Annotation of sys/dev/wscons/wsdisplay.c, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: wsdisplay.c,v 1.81 2007/07/25 23:11:52 art Exp $ */
! 2: /* $NetBSD: wsdisplay.c,v 1.82 2005/02/27 00:27:52 perry Exp $ */
! 3:
! 4: /*
! 5: * Copyright (c) 1996, 1997 Christopher G. Demetriou. All rights reserved.
! 6: *
! 7: * Redistribution and use in source and binary forms, with or without
! 8: * modification, are permitted provided that the following conditions
! 9: * are met:
! 10: * 1. Redistributions of source code must retain the above copyright
! 11: * notice, this list of conditions and the following disclaimer.
! 12: * 2. Redistributions in binary form must reproduce the above copyright
! 13: * notice, this list of conditions and the following disclaimer in the
! 14: * documentation and/or other materials provided with the distribution.
! 15: * 3. All advertising materials mentioning features or use of this software
! 16: * must display the following acknowledgement:
! 17: * This product includes software developed by Christopher G. Demetriou
! 18: * for the NetBSD Project.
! 19: * 4. The name of the author may not be used to endorse or promote products
! 20: * derived from this software without specific prior written permission
! 21: *
! 22: * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
! 23: * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
! 24: * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
! 25: * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
! 26: * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
! 27: * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! 28: * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! 29: * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 30: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
! 31: * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
! 32: */
! 33:
! 34: #ifndef SMALL_KERNEL
! 35: #define WSMOUSED_SUPPORT
! 36: #define BURNER_SUPPORT
! 37: #define SCROLLBACK_SUPPORT
! 38: #endif
! 39:
! 40: #include <sys/param.h>
! 41: #include <sys/conf.h>
! 42: #include <sys/device.h>
! 43: #include <sys/ioctl.h>
! 44: #include <sys/kernel.h>
! 45: #include <sys/proc.h>
! 46: #include <sys/malloc.h>
! 47: #include <sys/syslog.h>
! 48: #include <sys/systm.h>
! 49: #include <sys/tty.h>
! 50: #include <sys/signalvar.h>
! 51: #include <sys/errno.h>
! 52: #include <sys/fcntl.h>
! 53: #include <sys/vnode.h>
! 54: #include <sys/timeout.h>
! 55: #include <sys/poll.h>
! 56:
! 57: #include <dev/wscons/wsconsio.h>
! 58: #include <dev/wscons/wsdisplayvar.h>
! 59: #include <dev/wscons/wsksymvar.h>
! 60: #include <dev/wscons/wsksymdef.h>
! 61: #include <dev/wscons/wsemulvar.h>
! 62: #include <dev/wscons/wscons_callbacks.h>
! 63: #include <dev/cons.h>
! 64:
! 65: #include "wsdisplay.h"
! 66: #include "wskbd.h"
! 67: #include "wsmouse.h"
! 68: #include "wsmux.h"
! 69:
! 70: #if NWSKBD > 0
! 71: #include <dev/wscons/wseventvar.h>
! 72: #include <dev/wscons/wsmuxvar.h>
! 73: #endif
! 74:
! 75: #if NWSMOUSE > 0
! 76: #include <dev/wscons/wsmousevar.h>
! 77: #endif
! 78:
! 79: #include "wsmoused.h"
! 80:
! 81: #if NWSMOUSE > 0
! 82: extern struct cfdriver wsmouse_cd;
! 83: #endif /* NWSMOUSE > 0 */
! 84:
! 85: struct wsscreen_internal {
! 86: const struct wsdisplay_emulops *emulops;
! 87: void *emulcookie;
! 88:
! 89: const struct wsscreen_descr *scrdata;
! 90:
! 91: const struct wsemul_ops *wsemul;
! 92: void *wsemulcookie;
! 93: };
! 94:
! 95: struct wsscreen {
! 96: struct wsscreen_internal *scr_dconf;
! 97:
! 98: struct tty *scr_tty;
! 99: int scr_hold_screen; /* hold tty output */
! 100:
! 101: int scr_flags;
! 102: #define SCR_OPEN 1 /* is it open? */
! 103: #define SCR_WAITACTIVE 2 /* someone waiting on activation */
! 104: #define SCR_GRAPHICS 4 /* graphics mode, no text (emulation) output */
! 105: #define SCR_DUMBFB 8 /* in use as dumb fb (iff SCR_GRAPHICS) */
! 106:
! 107: #ifdef WSDISPLAY_COMPAT_USL
! 108: const struct wscons_syncops *scr_syncops;
! 109: void *scr_synccookie;
! 110: #endif
! 111:
! 112: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 113: int scr_rawkbd;
! 114: #endif
! 115:
! 116: struct wsdisplay_softc *sc;
! 117:
! 118: #ifdef WSMOUSED_SUPPORT
! 119: /* mouse console support via wsmoused(8) */
! 120: unsigned short mouse; /* mouse cursor position */
! 121: unsigned short cursor; /* selection cursor position (if
! 122: different from mouse cursor pos) */
! 123: unsigned short cpy_start; /* position of the copy start mark*/
! 124: unsigned short cpy_end; /* position of the copy end mark */
! 125: unsigned short orig_start; /* position of the original sel. start*/
! 126: unsigned short orig_end; /* position of the original sel. end */
! 127: #define MOUSE_VISIBLE (1 << 0) /* flag, the mouse cursor is visible */
! 128: #define SEL_EXISTS (1 << 1) /* flag, a selection exists */
! 129: #define SEL_IN_PROGRESS (1 << 2) /* flag, a selection is in progress */
! 130: #define SEL_EXT_AFTER (1 << 3) /* flag, selection is extended after */
! 131: #define BLANK_TO_EOL (1 << 4) /* flag, there are only blanks
! 132: characters to eol */
! 133: #define SEL_BY_CHAR (1 << 5) /* flag, select character by character*/
! 134: #define SEL_BY_WORD (1 << 6) /* flag, select word by word */
! 135: #define SEL_BY_LINE (1 << 7) /* flag, select line by line */
! 136:
! 137: #define IS_MOUSE_VISIBLE(ws) ((ws)->mouse_flags & MOUSE_VISIBLE)
! 138: #define IS_SEL_EXISTS(ws) ((ws)->mouse_flags & SEL_EXISTS)
! 139: #define IS_SEL_IN_PROGRESS(ws) ((ws)->mouse_flags & SEL_IN_PROGRESS)
! 140: #define IS_SEL_EXT_AFTER(ws) ((ws)->mouse_flags & SEL_EXT_AFTER)
! 141: #define IS_BLANK_TO_EOL(ws) ((ws)->mouse_flags & BLANK_TO_EOL)
! 142: #define IS_SEL_BY_CHAR(ws) ((ws)->mouse_flags & SEL_BY_CHAR)
! 143: #define IS_SEL_BY_WORD(ws) ((ws)->mouse_flags & SEL_BY_WORD)
! 144: #define IS_SEL_BY_LINE(ws) ((ws)->mouse_flags & SEL_BY_LINE)
! 145: unsigned char mouse_flags; /* flags, status of the mouse */
! 146: #endif /* WSMOUSED_SUPPORT */
! 147: };
! 148:
! 149: struct wsscreen *wsscreen_attach(struct wsdisplay_softc *, int, const char *,
! 150: const struct wsscreen_descr *, void *, int, int, long);
! 151: void wsscreen_detach(struct wsscreen *);
! 152: int wsdisplay_addscreen(struct wsdisplay_softc *, int, const char *,
! 153: const char *);
! 154: int wsdisplay_getscreen(struct wsdisplay_softc *,
! 155: struct wsdisplay_addscreendata *);
! 156: void wsdisplay_shutdownhook(void *);
! 157: void wsdisplay_addscreen_print(struct wsdisplay_softc *, int, int);
! 158: void wsdisplay_closescreen(struct wsdisplay_softc *, struct wsscreen *);
! 159: int wsdisplay_delscreen(struct wsdisplay_softc *, int, int);
! 160: void wsdisplay_burner(void *v);
! 161:
! 162: struct wsdisplay_softc {
! 163: struct device sc_dv;
! 164:
! 165: const struct wsdisplay_accessops *sc_accessops;
! 166: void *sc_accesscookie;
! 167:
! 168: const struct wsscreen_list *sc_scrdata;
! 169:
! 170: struct wsscreen *sc_scr[WSDISPLAY_MAXSCREEN];
! 171: int sc_focusidx; /* available only if sc_focus isn't null */
! 172: struct wsscreen *sc_focus;
! 173:
! 174: #ifdef BURNER_SUPPORT
! 175: struct timeout sc_burner;
! 176: int sc_burnoutintvl;
! 177: int sc_burninintvl;
! 178: int sc_burnout;
! 179: int sc_burnman;
! 180: int sc_burnflags;
! 181: #endif
! 182:
! 183: struct wsdisplay_font sc_fonts[WSDISPLAY_MAXFONT];
! 184:
! 185: int sc_isconsole;
! 186:
! 187: int sc_flags;
! 188: #define SC_SWITCHPENDING 1
! 189: int sc_screenwanted, sc_oldscreen; /* valid with SC_SWITCHPENDING */
! 190:
! 191: #if NWSKBD > 0
! 192: struct wsevsrc *sc_input;
! 193: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 194: int sc_rawkbd;
! 195: #endif
! 196: #endif /* NWSKBD > 0 */
! 197:
! 198: #ifdef WSMOUSED_SUPPORT
! 199: dev_t wsmoused_dev; /* device opened by wsmoused(8), when active */
! 200: int wsmoused_sleep; /* true when wsmoused(8) is sleeping */
! 201: #endif
! 202: };
! 203:
! 204: extern struct cfdriver wsdisplay_cd;
! 205:
! 206: /* Autoconfiguration definitions. */
! 207: int wsdisplay_emul_match(struct device *, void *, void *);
! 208: void wsdisplay_emul_attach(struct device *, struct device *, void *);
! 209: int wsdisplay_emul_detach(struct device *, int);
! 210:
! 211: struct cfdriver wsdisplay_cd = {
! 212: NULL, "wsdisplay", DV_TTY
! 213: };
! 214:
! 215: struct cfattach wsdisplay_emul_ca = {
! 216: sizeof(struct wsdisplay_softc), wsdisplay_emul_match,
! 217: wsdisplay_emul_attach, wsdisplay_emul_detach
! 218: };
! 219:
! 220: void wsdisplaystart(struct tty *);
! 221: int wsdisplayparam(struct tty *, struct termios *);
! 222:
! 223: /* Internal macros, functions, and variables. */
! 224: #define WSDISPLAYUNIT(dev) (minor(dev) >> 8)
! 225: #define WSDISPLAYSCREEN(dev) (minor(dev) & 0xff)
! 226: #define ISWSDISPLAYCTL(dev) (WSDISPLAYSCREEN(dev) == 255)
! 227: #define WSDISPLAYMINOR(unit, screen) (((unit) << 8) | (screen))
! 228:
! 229: #define WSSCREEN_HAS_TTY(scr) ((scr)->scr_tty != NULL)
! 230:
! 231: void wsdisplay_common_attach(struct wsdisplay_softc *sc,
! 232: int console, int mux, const struct wsscreen_list *,
! 233: const struct wsdisplay_accessops *accessops,
! 234: void *accesscookie, u_int defaultscreens);
! 235: int wsdisplay_common_detach(struct wsdisplay_softc *, int);
! 236:
! 237: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 238: int wsdisplay_update_rawkbd(struct wsdisplay_softc *, struct wsscreen *);
! 239: #endif
! 240:
! 241: int wsdisplay_console_initted;
! 242: struct wsdisplay_softc *wsdisplay_console_device;
! 243: struct wsscreen_internal wsdisplay_console_conf;
! 244:
! 245: int wsdisplay_getc_dummy(dev_t);
! 246: void wsdisplay_pollc(dev_t, int);
! 247:
! 248: int wsdisplay_cons_pollmode;
! 249: void (*wsdisplay_cons_kbd_pollc)(dev_t, int);
! 250:
! 251: struct consdev wsdisplay_cons = {
! 252: NULL, NULL, wsdisplay_getc_dummy, wsdisplay_cnputc,
! 253: wsdisplay_pollc, NULL, NODEV, CN_NORMAL
! 254: };
! 255:
! 256: #ifndef WSDISPLAY_DEFAULTSCREENS
! 257: #define WSDISPLAY_DEFAULTSCREENS 1
! 258: #endif
! 259: int wsdisplay_defaultscreens = WSDISPLAY_DEFAULTSCREENS;
! 260:
! 261: int wsdisplay_switch1(void *, int, int);
! 262: int wsdisplay_switch2(void *, int, int);
! 263: int wsdisplay_switch3(void *, int, int);
! 264:
! 265: int wsdisplay_clearonclose;
! 266:
! 267: #ifdef WSMOUSED_SUPPORT
! 268: char *Copybuffer;
! 269: u_int Copybuffer_size;
! 270: char Paste_avail;
! 271: #endif
! 272:
! 273: struct wsscreen *
! 274: wsscreen_attach(struct wsdisplay_softc *sc, int console, const char *emul,
! 275: const struct wsscreen_descr *type, void *cookie, int ccol, int crow,
! 276: long defattr)
! 277: {
! 278: struct wsscreen_internal *dconf;
! 279: struct wsscreen *scr;
! 280:
! 281: scr = malloc(sizeof(struct wsscreen), M_DEVBUF, M_NOWAIT);
! 282: if (!scr)
! 283: return (NULL);
! 284:
! 285: if (console) {
! 286: dconf = &wsdisplay_console_conf;
! 287: /*
! 288: * Tell the emulation about the callback argument.
! 289: * The other stuff is already there.
! 290: */
! 291: (void)(*dconf->wsemul->attach)(1, 0, 0, 0, 0, scr, 0);
! 292: } else { /* not console */
! 293: dconf = malloc(sizeof(struct wsscreen_internal),
! 294: M_DEVBUF, M_NOWAIT);
! 295: if (dconf == NULL)
! 296: goto fail;
! 297: dconf->emulops = type->textops;
! 298: dconf->emulcookie = cookie;
! 299: if (dconf->emulops == NULL ||
! 300: (dconf->wsemul = wsemul_pick(emul)) == NULL)
! 301: goto fail;
! 302: dconf->wsemulcookie = (*dconf->wsemul->attach)(0, type, cookie,
! 303: ccol, crow, scr, defattr);
! 304: if (dconf->wsemulcookie == NULL)
! 305: goto fail;
! 306: dconf->scrdata = type;
! 307: }
! 308:
! 309: scr->scr_dconf = dconf;
! 310:
! 311: scr->scr_tty = ttymalloc();
! 312: scr->scr_hold_screen = 0;
! 313: scr->scr_flags = 0;
! 314:
! 315: #ifdef WSDISPLAY_COMPAT_USL
! 316: scr->scr_syncops = NULL;
! 317: #endif
! 318:
! 319: scr->sc = sc;
! 320: #ifdef WSMOUSED_SUPPORT
! 321: scr->mouse_flags = 0;
! 322: #endif
! 323: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 324: scr->scr_rawkbd = 0;
! 325: #endif
! 326: return (scr);
! 327:
! 328: fail:
! 329: if (dconf != NULL)
! 330: free(dconf, M_DEVBUF);
! 331: free(scr, M_DEVBUF);
! 332: return (NULL);
! 333: }
! 334:
! 335: void
! 336: wsscreen_detach(struct wsscreen *scr)
! 337: {
! 338: int ccol, crow; /* XXX */
! 339:
! 340: if (WSSCREEN_HAS_TTY(scr)) {
! 341: timeout_del(&scr->scr_tty->t_rstrt_to);
! 342: ttyfree(scr->scr_tty);
! 343: }
! 344: (*scr->scr_dconf->wsemul->detach)(scr->scr_dconf->wsemulcookie,
! 345: &ccol, &crow);
! 346: free(scr->scr_dconf, M_DEVBUF);
! 347: free(scr, M_DEVBUF);
! 348: }
! 349:
! 350: const struct wsscreen_descr *
! 351: wsdisplay_screentype_pick(const struct wsscreen_list *scrdata, const char *name)
! 352: {
! 353: int i;
! 354: const struct wsscreen_descr *scr;
! 355:
! 356: KASSERT(scrdata->nscreens > 0);
! 357:
! 358: if (name == NULL || *name == '\0')
! 359: return (scrdata->screens[0]);
! 360:
! 361: for (i = 0; i < scrdata->nscreens; i++) {
! 362: scr = scrdata->screens[i];
! 363: if (!strncmp(name, scr->name, WSSCREEN_NAME_SIZE))
! 364: return (scr);
! 365: }
! 366:
! 367: return (0);
! 368: }
! 369:
! 370: /*
! 371: * print info about attached screen
! 372: */
! 373: void
! 374: wsdisplay_addscreen_print(struct wsdisplay_softc *sc, int idx, int count)
! 375: {
! 376: printf("%s: screen %d", sc->sc_dv.dv_xname, idx);
! 377: if (count > 1)
! 378: printf("-%d", idx + (count-1));
! 379: printf(" added (%s, %s emulation)\n",
! 380: sc->sc_scr[idx]->scr_dconf->scrdata->name,
! 381: sc->sc_scr[idx]->scr_dconf->wsemul->name);
! 382: }
! 383:
! 384: int
! 385: wsdisplay_addscreen(struct wsdisplay_softc *sc, int idx,
! 386: const char *screentype, const char *emul)
! 387: {
! 388: const struct wsscreen_descr *scrdesc;
! 389: int error;
! 390: void *cookie;
! 391: int ccol, crow;
! 392: long defattr;
! 393: struct wsscreen *scr;
! 394: int s;
! 395:
! 396: if (idx < 0 || idx >= WSDISPLAY_MAXSCREEN)
! 397: return (EINVAL);
! 398: if (sc->sc_scr[idx] != NULL)
! 399: return (EBUSY);
! 400:
! 401: scrdesc = wsdisplay_screentype_pick(sc->sc_scrdata, screentype);
! 402: if (!scrdesc)
! 403: return (ENXIO);
! 404: error = (*sc->sc_accessops->alloc_screen)(sc->sc_accesscookie,
! 405: scrdesc, &cookie, &ccol, &crow, &defattr);
! 406: if (error)
! 407: return (error);
! 408:
! 409: scr = wsscreen_attach(sc, 0, emul, scrdesc,
! 410: cookie, ccol, crow, defattr);
! 411: if (scr == NULL) {
! 412: (*sc->sc_accessops->free_screen)(sc->sc_accesscookie, cookie);
! 413: return (ENXIO);
! 414: }
! 415:
! 416: sc->sc_scr[idx] = scr;
! 417:
! 418: /* if no screen has focus yet, activate the first we get */
! 419: s = spltty();
! 420: if (!sc->sc_focus) {
! 421: (*sc->sc_accessops->show_screen)(sc->sc_accesscookie,
! 422: scr->scr_dconf->emulcookie, 0, 0, 0);
! 423: sc->sc_focusidx = idx;
! 424: sc->sc_focus = scr;
! 425: }
! 426: splx(s);
! 427:
! 428: #ifdef WSMOUSED_SUPPORT
! 429: allocate_copybuffer(sc); /* enlarge the copy buffer is necessary */
! 430: #endif
! 431: return (0);
! 432: }
! 433:
! 434: int
! 435: wsdisplay_getscreen(struct wsdisplay_softc *sc,
! 436: struct wsdisplay_addscreendata *sd)
! 437: {
! 438: struct wsscreen *scr;
! 439:
! 440: if (sd->idx < 0 && sc->sc_focus)
! 441: sd->idx = sc->sc_focusidx;
! 442:
! 443: if (sd->idx < 0 || sd->idx >= WSDISPLAY_MAXSCREEN)
! 444: return (EINVAL);
! 445:
! 446: scr = sc->sc_scr[sd->idx];
! 447: if (scr == NULL)
! 448: return (ENXIO);
! 449:
! 450: strncpy(sd->screentype, scr->scr_dconf->scrdata->name,
! 451: WSSCREEN_NAME_SIZE);
! 452: strncpy(sd->emul, scr->scr_dconf->wsemul->name, WSEMUL_NAME_SIZE);
! 453:
! 454: return (0);
! 455: }
! 456:
! 457: void
! 458: wsdisplay_closescreen(struct wsdisplay_softc *sc, struct wsscreen *scr)
! 459: {
! 460: int maj, mn, idx;
! 461:
! 462: /* hangup */
! 463: if (WSSCREEN_HAS_TTY(scr)) {
! 464: struct tty *tp = scr->scr_tty;
! 465: (*linesw[tp->t_line].l_modem)(tp, 0);
! 466: }
! 467:
! 468: /* locate the major number */
! 469: for (maj = 0; maj < nchrdev; maj++)
! 470: if (cdevsw[maj].d_open == wsdisplayopen)
! 471: break;
! 472: /* locate the screen index */
! 473: for (idx = 0; idx < WSDISPLAY_MAXSCREEN; idx++)
! 474: if (scr == sc->sc_scr[idx])
! 475: break;
! 476: #ifdef DIAGNOSTIC
! 477: if (idx == WSDISPLAY_MAXSCREEN)
! 478: panic("wsdisplay_forceclose: bad screen");
! 479: #endif
! 480:
! 481: /* nuke the vnodes */
! 482: mn = WSDISPLAYMINOR(sc->sc_dv.dv_unit, idx);
! 483: vdevgone(maj, mn, mn, VCHR);
! 484: }
! 485:
! 486: int
! 487: wsdisplay_delscreen(struct wsdisplay_softc *sc, int idx, int flags)
! 488: {
! 489: struct wsscreen *scr;
! 490: int s;
! 491: void *cookie;
! 492:
! 493: if (idx < 0 || idx >= WSDISPLAY_MAXSCREEN)
! 494: return (EINVAL);
! 495: if ((scr = sc->sc_scr[idx]) == NULL)
! 496: return (ENXIO);
! 497:
! 498: if (scr->scr_dconf == &wsdisplay_console_conf ||
! 499: #ifdef WSDISPLAY_COMPAT_USL
! 500: scr->scr_syncops ||
! 501: #endif
! 502: ((scr->scr_flags & SCR_OPEN) && !(flags & WSDISPLAY_DELSCR_FORCE)))
! 503: return (EBUSY);
! 504:
! 505: wsdisplay_closescreen(sc, scr);
! 506:
! 507: /*
! 508: * delete pointers, so neither device entries
! 509: * nor keyboard input can reference it anymore
! 510: */
! 511: s = spltty();
! 512: if (sc->sc_focus == scr) {
! 513: sc->sc_focus = 0;
! 514: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 515: wsdisplay_update_rawkbd(sc, 0);
! 516: #endif
! 517: }
! 518: sc->sc_scr[idx] = 0;
! 519: splx(s);
! 520:
! 521: /*
! 522: * Wake up processes waiting for the screen to
! 523: * be activated. Sleepers must check whether
! 524: * the screen still exists.
! 525: */
! 526: if (scr->scr_flags & SCR_WAITACTIVE)
! 527: wakeup(scr);
! 528:
! 529: /* save a reference to the graphics screen */
! 530: cookie = scr->scr_dconf->emulcookie;
! 531:
! 532: wsscreen_detach(scr);
! 533:
! 534: (*sc->sc_accessops->free_screen)(sc->sc_accesscookie, cookie);
! 535:
! 536: if ((flags & WSDISPLAY_DELSCR_QUIET) == 0)
! 537: printf("%s: screen %d deleted\n", sc->sc_dv.dv_xname, idx);
! 538: return (0);
! 539: }
! 540:
! 541: /*
! 542: * Autoconfiguration functions.
! 543: */
! 544: int
! 545: wsdisplay_emul_match(struct device *parent, void *match, void *aux)
! 546: {
! 547: struct cfdata *cf = match;
! 548: struct wsemuldisplaydev_attach_args *ap = aux;
! 549:
! 550: if (cf->wsemuldisplaydevcf_console != WSEMULDISPLAYDEVCF_CONSOLE_UNK) {
! 551: /*
! 552: * If console-ness of device specified, either match
! 553: * exactly (at high priority), or fail.
! 554: */
! 555: if (cf->wsemuldisplaydevcf_console != 0 && ap->console != 0)
! 556: return (10);
! 557: else
! 558: return (0);
! 559: }
! 560:
! 561: /* If console-ness unspecified, it wins. */
! 562: return (1);
! 563: }
! 564:
! 565: void
! 566: wsdisplay_emul_attach(struct device *parent, struct device *self, void *aux)
! 567: {
! 568: struct wsdisplay_softc *sc = (struct wsdisplay_softc *)self;
! 569: struct wsemuldisplaydev_attach_args *ap = aux;
! 570:
! 571: wsdisplay_common_attach(sc, ap->console,
! 572: sc->sc_dv.dv_cfdata->wsemuldisplaydevcf_mux, ap->scrdata,
! 573: ap->accessops, ap->accesscookie, ap->defaultscreens);
! 574:
! 575: if (ap->console && cn_tab == &wsdisplay_cons) {
! 576: int maj;
! 577:
! 578: /* locate the major number */
! 579: for (maj = 0; maj < nchrdev; maj++)
! 580: if (cdevsw[maj].d_open == wsdisplayopen)
! 581: break;
! 582:
! 583: cn_tab->cn_dev = makedev(maj, WSDISPLAYMINOR(self->dv_unit, 0));
! 584: }
! 585: }
! 586:
! 587: /*
! 588: * Detach a display.
! 589: */
! 590: int
! 591: wsdisplay_emul_detach(struct device *self, int flags)
! 592: {
! 593: struct wsdisplay_softc *sc = (struct wsdisplay_softc *)self;
! 594:
! 595: return (wsdisplay_common_detach(sc, flags));
! 596: }
! 597:
! 598: int
! 599: wsdisplay_common_detach(struct wsdisplay_softc *sc, int flags)
! 600: {
! 601: int i;
! 602: int rc;
! 603:
! 604: /* We don't support detaching the console display yet. */
! 605: if (sc->sc_isconsole)
! 606: return (EBUSY);
! 607:
! 608: /* Delete all screens managed by this display */
! 609: for (i = 0; i < WSDISPLAY_MAXSCREEN; i++)
! 610: if (sc->sc_scr[i] != NULL) {
! 611: if ((rc = wsdisplay_delscreen(sc, i,
! 612: WSDISPLAY_DELSCR_QUIET | (flags & DETACH_FORCE ?
! 613: WSDISPLAY_DELSCR_FORCE : 0))) != 0)
! 614: return (rc);
! 615: }
! 616:
! 617: #ifdef BURNER_SUPPORT
! 618: timeout_del(&sc->sc_burner);
! 619: #endif
! 620:
! 621: #if NWSKBD > 0
! 622: if (sc->sc_input != NULL) {
! 623: #if NWSMUX > 0
! 624: wsmux_detach_sc(sc->sc_input); /* XXX not exactly correct */
! 625: /*
! 626: * XXX
! 627: * If we created a standalone mux (dmux), we should destroy it
! 628: * there, but there is currently no support for this in wsmux.
! 629: */
! 630: #else
! 631: if ((rc = wskbd_set_display((struct device *)sc->sc_input,
! 632: NULL)) != 0)
! 633: return (rc);
! 634: #endif
! 635: }
! 636: #endif
! 637:
! 638: return (0);
! 639: }
! 640:
! 641: /* Print function (for parent devices). */
! 642: int
! 643: wsemuldisplaydevprint(void *aux, const char *pnp)
! 644: {
! 645: #if 0 /* -Wunused */
! 646: struct wsemuldisplaydev_attach_args *ap = aux;
! 647: #endif
! 648:
! 649: if (pnp)
! 650: printf("wsdisplay at %s", pnp);
! 651: #if 0 /* don't bother; it's ugly */
! 652: printf(" console %d", ap->console);
! 653: #endif
! 654:
! 655: return (UNCONF);
! 656: }
! 657:
! 658: void
! 659: wsdisplay_common_attach(struct wsdisplay_softc *sc, int console, int kbdmux,
! 660: const struct wsscreen_list *scrdata,
! 661: const struct wsdisplay_accessops *accessops, void *accesscookie,
! 662: u_int defaultscreens)
! 663: {
! 664: static int hookset = 0;
! 665: int i, start = 0;
! 666: #if NWSKBD > 0
! 667: struct wsevsrc *kme;
! 668: #if NWSMUX > 0
! 669: struct wsmux_softc *mux;
! 670:
! 671: if (kbdmux >= 0)
! 672: mux = wsmux_getmux(kbdmux);
! 673: else
! 674: mux = wsmux_create("dmux", sc->sc_dv.dv_unit);
! 675: /* XXX panic()ing isn't nice, but attach cannot fail */
! 676: if (mux == NULL)
! 677: panic("wsdisplay_common_attach: no memory");
! 678: sc->sc_input = &mux->sc_base;
! 679: mux->sc_displaydv = &sc->sc_dv;
! 680: if (kbdmux >= 0)
! 681: printf(" mux %d", kbdmux);
! 682: #else
! 683: #if 0 /* not worth keeping, especially since the default value is not -1... */
! 684: if (kbdmux >= 0)
! 685: printf(" (mux ignored)");
! 686: #endif
! 687: #endif /* NWSMUX > 0 */
! 688: #endif /* NWSKBD > 0 */
! 689:
! 690: sc->sc_isconsole = console;
! 691:
! 692: if (console) {
! 693: KASSERT(wsdisplay_console_initted);
! 694: KASSERT(wsdisplay_console_device == NULL);
! 695:
! 696: sc->sc_scr[0] = wsscreen_attach(sc, 1, 0, 0, 0, 0, 0, 0);
! 697: if (sc->sc_scr[0] == NULL)
! 698: return;
! 699: wsdisplay_console_device = sc;
! 700:
! 701: printf(": console (%s, %s emulation)",
! 702: wsdisplay_console_conf.scrdata->name,
! 703: wsdisplay_console_conf.wsemul->name);
! 704:
! 705: #if NWSKBD > 0
! 706: kme = wskbd_set_console_display(&sc->sc_dv, sc->sc_input);
! 707: if (kme != NULL)
! 708: printf(", using %s", kme->me_dv.dv_xname);
! 709: #if NWSMUX == 0
! 710: sc->sc_input = kme;
! 711: #endif
! 712: #endif
! 713:
! 714: sc->sc_focusidx = 0;
! 715: sc->sc_focus = sc->sc_scr[0];
! 716: start = 1;
! 717: }
! 718: printf("\n");
! 719:
! 720: #if NWSKBD > 0 && NWSMUX > 0
! 721: wsmux_set_display(mux, &sc->sc_dv);
! 722: #endif
! 723:
! 724: sc->sc_accessops = accessops;
! 725: sc->sc_accesscookie = accesscookie;
! 726: sc->sc_scrdata = scrdata;
! 727:
! 728: /*
! 729: * Set up a number of virtual screens if wanted. The
! 730: * WSDISPLAYIO_ADDSCREEN ioctl is more flexible, so this code
! 731: * is for special cases like installation kernels, as well as
! 732: * sane multihead defaults.
! 733: */
! 734: if (defaultscreens == 0)
! 735: defaultscreens = wsdisplay_defaultscreens;
! 736: for (i = start; i < defaultscreens; i++) {
! 737: if (wsdisplay_addscreen(sc, i, 0, 0))
! 738: break;
! 739: }
! 740:
! 741: if (i > start)
! 742: wsdisplay_addscreen_print(sc, start, i-start);
! 743:
! 744: #ifdef BURNER_SUPPORT
! 745: sc->sc_burnoutintvl = (hz * WSDISPLAY_DEFBURNOUT) / 1000;
! 746: sc->sc_burninintvl = (hz * WSDISPLAY_DEFBURNIN ) / 1000;
! 747: sc->sc_burnflags = 0; /* off by default */
! 748: timeout_set(&sc->sc_burner, wsdisplay_burner, sc);
! 749: sc->sc_burnout = sc->sc_burnoutintvl;
! 750: wsdisplay_burn(sc, sc->sc_burnflags);
! 751: #endif
! 752:
! 753: if (hookset == 0)
! 754: shutdownhook_establish(wsdisplay_shutdownhook, NULL);
! 755: hookset = 1;
! 756:
! 757: #if NWSKBD > 0 && NWSMUX == 0
! 758: if (console == 0) {
! 759: /*
! 760: * In the non-wsmux world, always connect wskbd0 and wsdisplay0
! 761: * together.
! 762: */
! 763: extern struct cfdriver wskbd_cd;
! 764:
! 765: if (wskbd_cd.cd_ndevs != 0 && sc->sc_dv.dv_unit == 0) {
! 766: if (wsdisplay_set_kbd(&sc->sc_dv,
! 767: (struct wsevsrc *)wskbd_cd.cd_devs[0]) == 0)
! 768: wskbd_set_display(wskbd_cd.cd_devs[0],
! 769: &sc->sc_dv);
! 770: }
! 771: }
! 772: #endif
! 773: }
! 774:
! 775: void
! 776: wsdisplay_cnattach(const struct wsscreen_descr *type, void *cookie, int ccol,
! 777: int crow, long defattr)
! 778: {
! 779: const struct wsemul_ops *wsemul;
! 780: const struct wsdisplay_emulops *emulops;
! 781:
! 782: KASSERT(!wsdisplay_console_initted);
! 783: KASSERT(type->nrows > 0);
! 784: KASSERT(type->ncols > 0);
! 785: KASSERT(crow < type->nrows);
! 786: KASSERT(ccol < type->ncols);
! 787:
! 788: wsdisplay_console_conf.emulops = emulops = type->textops;
! 789: wsdisplay_console_conf.emulcookie = cookie;
! 790: wsdisplay_console_conf.scrdata = type;
! 791:
! 792: #ifdef WSEMUL_DUMB
! 793: /*
! 794: * If the emulops structure is crippled, force a dumb emulation.
! 795: */
! 796: if (emulops->cursor == NULL ||
! 797: emulops->copycols == NULL || emulops->copyrows == NULL ||
! 798: emulops->erasecols == NULL || emulops->eraserows == NULL)
! 799: wsemul = wsemul_pick("dumb");
! 800: else
! 801: #endif
! 802: wsemul = wsemul_pick("");
! 803: wsdisplay_console_conf.wsemul = wsemul;
! 804: wsdisplay_console_conf.wsemulcookie =
! 805: (*wsemul->cnattach)(type, cookie, ccol, crow, defattr);
! 806:
! 807: cn_tab = &wsdisplay_cons;
! 808:
! 809: wsdisplay_console_initted = 1;
! 810: }
! 811:
! 812: /*
! 813: * Tty and cdevsw functions.
! 814: */
! 815: int
! 816: wsdisplayopen(dev_t dev, int flag, int mode, struct proc *p)
! 817: {
! 818: struct wsdisplay_softc *sc;
! 819: struct tty *tp;
! 820: int unit, newopen, error;
! 821: struct wsscreen *scr;
! 822:
! 823: unit = WSDISPLAYUNIT(dev);
! 824: if (unit >= wsdisplay_cd.cd_ndevs || /* make sure it was attached */
! 825: (sc = wsdisplay_cd.cd_devs[unit]) == NULL)
! 826: return (ENXIO);
! 827:
! 828: if (ISWSDISPLAYCTL(dev))
! 829: return (0);
! 830:
! 831: if (WSDISPLAYSCREEN(dev) >= WSDISPLAY_MAXSCREEN)
! 832: return (ENXIO);
! 833: if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
! 834: return (ENXIO);
! 835:
! 836: if (WSSCREEN_HAS_TTY(scr)) {
! 837: tp = scr->scr_tty;
! 838: tp->t_oproc = wsdisplaystart;
! 839: tp->t_param = wsdisplayparam;
! 840: tp->t_dev = dev;
! 841: newopen = (tp->t_state & TS_ISOPEN) == 0;
! 842: if (newopen) {
! 843: ttychars(tp);
! 844: tp->t_iflag = TTYDEF_IFLAG;
! 845: tp->t_oflag = TTYDEF_OFLAG;
! 846: tp->t_cflag = TTYDEF_CFLAG;
! 847: tp->t_lflag = TTYDEF_LFLAG;
! 848: tp->t_ispeed = tp->t_ospeed = TTYDEF_SPEED;
! 849: wsdisplayparam(tp, &tp->t_termios);
! 850: ttsetwater(tp);
! 851: } else if ((tp->t_state & TS_XCLUDE) != 0 &&
! 852: p->p_ucred->cr_uid != 0)
! 853: return (EBUSY);
! 854: tp->t_state |= TS_CARR_ON;
! 855:
! 856: error = ((*linesw[tp->t_line].l_open)(dev, tp));
! 857: if (error)
! 858: return (error);
! 859:
! 860: if (newopen) {
! 861: /* set window sizes as appropriate, and reset
! 862: the emulation */
! 863: tp->t_winsize.ws_row = scr->scr_dconf->scrdata->nrows;
! 864: tp->t_winsize.ws_col = scr->scr_dconf->scrdata->ncols;
! 865: }
! 866: }
! 867:
! 868: scr->scr_flags |= SCR_OPEN;
! 869: return (0);
! 870: }
! 871:
! 872: int
! 873: wsdisplayclose(dev_t dev, int flag, int mode, struct proc *p)
! 874: {
! 875: struct wsdisplay_softc *sc;
! 876: struct tty *tp;
! 877: int unit;
! 878: struct wsscreen *scr;
! 879:
! 880: unit = WSDISPLAYUNIT(dev);
! 881: sc = wsdisplay_cd.cd_devs[unit];
! 882:
! 883: if (ISWSDISPLAYCTL(dev))
! 884: return (0);
! 885:
! 886: if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
! 887: return (ENXIO);
! 888:
! 889: if (WSSCREEN_HAS_TTY(scr)) {
! 890: if (scr->scr_hold_screen) {
! 891: int s;
! 892:
! 893: /* XXX RESET KEYBOARD LEDS, etc. */
! 894: s = spltty(); /* avoid conflict with keyboard */
! 895: wsdisplay_kbdholdscreen((struct device *)sc, 0);
! 896: splx(s);
! 897: }
! 898: tp = scr->scr_tty;
! 899: (*linesw[tp->t_line].l_close)(tp, flag);
! 900: ttyclose(tp);
! 901: }
! 902:
! 903: #ifdef WSDISPLAY_COMPAT_USL
! 904: if (scr->scr_syncops)
! 905: (*scr->scr_syncops->destroy)(scr->scr_synccookie);
! 906: #endif
! 907:
! 908: scr->scr_flags &= ~SCR_GRAPHICS;
! 909: (*scr->scr_dconf->wsemul->reset)(scr->scr_dconf->wsemulcookie,
! 910: WSEMUL_RESET);
! 911: if (wsdisplay_clearonclose)
! 912: (*scr->scr_dconf->wsemul->reset)
! 913: (scr->scr_dconf->wsemulcookie, WSEMUL_CLEARSCREEN);
! 914:
! 915: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 916: if (scr->scr_rawkbd) {
! 917: int kbmode = WSKBD_TRANSLATED;
! 918: (void) wsdisplay_internal_ioctl(sc, scr, WSKBDIO_SETMODE,
! 919: (caddr_t)&kbmode, FWRITE, p);
! 920: }
! 921: #endif
! 922:
! 923: scr->scr_flags &= ~SCR_OPEN;
! 924:
! 925: #ifdef WSMOUSED_SUPPORT
! 926: /* remove the selection at logout */
! 927: if (Copybuffer)
! 928: bzero(Copybuffer, Copybuffer_size);
! 929: Paste_avail = 0;
! 930: #endif
! 931:
! 932: return (0);
! 933: }
! 934:
! 935: int
! 936: wsdisplayread(dev_t dev, struct uio *uio, int flag)
! 937: {
! 938: struct wsdisplay_softc *sc;
! 939: struct tty *tp;
! 940: int unit;
! 941: struct wsscreen *scr;
! 942:
! 943: unit = WSDISPLAYUNIT(dev);
! 944: sc = wsdisplay_cd.cd_devs[unit];
! 945:
! 946: if (ISWSDISPLAYCTL(dev))
! 947: return (0);
! 948:
! 949: if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
! 950: return (ENXIO);
! 951:
! 952: if (!WSSCREEN_HAS_TTY(scr))
! 953: return (ENODEV);
! 954:
! 955: tp = scr->scr_tty;
! 956: return ((*linesw[tp->t_line].l_read)(tp, uio, flag));
! 957: }
! 958:
! 959: int
! 960: wsdisplaywrite(dev_t dev, struct uio *uio, int flag)
! 961: {
! 962: struct wsdisplay_softc *sc;
! 963: struct tty *tp;
! 964: int unit;
! 965: struct wsscreen *scr;
! 966:
! 967: unit = WSDISPLAYUNIT(dev);
! 968: sc = wsdisplay_cd.cd_devs[unit];
! 969:
! 970: if (ISWSDISPLAYCTL(dev))
! 971: return (0);
! 972:
! 973: if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
! 974: return (ENXIO);
! 975:
! 976: if (!WSSCREEN_HAS_TTY(scr))
! 977: return (ENODEV);
! 978:
! 979: tp = scr->scr_tty;
! 980: return ((*linesw[tp->t_line].l_write)(tp, uio, flag));
! 981: }
! 982:
! 983: struct tty *
! 984: wsdisplaytty(dev_t dev)
! 985: {
! 986: struct wsdisplay_softc *sc;
! 987: int unit;
! 988: struct wsscreen *scr;
! 989:
! 990: unit = WSDISPLAYUNIT(dev);
! 991: sc = wsdisplay_cd.cd_devs[unit];
! 992:
! 993: if (ISWSDISPLAYCTL(dev))
! 994: panic("wsdisplaytty() on ctl device");
! 995:
! 996: if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
! 997: return (NULL);
! 998:
! 999: return (scr->scr_tty);
! 1000: }
! 1001:
! 1002: int
! 1003: wsdisplayioctl(dev_t dev, u_long cmd, caddr_t data, int flag, struct proc *p)
! 1004: {
! 1005: struct wsdisplay_softc *sc;
! 1006: struct tty *tp;
! 1007: int unit, error;
! 1008: struct wsscreen *scr;
! 1009:
! 1010: unit = WSDISPLAYUNIT(dev);
! 1011: sc = wsdisplay_cd.cd_devs[unit];
! 1012:
! 1013: #ifdef WSDISPLAY_COMPAT_USL
! 1014: error = wsdisplay_usl_ioctl1(sc, cmd, data, flag, p);
! 1015: if (error >= 0)
! 1016: return (error);
! 1017: #endif
! 1018:
! 1019: if (ISWSDISPLAYCTL(dev))
! 1020: return (wsdisplay_cfg_ioctl(sc, cmd, data, flag, p));
! 1021:
! 1022: if (WSDISPLAYSCREEN(dev) >= WSDISPLAY_MAXSCREEN)
! 1023: return (ENODEV);
! 1024:
! 1025: if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
! 1026: return (ENXIO);
! 1027:
! 1028: if (WSSCREEN_HAS_TTY(scr)) {
! 1029: tp = scr->scr_tty;
! 1030:
! 1031: /* printf("disc\n"); */
! 1032: /* do the line discipline ioctls first */
! 1033: error = (*linesw[tp->t_line].l_ioctl)(tp, cmd, data, flag, p);
! 1034: if (error >= 0)
! 1035: return (error);
! 1036:
! 1037: /* printf("tty\n"); */
! 1038: /* then the tty ioctls */
! 1039: error = ttioctl(tp, cmd, data, flag, p);
! 1040: if (error >= 0)
! 1041: return (error);
! 1042: }
! 1043:
! 1044: #ifdef WSDISPLAY_COMPAT_USL
! 1045: error = wsdisplay_usl_ioctl2(sc, scr, cmd, data, flag, p);
! 1046: if (error >= 0)
! 1047: return (error);
! 1048: #endif
! 1049:
! 1050: error = wsdisplay_internal_ioctl(sc, scr, cmd, data, flag, p);
! 1051: return (error != -1 ? error : ENOTTY);
! 1052: }
! 1053:
! 1054: int
! 1055: wsdisplay_param(struct device *dev, u_long cmd, struct wsdisplay_param *dp)
! 1056: {
! 1057: struct wsdisplay_softc *sc = (struct wsdisplay_softc *)dev;
! 1058:
! 1059: return ((*sc->sc_accessops->ioctl)(sc->sc_accesscookie, cmd,
! 1060: (caddr_t)dp, 0, NULL));
! 1061: }
! 1062:
! 1063: int
! 1064: wsdisplay_internal_ioctl(struct wsdisplay_softc *sc, struct wsscreen *scr,
! 1065: u_long cmd, caddr_t data, int flag, struct proc *p)
! 1066: {
! 1067: int error;
! 1068:
! 1069: #if NWSKBD > 0
! 1070: struct wsevsrc *inp;
! 1071:
! 1072: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 1073: switch (cmd) {
! 1074: case WSKBDIO_SETMODE:
! 1075: if ((flag & FWRITE) == 0)
! 1076: return (EACCES);
! 1077: scr->scr_rawkbd = (*(int *)data == WSKBD_RAW);
! 1078: return (wsdisplay_update_rawkbd(sc, scr));
! 1079: case WSKBDIO_GETMODE:
! 1080: *(int *)data = (scr->scr_rawkbd ?
! 1081: WSKBD_RAW : WSKBD_TRANSLATED);
! 1082: return (0);
! 1083: }
! 1084: #endif
! 1085: inp = sc->sc_input;
! 1086: if (inp != NULL) {
! 1087: error = wsevsrc_display_ioctl(inp, cmd, data, flag, p);
! 1088: if (error >= 0)
! 1089: return (error);
! 1090: }
! 1091: #endif /* NWSKBD > 0 */
! 1092:
! 1093: switch (cmd) {
! 1094: case WSDISPLAYIO_SMODE:
! 1095: case WSDISPLAYIO_USEFONT:
! 1096: #ifdef BURNER_SUPPORT
! 1097: case WSDISPLAYIO_SVIDEO:
! 1098: case WSDISPLAYIO_SBURNER:
! 1099: #endif
! 1100: case WSDISPLAYIO_SETSCREEN:
! 1101: if ((flag & FWRITE) == 0)
! 1102: return (EACCES);
! 1103: }
! 1104:
! 1105: switch (cmd) {
! 1106: case WSDISPLAYIO_GMODE:
! 1107: if (scr->scr_flags & SCR_GRAPHICS) {
! 1108: if (scr->scr_flags & SCR_DUMBFB)
! 1109: *(u_int *)data = WSDISPLAYIO_MODE_DUMBFB;
! 1110: else
! 1111: *(u_int *)data = WSDISPLAYIO_MODE_MAPPED;
! 1112: } else
! 1113: *(u_int *)data = WSDISPLAYIO_MODE_EMUL;
! 1114: return (0);
! 1115:
! 1116: case WSDISPLAYIO_SMODE:
! 1117: #define d (*(int *)data)
! 1118: if (d != WSDISPLAYIO_MODE_EMUL &&
! 1119: d != WSDISPLAYIO_MODE_MAPPED &&
! 1120: d != WSDISPLAYIO_MODE_DUMBFB)
! 1121: return (EINVAL);
! 1122:
! 1123: scr->scr_flags &= ~SCR_GRAPHICS;
! 1124: if (d == WSDISPLAYIO_MODE_MAPPED ||
! 1125: d == WSDISPLAYIO_MODE_DUMBFB) {
! 1126: scr->scr_flags |= SCR_GRAPHICS |
! 1127: ((d == WSDISPLAYIO_MODE_DUMBFB) ? SCR_DUMBFB : 0);
! 1128:
! 1129: #ifdef WSMOUSED_SUPPORT
! 1130: /*
! 1131: * wsmoused cohabitation with X-Window support
! 1132: * X-Window is starting
! 1133: */
! 1134: wsmoused_release(sc);
! 1135: #endif
! 1136:
! 1137: #ifdef BURNER_SUPPORT
! 1138: /* disable the burner while X is running */
! 1139: if (sc->sc_burnout)
! 1140: timeout_del(&sc->sc_burner);
! 1141: #endif
! 1142: } else {
! 1143: #ifdef BURNER_SUPPORT
! 1144: /* reenable the burner after exiting from X */
! 1145: if (!sc->sc_burnman)
! 1146: wsdisplay_burn(sc, sc->sc_burnflags);
! 1147: #endif
! 1148:
! 1149: #ifdef WSMOUSED_SUPPORT
! 1150: /*
! 1151: * wsmoused cohabitation with X-Window support
! 1152: * X-Window is ending
! 1153: */
! 1154: wsmoused_wakeup(sc);
! 1155: #endif
! 1156: }
! 1157:
! 1158: (void)(*sc->sc_accessops->ioctl)(sc->sc_accesscookie, cmd, data,
! 1159: flag, p);
! 1160:
! 1161: return (0);
! 1162: #undef d
! 1163:
! 1164: case WSDISPLAYIO_USEFONT:
! 1165: #define d ((struct wsdisplay_font *)data)
! 1166: if (!sc->sc_accessops->load_font)
! 1167: return (EINVAL);
! 1168: d->data = 0;
! 1169: error = (*sc->sc_accessops->load_font)(sc->sc_accesscookie,
! 1170: scr->scr_dconf->emulcookie, d);
! 1171: if (!error)
! 1172: (*scr->scr_dconf->wsemul->reset)
! 1173: (scr->scr_dconf->wsemulcookie, WSEMUL_SYNCFONT);
! 1174: return (error);
! 1175: #undef d
! 1176: #ifdef BURNER_SUPPORT
! 1177: case WSDISPLAYIO_GVIDEO:
! 1178: *(u_int *)data = !sc->sc_burnman;
! 1179: break;
! 1180:
! 1181: case WSDISPLAYIO_SVIDEO:
! 1182: if (*(u_int *)data != WSDISPLAYIO_VIDEO_OFF &&
! 1183: *(u_int *)data != WSDISPLAYIO_VIDEO_ON)
! 1184: return (EINVAL);
! 1185: if (sc->sc_accessops->burn_screen == NULL)
! 1186: return (EOPNOTSUPP);
! 1187: (*sc->sc_accessops->burn_screen)(sc->sc_accesscookie,
! 1188: *(u_int *)data, sc->sc_burnflags);
! 1189: break;
! 1190:
! 1191: case WSDISPLAYIO_GBURNER:
! 1192: #define d ((struct wsdisplay_burner *)data)
! 1193: d->on = sc->sc_burninintvl * 1000 / hz;
! 1194: d->off = sc->sc_burnoutintvl * 1000 / hz;
! 1195: d->flags = sc->sc_burnflags;
! 1196: return (0);
! 1197:
! 1198: case WSDISPLAYIO_SBURNER:
! 1199: if (d->flags & ~(WSDISPLAY_BURN_VBLANK | WSDISPLAY_BURN_KBD |
! 1200: WSDISPLAY_BURN_MOUSE | WSDISPLAY_BURN_OUTPUT))
! 1201: error = EINVAL;
! 1202: else {
! 1203: error = 0;
! 1204: sc->sc_burnflags = d->flags;
! 1205: /* disable timeout if necessary */
! 1206: if ((sc->sc_burnflags & (WSDISPLAY_BURN_OUTPUT |
! 1207: WSDISPLAY_BURN_KBD | WSDISPLAY_BURN_MOUSE)) == 0) {
! 1208: if (sc->sc_burnout)
! 1209: timeout_del(&sc->sc_burner);
! 1210: }
! 1211: }
! 1212: if (d->on) {
! 1213: error = 0;
! 1214: sc->sc_burninintvl = hz * d->on / 1000;
! 1215: if (sc->sc_burnman)
! 1216: sc->sc_burnout = sc->sc_burninintvl;
! 1217: }
! 1218: if (d->off) {
! 1219: error = 0;
! 1220: sc->sc_burnoutintvl = hz * d->off / 1000;
! 1221: if (!sc->sc_burnman) {
! 1222: sc->sc_burnout = sc->sc_burnoutintvl;
! 1223: /* reinit timeout if changed */
! 1224: if ((scr->scr_flags & SCR_GRAPHICS) == 0)
! 1225: wsdisplay_burn(sc, sc->sc_burnflags);
! 1226: }
! 1227: }
! 1228: return (error);
! 1229: #undef d
! 1230: #endif /* BURNER_SUPPORT */
! 1231: case WSDISPLAYIO_GETSCREEN:
! 1232: return (wsdisplay_getscreen(sc,
! 1233: (struct wsdisplay_addscreendata *)data));
! 1234:
! 1235: case WSDISPLAYIO_SETSCREEN:
! 1236: return (wsdisplay_switch((void *)sc, *(int *)data, 1));
! 1237: }
! 1238:
! 1239: /* check ioctls for display */
! 1240: return ((*sc->sc_accessops->ioctl)(sc->sc_accesscookie, cmd, data,
! 1241: flag, p));
! 1242: }
! 1243:
! 1244: int
! 1245: wsdisplay_cfg_ioctl(struct wsdisplay_softc *sc, u_long cmd, caddr_t data,
! 1246: int flag, struct proc *p)
! 1247: {
! 1248: int error;
! 1249: void *buf;
! 1250: size_t fontsz;
! 1251: #if NWSKBD > 0
! 1252: struct wsevsrc *inp;
! 1253: #endif
! 1254:
! 1255: switch (cmd) {
! 1256: #ifdef WSMOUSED_SUPPORT
! 1257: case WSDISPLAYIO_WSMOUSED:
! 1258: error = wsmoused(sc, cmd, data, flag, p);
! 1259: return (error);
! 1260: #endif
! 1261: case WSDISPLAYIO_ADDSCREEN:
! 1262: #define d ((struct wsdisplay_addscreendata *)data)
! 1263: if ((error = wsdisplay_addscreen(sc, d->idx,
! 1264: d->screentype, d->emul)) == 0)
! 1265: wsdisplay_addscreen_print(sc, d->idx, 0);
! 1266: return (error);
! 1267: #undef d
! 1268: case WSDISPLAYIO_DELSCREEN:
! 1269: #define d ((struct wsdisplay_delscreendata *)data)
! 1270: return (wsdisplay_delscreen(sc, d->idx, d->flags));
! 1271: #undef d
! 1272: case WSDISPLAYIO_GETSCREEN:
! 1273: return (wsdisplay_getscreen(sc,
! 1274: (struct wsdisplay_addscreendata *)data));
! 1275: case WSDISPLAYIO_SETSCREEN:
! 1276: return (wsdisplay_switch((void *)sc, *(int *)data, 1));
! 1277: case WSDISPLAYIO_LDFONT:
! 1278: #define d ((struct wsdisplay_font *)data)
! 1279: if (!sc->sc_accessops->load_font)
! 1280: return (EINVAL);
! 1281: if (d->index >= WSDISPLAY_MAXFONT)
! 1282: return (EINVAL);
! 1283: fontsz = d->fontheight * d->stride * d->numchars;
! 1284: if (fontsz > WSDISPLAY_MAXFONTSZ)
! 1285: return (EINVAL);
! 1286:
! 1287: buf = malloc(fontsz, M_DEVBUF, M_WAITOK);
! 1288: error = copyin(d->data, buf, fontsz);
! 1289: if (error) {
! 1290: free(buf, M_DEVBUF);
! 1291: return (error);
! 1292: }
! 1293: d->data = buf;
! 1294: error =
! 1295: (*sc->sc_accessops->load_font)(sc->sc_accesscookie, 0, d);
! 1296: if (error)
! 1297: free(buf, M_DEVBUF);
! 1298: else if (d->index >= 0 || d->index < WSDISPLAY_MAXFONT)
! 1299: sc->sc_fonts[d->index] = *d;
! 1300: return (error);
! 1301:
! 1302: case WSDISPLAYIO_LSFONT:
! 1303: if (d->index < 0 || d->index >= WSDISPLAY_MAXFONT)
! 1304: return (EINVAL);
! 1305: *d = sc->sc_fonts[d->index];
! 1306: return (0);
! 1307:
! 1308: case WSDISPLAYIO_DELFONT:
! 1309: return (EINVAL);
! 1310: #undef d
! 1311:
! 1312: #if NWSKBD > 0
! 1313: case WSMUXIO_ADD_DEVICE:
! 1314: #define d ((struct wsmux_device *)data)
! 1315: if (d->idx == -1 && d->type == WSMUX_KBD)
! 1316: d->idx = wskbd_pickfree();
! 1317: #undef d
! 1318: /* FALLTHROUGH */
! 1319: case WSMUXIO_INJECTEVENT:
! 1320: case WSMUXIO_REMOVE_DEVICE:
! 1321: case WSMUXIO_LIST_DEVICES:
! 1322: inp = sc->sc_input;
! 1323: if (inp == NULL)
! 1324: return (ENXIO);
! 1325: return (wsevsrc_ioctl(inp, cmd, data, flag,p));
! 1326: #endif /* NWSKBD > 0 */
! 1327:
! 1328: }
! 1329: return (EINVAL);
! 1330: }
! 1331:
! 1332: paddr_t
! 1333: wsdisplaymmap(dev_t dev, off_t offset, int prot)
! 1334: {
! 1335: struct wsdisplay_softc *sc = wsdisplay_cd.cd_devs[WSDISPLAYUNIT(dev)];
! 1336: struct wsscreen *scr;
! 1337:
! 1338: if (ISWSDISPLAYCTL(dev))
! 1339: return (-1);
! 1340:
! 1341: if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
! 1342: return (-1);
! 1343:
! 1344: if (!(scr->scr_flags & SCR_GRAPHICS))
! 1345: return (-1);
! 1346:
! 1347: /* pass mmap to display */
! 1348: return ((*sc->sc_accessops->mmap)(sc->sc_accesscookie, offset, prot));
! 1349: }
! 1350:
! 1351: int
! 1352: wsdisplaypoll(dev_t dev, int events, struct proc *p)
! 1353: {
! 1354: struct wsdisplay_softc *sc = wsdisplay_cd.cd_devs[WSDISPLAYUNIT(dev)];
! 1355: struct wsscreen *scr;
! 1356:
! 1357: if (ISWSDISPLAYCTL(dev))
! 1358: return (0);
! 1359:
! 1360: if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
! 1361: return (POLLERR);
! 1362:
! 1363: if (!WSSCREEN_HAS_TTY(scr))
! 1364: return (POLLERR);
! 1365:
! 1366: return (ttpoll(dev, events, p));
! 1367: }
! 1368:
! 1369: int
! 1370: wsdisplaykqfilter(dev_t dev, struct knote *kn)
! 1371: {
! 1372: struct wsdisplay_softc *sc = wsdisplay_cd.cd_devs[WSDISPLAYUNIT(dev)];
! 1373: struct wsscreen *scr;
! 1374:
! 1375: if (ISWSDISPLAYCTL(dev))
! 1376: return (1);
! 1377:
! 1378: if ((scr = sc->sc_scr[WSDISPLAYSCREEN(dev)]) == NULL)
! 1379: return (1);
! 1380:
! 1381: if (WSSCREEN_HAS_TTY(scr))
! 1382: return (ttkqfilter(dev, kn));
! 1383: else
! 1384: return (1);
! 1385: }
! 1386:
! 1387: void
! 1388: wsdisplaystart(struct tty *tp)
! 1389: {
! 1390: struct wsdisplay_softc *sc;
! 1391: struct wsscreen *scr;
! 1392: int s, n, unit;
! 1393: u_char *buf;
! 1394:
! 1395: unit = WSDISPLAYUNIT(tp->t_dev);
! 1396: if (unit >= wsdisplay_cd.cd_ndevs ||
! 1397: (sc = wsdisplay_cd.cd_devs[unit]) == NULL)
! 1398: return;
! 1399:
! 1400: s = spltty();
! 1401: if (tp->t_state & (TS_TIMEOUT | TS_BUSY | TS_TTSTOP)) {
! 1402: splx(s);
! 1403: return;
! 1404: }
! 1405: if (tp->t_outq.c_cc == 0 && tp->t_wsel.si_selpid == 0)
! 1406: goto low;
! 1407:
! 1408: if ((scr = sc->sc_scr[WSDISPLAYSCREEN(tp->t_dev)]) == NULL) {
! 1409: splx(s);
! 1410: return;
! 1411: }
! 1412: if (scr->scr_hold_screen) {
! 1413: tp->t_state |= TS_TIMEOUT;
! 1414: splx(s);
! 1415: return;
! 1416: }
! 1417: tp->t_state |= TS_BUSY;
! 1418: splx(s);
! 1419:
! 1420: /*
! 1421: * Drain output from ring buffer.
! 1422: * The output will normally be in one contiguous chunk, but when the
! 1423: * ring wraps, it will be in two pieces.. one at the end of the ring,
! 1424: * the other at the start. For performance, rather than loop here,
! 1425: * we output one chunk, see if there's another one, and if so, output
! 1426: * it too.
! 1427: */
! 1428:
! 1429: n = ndqb(&tp->t_outq, 0);
! 1430: buf = tp->t_outq.c_cf;
! 1431:
! 1432: if (!(scr->scr_flags & SCR_GRAPHICS)) {
! 1433: #ifdef BURNER_SUPPORT
! 1434: wsdisplay_burn(sc, WSDISPLAY_BURN_OUTPUT);
! 1435: #endif
! 1436: #ifdef WSMOUSED_SUPPORT
! 1437: if (scr == sc->sc_focus) {
! 1438: if (IS_SEL_EXISTS(sc->sc_focus))
! 1439: /* hide a potential selection */
! 1440: remove_selection(sc);
! 1441: /* hide a potential mouse cursor */
! 1442: mouse_hide(sc);
! 1443: }
! 1444: #endif
! 1445: (*scr->scr_dconf->wsemul->output)(scr->scr_dconf->wsemulcookie,
! 1446: buf, n, 0);
! 1447: }
! 1448: ndflush(&tp->t_outq, n);
! 1449:
! 1450: if ((n = ndqb(&tp->t_outq, 0)) > 0) {
! 1451: buf = tp->t_outq.c_cf;
! 1452:
! 1453: if (!(scr->scr_flags & SCR_GRAPHICS)) {
! 1454: #ifdef BURNER_SUPPORT
! 1455: wsdisplay_burn(sc, WSDISPLAY_BURN_OUTPUT);
! 1456: #endif
! 1457: (*scr->scr_dconf->wsemul->output)
! 1458: (scr->scr_dconf->wsemulcookie, buf, n, 0);
! 1459: }
! 1460: ndflush(&tp->t_outq, n);
! 1461: }
! 1462:
! 1463: s = spltty();
! 1464: tp->t_state &= ~TS_BUSY;
! 1465: /* Come back if there's more to do */
! 1466: if (tp->t_outq.c_cc) {
! 1467: tp->t_state |= TS_TIMEOUT;
! 1468: timeout_add(&tp->t_rstrt_to, (hz > 128) ? (hz / 128) : 1);
! 1469: }
! 1470: if (tp->t_outq.c_cc <= tp->t_lowat) {
! 1471: low:
! 1472: if (tp->t_state & TS_ASLEEP) {
! 1473: tp->t_state &= ~TS_ASLEEP;
! 1474: wakeup((caddr_t)&tp->t_outq);
! 1475: }
! 1476: selwakeup(&tp->t_wsel);
! 1477: }
! 1478: splx(s);
! 1479: }
! 1480:
! 1481: int
! 1482: wsdisplaystop(struct tty *tp, int flag)
! 1483: {
! 1484: int s;
! 1485:
! 1486: s = spltty();
! 1487: if (ISSET(tp->t_state, TS_BUSY))
! 1488: if (!ISSET(tp->t_state, TS_TTSTOP))
! 1489: SET(tp->t_state, TS_FLUSH);
! 1490: splx(s);
! 1491:
! 1492: return (0);
! 1493: }
! 1494:
! 1495: /* Set line parameters. */
! 1496: int
! 1497: wsdisplayparam(struct tty *tp, struct termios *t)
! 1498: {
! 1499:
! 1500: tp->t_ispeed = t->c_ispeed;
! 1501: tp->t_ospeed = t->c_ospeed;
! 1502: tp->t_cflag = t->c_cflag;
! 1503: return (0);
! 1504: }
! 1505:
! 1506: /*
! 1507: * Callbacks for the emulation code.
! 1508: */
! 1509: void
! 1510: wsdisplay_emulbell(void *v)
! 1511: {
! 1512: struct wsscreen *scr = v;
! 1513:
! 1514: if (scr == NULL) /* console, before real attach */
! 1515: return;
! 1516:
! 1517: if (scr->scr_flags & SCR_GRAPHICS) /* can this happen? */
! 1518: return;
! 1519:
! 1520: (void) wsdisplay_internal_ioctl(scr->sc, scr, WSKBDIO_BELL, NULL,
! 1521: FWRITE, NULL);
! 1522: }
! 1523:
! 1524: void
! 1525: wsdisplay_emulinput(void *v, const u_char *data, u_int count)
! 1526: {
! 1527: struct wsscreen *scr = v;
! 1528: struct tty *tp;
! 1529:
! 1530: if (v == NULL) /* console, before real attach */
! 1531: return;
! 1532:
! 1533: if (scr->scr_flags & SCR_GRAPHICS) /* XXX can't happen */
! 1534: return;
! 1535: if (!WSSCREEN_HAS_TTY(scr))
! 1536: return;
! 1537:
! 1538: tp = scr->scr_tty;
! 1539: while (count-- > 0)
! 1540: (*linesw[tp->t_line].l_rint)(*data++, tp);
! 1541: }
! 1542:
! 1543: /*
! 1544: * Calls from the keyboard interface.
! 1545: */
! 1546: void
! 1547: wsdisplay_kbdinput(struct device *dev, keysym_t ks)
! 1548: {
! 1549: struct wsdisplay_softc *sc = (struct wsdisplay_softc *)dev;
! 1550: struct wsscreen *scr;
! 1551: char *dp;
! 1552: int count;
! 1553: struct tty *tp;
! 1554:
! 1555: KASSERT(sc != NULL);
! 1556:
! 1557: scr = sc->sc_focus;
! 1558:
! 1559: if (!scr || !WSSCREEN_HAS_TTY(scr))
! 1560: return;
! 1561:
! 1562: tp = scr->scr_tty;
! 1563:
! 1564: if (KS_GROUP(ks) == KS_GROUP_Ascii)
! 1565: (*linesw[tp->t_line].l_rint)(KS_VALUE(ks), tp);
! 1566: else {
! 1567: count = (*scr->scr_dconf->wsemul->translate)
! 1568: (scr->scr_dconf->wsemulcookie, ks, &dp);
! 1569: while (count-- > 0)
! 1570: (*linesw[tp->t_line].l_rint)(*dp++, tp);
! 1571: }
! 1572: }
! 1573:
! 1574: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 1575: int
! 1576: wsdisplay_update_rawkbd(struct wsdisplay_softc *sc, struct wsscreen *scr)
! 1577: {
! 1578: #if NWSKBD > 0
! 1579: int s, raw, data, error;
! 1580: struct wsevsrc *inp;
! 1581:
! 1582: s = spltty();
! 1583:
! 1584: raw = (scr ? scr->scr_rawkbd : 0);
! 1585:
! 1586: if (scr != sc->sc_focus || sc->sc_rawkbd == raw) {
! 1587: splx(s);
! 1588: return (0);
! 1589: }
! 1590:
! 1591: data = raw ? WSKBD_RAW : WSKBD_TRANSLATED;
! 1592: inp = sc->sc_input;
! 1593: if (inp == NULL) {
! 1594: splx(s);
! 1595: return (ENXIO);
! 1596: }
! 1597: error = wsevsrc_display_ioctl(inp, WSKBDIO_SETMODE, &data, FWRITE, 0);
! 1598: if (!error)
! 1599: sc->sc_rawkbd = raw;
! 1600: splx(s);
! 1601: return (error);
! 1602: #else
! 1603: return (0);
! 1604: #endif
! 1605: }
! 1606: #endif
! 1607:
! 1608: int
! 1609: wsdisplay_switch3(void *arg, int error, int waitok)
! 1610: {
! 1611: struct wsdisplay_softc *sc = arg;
! 1612: int no;
! 1613: struct wsscreen *scr;
! 1614:
! 1615: #ifdef WSDISPLAY_COMPAT_USL
! 1616: if (!(sc->sc_flags & SC_SWITCHPENDING)) {
! 1617: printf("wsdisplay_switch3: not switching\n");
! 1618: return (EINVAL);
! 1619: }
! 1620:
! 1621: no = sc->sc_screenwanted;
! 1622: if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
! 1623: panic("wsdisplay_switch3: invalid screen %d", no);
! 1624: scr = sc->sc_scr[no];
! 1625: if (!scr) {
! 1626: printf("wsdisplay_switch3: screen %d disappeared\n", no);
! 1627: error = ENXIO;
! 1628: }
! 1629:
! 1630: if (error) {
! 1631: /* try to recover, avoid recursion */
! 1632:
! 1633: if (sc->sc_oldscreen == WSDISPLAY_NULLSCREEN) {
! 1634: printf("wsdisplay_switch3: giving up\n");
! 1635: sc->sc_focus = 0;
! 1636: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 1637: wsdisplay_update_rawkbd(sc, 0);
! 1638: #endif
! 1639: sc->sc_flags &= ~SC_SWITCHPENDING;
! 1640: return (error);
! 1641: }
! 1642:
! 1643: sc->sc_screenwanted = sc->sc_oldscreen;
! 1644: sc->sc_oldscreen = WSDISPLAY_NULLSCREEN;
! 1645: return (wsdisplay_switch1(arg, 0, waitok));
! 1646: }
! 1647: #else
! 1648: /*
! 1649: * If we do not have syncops support, we come straight from
! 1650: * wsdisplay_switch2 which has already validated our arguments
! 1651: * and did not sleep.
! 1652: */
! 1653: no = sc->sc_screenwanted;
! 1654: scr = sc->sc_scr[no];
! 1655: #endif
! 1656:
! 1657: sc->sc_flags &= ~SC_SWITCHPENDING;
! 1658:
! 1659: if (!error && (scr->scr_flags & SCR_WAITACTIVE))
! 1660: wakeup(scr);
! 1661: return (error);
! 1662: }
! 1663:
! 1664: int
! 1665: wsdisplay_switch2(void *arg, int error, int waitok)
! 1666: {
! 1667: struct wsdisplay_softc *sc = arg;
! 1668: int no;
! 1669: struct wsscreen *scr;
! 1670:
! 1671: if (!(sc->sc_flags & SC_SWITCHPENDING)) {
! 1672: printf("wsdisplay_switch2: not switching\n");
! 1673: return (EINVAL);
! 1674: }
! 1675:
! 1676: no = sc->sc_screenwanted;
! 1677: if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
! 1678: panic("wsdisplay_switch2: invalid screen %d", no);
! 1679: scr = sc->sc_scr[no];
! 1680: if (!scr) {
! 1681: printf("wsdisplay_switch2: screen %d disappeared\n", no);
! 1682: error = ENXIO;
! 1683: }
! 1684:
! 1685: if (error) {
! 1686: /* try to recover, avoid recursion */
! 1687:
! 1688: if (sc->sc_oldscreen == WSDISPLAY_NULLSCREEN) {
! 1689: printf("wsdisplay_switch2: giving up\n");
! 1690: sc->sc_focus = 0;
! 1691: sc->sc_flags &= ~SC_SWITCHPENDING;
! 1692: return (error);
! 1693: }
! 1694:
! 1695: sc->sc_screenwanted = sc->sc_oldscreen;
! 1696: sc->sc_oldscreen = WSDISPLAY_NULLSCREEN;
! 1697: return (wsdisplay_switch1(arg, 0, waitok));
! 1698: }
! 1699:
! 1700: sc->sc_focusidx = no;
! 1701: sc->sc_focus = scr;
! 1702:
! 1703: #ifdef WSDISPLAY_COMPAT_RAWKBD
! 1704: (void) wsdisplay_update_rawkbd(sc, scr);
! 1705: #endif
! 1706: /* keyboard map??? */
! 1707:
! 1708: #ifdef WSDISPLAY_COMPAT_USL
! 1709: #define wsswitch_cb3 ((void (*)(void *, int, int))wsdisplay_switch3)
! 1710: if (scr->scr_syncops) {
! 1711: error = (*scr->scr_syncops->attach)(scr->scr_synccookie, waitok,
! 1712: sc->sc_isconsole && wsdisplay_cons_pollmode ?
! 1713: 0 : wsswitch_cb3, sc);
! 1714: if (error == EAGAIN) {
! 1715: /* switch will be done asynchronously */
! 1716: return (0);
! 1717: }
! 1718: }
! 1719: #endif
! 1720:
! 1721: return (wsdisplay_switch3(sc, error, waitok));
! 1722: }
! 1723:
! 1724: int
! 1725: wsdisplay_switch1(void *arg, int error, int waitok)
! 1726: {
! 1727: struct wsdisplay_softc *sc = arg;
! 1728: int no;
! 1729: struct wsscreen *scr;
! 1730:
! 1731: if (!(sc->sc_flags & SC_SWITCHPENDING)) {
! 1732: printf("wsdisplay_switch1: not switching\n");
! 1733: return (EINVAL);
! 1734: }
! 1735:
! 1736: no = sc->sc_screenwanted;
! 1737: if (no == WSDISPLAY_NULLSCREEN) {
! 1738: sc->sc_flags &= ~SC_SWITCHPENDING;
! 1739: if (!error) {
! 1740: sc->sc_focus = 0;
! 1741: }
! 1742: wakeup(sc);
! 1743: return (error);
! 1744: }
! 1745: if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
! 1746: panic("wsdisplay_switch1: invalid screen %d", no);
! 1747: scr = sc->sc_scr[no];
! 1748: if (!scr) {
! 1749: printf("wsdisplay_switch1: screen %d disappeared\n", no);
! 1750: error = ENXIO;
! 1751: }
! 1752:
! 1753: if (error) {
! 1754: sc->sc_flags &= ~SC_SWITCHPENDING;
! 1755: return (error);
! 1756: }
! 1757:
! 1758: #define wsswitch_cb2 ((void (*)(void *, int, int))wsdisplay_switch2)
! 1759: error = (*sc->sc_accessops->show_screen)(sc->sc_accesscookie,
! 1760: scr->scr_dconf->emulcookie, waitok,
! 1761: sc->sc_isconsole && wsdisplay_cons_pollmode ? 0 : wsswitch_cb2, sc);
! 1762: if (error == EAGAIN) {
! 1763: /* switch will be done asynchronously */
! 1764: return (0);
! 1765: }
! 1766:
! 1767: return (wsdisplay_switch2(sc, error, waitok));
! 1768: }
! 1769:
! 1770: int
! 1771: wsdisplay_switch(struct device *dev, int no, int waitok)
! 1772: {
! 1773: struct wsdisplay_softc *sc = (struct wsdisplay_softc *)dev;
! 1774: int s, res = 0;
! 1775: struct wsscreen *scr;
! 1776:
! 1777: if (no != WSDISPLAY_NULLSCREEN) {
! 1778: if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
! 1779: return (EINVAL);
! 1780: if (sc->sc_scr[no] == NULL)
! 1781: return (ENXIO);
! 1782: }
! 1783:
! 1784: s = spltty();
! 1785:
! 1786: if ((sc->sc_focus && no == sc->sc_focusidx) ||
! 1787: (sc->sc_focus == NULL && no == WSDISPLAY_NULLSCREEN)) {
! 1788: splx(s);
! 1789: return (0);
! 1790: }
! 1791:
! 1792: if (sc->sc_flags & SC_SWITCHPENDING) {
! 1793: splx(s);
! 1794: return (EBUSY);
! 1795: }
! 1796:
! 1797: sc->sc_flags |= SC_SWITCHPENDING;
! 1798: sc->sc_screenwanted = no;
! 1799:
! 1800: splx(s);
! 1801:
! 1802: scr = sc->sc_focus;
! 1803: if (!scr) {
! 1804: sc->sc_oldscreen = WSDISPLAY_NULLSCREEN;
! 1805: return (wsdisplay_switch1(sc, 0, waitok));
! 1806: } else
! 1807: sc->sc_oldscreen = sc->sc_focusidx;
! 1808:
! 1809:
! 1810: #ifdef WSMOUSED_SUPPORT
! 1811: /*
! 1812: * wsmoused cohabitation with X-Window support
! 1813: *
! 1814: * Detect switch from a graphic to text console and vice-versa
! 1815: * This only happen when switching from X-Window to text mode and
! 1816: * switching back from text mode to X-Window.
! 1817: *
! 1818: * scr_flags is not yet flagged with SCR_GRAPHICS when X-Window starts
! 1819: * (KD_GRAPHICS ioctl happens after VT_ACTIVATE ioctl in
! 1820: * xf86OpenPcvt()). Conversely, scr_flags is no longer flagged with
! 1821: * SCR_GRAPHICS when X-Window stops. In this case, the first of the
! 1822: * three following 'if' statements is evaluated.
! 1823: * We handle wsmoused(8) events the WSDISPLAYIO_SMODE ioctl.
! 1824: */
! 1825:
! 1826: if (!(scr->scr_flags & SCR_GRAPHICS) &&
! 1827: (!(sc->sc_scr[no]->scr_flags & SCR_GRAPHICS))) {
! 1828: /* switching from a text console to another text console */
! 1829: /* XXX evaluated when the X-server starts or stops, see above */
! 1830:
! 1831: /* remove a potential wsmoused(8) selection */
! 1832: mouse_remove(sc);
! 1833: }
! 1834:
! 1835: if (!(scr->scr_flags & SCR_GRAPHICS) &&
! 1836: (sc->sc_scr[no]->scr_flags & SCR_GRAPHICS)) {
! 1837: /* switching from a text console to a graphic console */
! 1838:
! 1839: /* remote a potential wsmoused(8) selection */
! 1840: mouse_remove(sc);
! 1841: wsmoused_release(sc);
! 1842: }
! 1843:
! 1844: if ((scr->scr_flags & SCR_GRAPHICS) &&
! 1845: !(sc->sc_scr[no]->scr_flags & SCR_GRAPHICS)) {
! 1846: /* switching from a graphic console to a text console */
! 1847:
! 1848: wsmoused_wakeup(sc);
! 1849: }
! 1850: #endif /* WSMOUSED_SUPPORT */
! 1851:
! 1852: #ifdef WSDISPLAY_COMPAT_USL
! 1853: #define wsswitch_cb1 ((void (*)(void *, int, int))wsdisplay_switch1)
! 1854: if (scr->scr_syncops) {
! 1855: res = (*scr->scr_syncops->detach)(scr->scr_synccookie, waitok,
! 1856: sc->sc_isconsole && wsdisplay_cons_pollmode ?
! 1857: 0 : wsswitch_cb1, sc);
! 1858: if (res == EAGAIN) {
! 1859: /* switch will be done asynchronously */
! 1860: return (0);
! 1861: }
! 1862: } else if (scr->scr_flags & SCR_GRAPHICS) {
! 1863: /* no way to save state */
! 1864: res = EBUSY;
! 1865: }
! 1866: #endif
! 1867:
! 1868: return (wsdisplay_switch1(sc, res, waitok));
! 1869: }
! 1870:
! 1871: void
! 1872: wsdisplay_reset(struct device *dev, enum wsdisplay_resetops op)
! 1873: {
! 1874: struct wsdisplay_softc *sc = (struct wsdisplay_softc *)dev;
! 1875: struct wsscreen *scr;
! 1876:
! 1877: KASSERT(sc != NULL);
! 1878: scr = sc->sc_focus;
! 1879:
! 1880: if (!scr)
! 1881: return;
! 1882:
! 1883: switch (op) {
! 1884: case WSDISPLAY_RESETEMUL:
! 1885: (*scr->scr_dconf->wsemul->reset)(scr->scr_dconf->wsemulcookie,
! 1886: WSEMUL_RESET);
! 1887: break;
! 1888: case WSDISPLAY_RESETCLOSE:
! 1889: wsdisplay_closescreen(sc, scr);
! 1890: break;
! 1891: }
! 1892: }
! 1893:
! 1894: #ifdef WSDISPLAY_COMPAT_USL
! 1895: /*
! 1896: * Interface for (external) VT switch / process synchronization code
! 1897: */
! 1898: int
! 1899: wsscreen_attach_sync(struct wsscreen *scr, const struct wscons_syncops *ops,
! 1900: void *cookie)
! 1901: {
! 1902: if (scr->scr_syncops) {
! 1903: /*
! 1904: * The screen is already claimed.
! 1905: * Check if the owner is still alive.
! 1906: */
! 1907: if ((*scr->scr_syncops->check)(scr->scr_synccookie))
! 1908: return (EBUSY);
! 1909: }
! 1910: scr->scr_syncops = ops;
! 1911: scr->scr_synccookie = cookie;
! 1912: return (0);
! 1913: }
! 1914:
! 1915: int
! 1916: wsscreen_detach_sync(struct wsscreen *scr)
! 1917: {
! 1918: if (!scr->scr_syncops)
! 1919: return (EINVAL);
! 1920: scr->scr_syncops = 0;
! 1921: return (0);
! 1922: }
! 1923:
! 1924: int
! 1925: wsscreen_lookup_sync(struct wsscreen *scr,
! 1926: const struct wscons_syncops *ops, /* used as ID */
! 1927: void **cookiep)
! 1928: {
! 1929: if (!scr->scr_syncops || ops != scr->scr_syncops)
! 1930: return (EINVAL);
! 1931: *cookiep = scr->scr_synccookie;
! 1932: return (0);
! 1933: }
! 1934: #endif
! 1935:
! 1936: /*
! 1937: * Interface to virtual screen stuff
! 1938: */
! 1939: int
! 1940: wsdisplay_maxscreenidx(struct wsdisplay_softc *sc)
! 1941: {
! 1942: return (WSDISPLAY_MAXSCREEN - 1);
! 1943: }
! 1944:
! 1945: int
! 1946: wsdisplay_screenstate(struct wsdisplay_softc *sc, int idx)
! 1947: {
! 1948: if (idx < 0 || idx >= WSDISPLAY_MAXSCREEN)
! 1949: return (EINVAL);
! 1950: if (!sc->sc_scr[idx])
! 1951: return (ENXIO);
! 1952: return ((sc->sc_scr[idx]->scr_flags & SCR_OPEN) ? EBUSY : 0);
! 1953: }
! 1954:
! 1955: int
! 1956: wsdisplay_getactivescreen(struct wsdisplay_softc *sc)
! 1957: {
! 1958: return (sc->sc_focus ? sc->sc_focusidx : WSDISPLAY_NULLSCREEN);
! 1959: }
! 1960:
! 1961: int
! 1962: wsscreen_switchwait(struct wsdisplay_softc *sc, int no)
! 1963: {
! 1964: struct wsscreen *scr;
! 1965: int s, res = 0;
! 1966:
! 1967: if (no == WSDISPLAY_NULLSCREEN) {
! 1968: s = spltty();
! 1969: while (sc->sc_focus && res == 0) {
! 1970: res = tsleep(sc, PCATCH, "wswait", 0);
! 1971: }
! 1972: splx(s);
! 1973: return (res);
! 1974: }
! 1975:
! 1976: if (no < 0 || no >= WSDISPLAY_MAXSCREEN)
! 1977: return (ENXIO);
! 1978: scr = sc->sc_scr[no];
! 1979: if (!scr)
! 1980: return (ENXIO);
! 1981:
! 1982: s = spltty();
! 1983: if (scr != sc->sc_focus) {
! 1984: scr->scr_flags |= SCR_WAITACTIVE;
! 1985: res = tsleep(scr, PCATCH, "wswait", 0);
! 1986: if (scr != sc->sc_scr[no])
! 1987: res = ENXIO; /* disappeared in the meantime */
! 1988: else
! 1989: scr->scr_flags &= ~SCR_WAITACTIVE;
! 1990: }
! 1991: splx(s);
! 1992: return (res);
! 1993: }
! 1994:
! 1995: void
! 1996: wsdisplay_kbdholdscreen(struct device *dev, int hold)
! 1997: {
! 1998: struct wsdisplay_softc *sc = (struct wsdisplay_softc *)dev;
! 1999: struct wsscreen *scr;
! 2000:
! 2001: scr = sc->sc_focus;
! 2002:
! 2003: if (hold)
! 2004: scr->scr_hold_screen = 1;
! 2005: else {
! 2006: scr->scr_hold_screen = 0;
! 2007: timeout_add(&scr->scr_tty->t_rstrt_to, 0); /* "immediate" */
! 2008: }
! 2009: }
! 2010:
! 2011: #if NWSKBD > 0
! 2012: void
! 2013: wsdisplay_set_console_kbd(struct wsevsrc *src)
! 2014: {
! 2015: if (wsdisplay_console_device == NULL) {
! 2016: src->me_dispdv = NULL;
! 2017: return;
! 2018: }
! 2019: #if NWSMUX > 0
! 2020: if (wsmux_attach_sc((struct wsmux_softc *)
! 2021: wsdisplay_console_device->sc_input, src)) {
! 2022: src->me_dispdv = NULL;
! 2023: return;
! 2024: }
! 2025: #else
! 2026: wsdisplay_console_device->sc_input = src;
! 2027: #endif
! 2028: src->me_dispdv = &wsdisplay_console_device->sc_dv;
! 2029: }
! 2030:
! 2031: #if NWSMUX == 0
! 2032: int
! 2033: wsdisplay_set_kbd(struct device *disp, struct wsevsrc *kbd)
! 2034: {
! 2035: struct wsdisplay_softc *sc = (struct wsdisplay_softc *)disp;
! 2036:
! 2037: if (sc->sc_input != NULL)
! 2038: return (EBUSY);
! 2039:
! 2040: sc->sc_input = kbd;
! 2041:
! 2042: return (0);
! 2043: }
! 2044: #endif
! 2045:
! 2046: #endif /* NWSKBD > 0 */
! 2047:
! 2048: /*
! 2049: * Console interface.
! 2050: */
! 2051: void
! 2052: wsdisplay_cnputc(dev_t dev, int i)
! 2053: {
! 2054: struct wsscreen_internal *dc;
! 2055: char c = i;
! 2056:
! 2057: if (!wsdisplay_console_initted)
! 2058: return;
! 2059:
! 2060: if (wsdisplay_console_device != NULL &&
! 2061: (wsdisplay_console_device->sc_scr[0] != NULL) &&
! 2062: (wsdisplay_console_device->sc_scr[0]->scr_flags & SCR_GRAPHICS))
! 2063: return;
! 2064:
! 2065: dc = &wsdisplay_console_conf;
! 2066: #ifdef BURNER_SUPPORT
! 2067: /*wsdisplay_burn(wsdisplay_console_device, WSDISPLAY_BURN_OUTPUT);*/
! 2068: #endif
! 2069: (*dc->wsemul->output)(dc->wsemulcookie, &c, 1, 1);
! 2070: }
! 2071:
! 2072: int
! 2073: wsdisplay_getc_dummy(dev_t dev)
! 2074: {
! 2075: /* panic? */
! 2076: return (0);
! 2077: }
! 2078:
! 2079: void
! 2080: wsdisplay_pollc(dev_t dev, int on)
! 2081: {
! 2082:
! 2083: wsdisplay_cons_pollmode = on;
! 2084:
! 2085: /* notify to fb drivers */
! 2086: if (wsdisplay_console_device != NULL &&
! 2087: wsdisplay_console_device->sc_accessops->pollc != NULL)
! 2088: (*wsdisplay_console_device->sc_accessops->pollc)
! 2089: (wsdisplay_console_device->sc_accesscookie, on);
! 2090:
! 2091: /* notify to kbd drivers */
! 2092: if (wsdisplay_cons_kbd_pollc)
! 2093: (*wsdisplay_cons_kbd_pollc)(dev, on);
! 2094: }
! 2095:
! 2096: void
! 2097: wsdisplay_set_cons_kbd(int (*get)(dev_t), void (*poll)(dev_t, int),
! 2098: void (*bell)(dev_t, u_int, u_int, u_int))
! 2099: {
! 2100: wsdisplay_cons.cn_getc = get;
! 2101: wsdisplay_cons.cn_bell = bell;
! 2102: wsdisplay_cons_kbd_pollc = poll;
! 2103: }
! 2104:
! 2105: void
! 2106: wsdisplay_unset_cons_kbd()
! 2107: {
! 2108: wsdisplay_cons.cn_getc = wsdisplay_getc_dummy;
! 2109: wsdisplay_cons.cn_bell = NULL;
! 2110: wsdisplay_cons_kbd_pollc = 0;
! 2111: }
! 2112:
! 2113: /*
! 2114: * Switch the console display to its first screen.
! 2115: */
! 2116: void
! 2117: wsdisplay_switchtoconsole()
! 2118: {
! 2119: struct wsdisplay_softc *sc;
! 2120: struct wsscreen *scr;
! 2121:
! 2122: if (wsdisplay_console_device != NULL) {
! 2123: sc = wsdisplay_console_device;
! 2124: if ((scr = sc->sc_scr[0]) == NULL)
! 2125: return;
! 2126: (*sc->sc_accessops->show_screen)(sc->sc_accesscookie,
! 2127: scr->scr_dconf->emulcookie, 0, NULL, NULL);
! 2128: }
! 2129: }
! 2130:
! 2131: #ifdef SCROLLBACK_SUPPORT
! 2132: void
! 2133: wsscrollback(void *arg, int op)
! 2134: {
! 2135: struct wsdisplay_softc *sc = arg;
! 2136: int lines;
! 2137:
! 2138: if (op == WSDISPLAY_SCROLL_RESET)
! 2139: lines = 0;
! 2140: else {
! 2141: lines = sc->sc_focus->scr_dconf->scrdata->nrows - 1;
! 2142: if (op == WSDISPLAY_SCROLL_BACKWARD)
! 2143: lines = -lines;
! 2144: }
! 2145:
! 2146: if (sc->sc_accessops->scrollback) {
! 2147: (*sc->sc_accessops->scrollback)(sc->sc_accesscookie,
! 2148: sc->sc_focus->scr_dconf->emulcookie, lines);
! 2149: }
! 2150: }
! 2151: #endif
! 2152:
! 2153: #ifdef BURNER_SUPPORT
! 2154: void
! 2155: wsdisplay_burn(void *v, u_int flags)
! 2156: {
! 2157: struct wsdisplay_softc *sc = v;
! 2158:
! 2159: if ((flags & sc->sc_burnflags & (WSDISPLAY_BURN_OUTPUT |
! 2160: WSDISPLAY_BURN_KBD | WSDISPLAY_BURN_MOUSE)) &&
! 2161: sc->sc_accessops->burn_screen) {
! 2162: if (sc->sc_burnout)
! 2163: timeout_add(&sc->sc_burner, sc->sc_burnout);
! 2164: if (sc->sc_burnman)
! 2165: sc->sc_burnout = 0;
! 2166: }
! 2167: }
! 2168:
! 2169: void
! 2170: wsdisplay_burner(void *v)
! 2171: {
! 2172: struct wsdisplay_softc *sc = v;
! 2173: int s;
! 2174:
! 2175: if (sc->sc_accessops->burn_screen) {
! 2176: (*sc->sc_accessops->burn_screen)(sc->sc_accesscookie,
! 2177: sc->sc_burnman, sc->sc_burnflags);
! 2178: s = spltty();
! 2179: if (sc->sc_burnman) {
! 2180: sc->sc_burnout = sc->sc_burnoutintvl;
! 2181: timeout_add(&sc->sc_burner, sc->sc_burnout);
! 2182: } else
! 2183: sc->sc_burnout = sc->sc_burninintvl;
! 2184: sc->sc_burnman = !sc->sc_burnman;
! 2185: splx(s);
! 2186: }
! 2187: }
! 2188: #endif
! 2189:
! 2190: /*
! 2191: * Switch the console at shutdown.
! 2192: */
! 2193: void
! 2194: wsdisplay_shutdownhook(void *arg)
! 2195: {
! 2196: wsdisplay_switchtoconsole();
! 2197: }
! 2198:
! 2199: #ifdef WSMOUSED_SUPPORT
! 2200: /*
! 2201: * wsmoused(8) support functions
! 2202: */
! 2203:
! 2204: /* pointer to the current screen wsdisplay_softc structure */
! 2205: static struct wsdisplay_softc *sc = NULL;
! 2206:
! 2207: /*
! 2208: * Main function, called from wsdisplay_cfg_ioctl.
! 2209: */
! 2210: int
! 2211: wsmoused(struct wsdisplay_softc *ws_sc, u_long cmd, caddr_t data,
! 2212: int flag, struct proc *p)
! 2213: {
! 2214: int error = -1;
! 2215: struct wscons_event mouse_event = *(struct wscons_event *)data;
! 2216:
! 2217: if (cmd == WSDISPLAYIO_WSMOUSED) {
! 2218: if (IS_MOTION_EVENT(mouse_event.type)) {
! 2219: motion_event(mouse_event.type, mouse_event.value);
! 2220: return (0);
! 2221: }
! 2222: if (IS_BUTTON_EVENT(mouse_event.type)) {
! 2223: /* XXX tv_sec contains the number of clicks */
! 2224: if (mouse_event.type == WSCONS_EVENT_MOUSE_DOWN) {
! 2225: button_event(mouse_event.value,
! 2226: mouse_event.time.tv_sec);
! 2227: } else
! 2228: button_event(mouse_event.value, 0);
! 2229: return (0);
! 2230: }
! 2231: if (IS_CTRL_EVENT(mouse_event.type)) {
! 2232: return (ctrl_event(mouse_event.type, mouse_event.value,
! 2233: ws_sc, p));
! 2234: }
! 2235: }
! 2236: return (error);
! 2237: }
! 2238:
! 2239: /*
! 2240: * Mouse motion events
! 2241: */
! 2242: void
! 2243: motion_event(u_int type, int value)
! 2244: {
! 2245: switch (type) {
! 2246: case WSCONS_EVENT_MOUSE_DELTA_X:
! 2247: mouse_moverel(value, 0);
! 2248: break;
! 2249: case WSCONS_EVENT_MOUSE_DELTA_Y:
! 2250: mouse_moverel(0, 0 - value);
! 2251: break;
! 2252: case WSCONS_EVENT_MOUSE_DELTA_Z:
! 2253: mouse_zaxis(value);
! 2254: break;
! 2255: default:
! 2256: break;
! 2257: }
! 2258: }
! 2259:
! 2260: /*
! 2261: * Button clicks events
! 2262: */
! 2263: void
! 2264: button_event(int button, int clicks)
! 2265: {
! 2266: switch (button) {
! 2267: case MOUSE_COPY_BUTTON:
! 2268: switch (clicks % 4) {
! 2269: case 0: /* button is up */
! 2270: mouse_copy_end();
! 2271: mouse_copy_selection();
! 2272: break;
! 2273: case 1: /* single click */
! 2274: mouse_copy_start();
! 2275: mouse_copy_selection();
! 2276: break;
! 2277: case 2: /* double click */
! 2278: mouse_copy_word();
! 2279: mouse_copy_selection();
! 2280: break;
! 2281: case 3: /* triple click */
! 2282: mouse_copy_line();
! 2283: mouse_copy_selection();
! 2284: break;
! 2285: default:
! 2286: break;
! 2287: }
! 2288: break;
! 2289:
! 2290: case MOUSE_PASTE_BUTTON:
! 2291: switch (clicks) {
! 2292: case 0: /* button is up */
! 2293: break;
! 2294: default: /* paste */
! 2295: mouse_paste();
! 2296: break;
! 2297: }
! 2298: break;
! 2299:
! 2300: case MOUSE_EXTEND_BUTTON:
! 2301: switch (clicks) {
! 2302: case 0: /* button is up */
! 2303: break;
! 2304: default: /* extend the selection */
! 2305: mouse_copy_extend_after();
! 2306: break;
! 2307: }
! 2308: break;
! 2309:
! 2310: default:
! 2311: break;
! 2312: }
! 2313: }
! 2314:
! 2315: /*
! 2316: * Control events
! 2317: */
! 2318: int
! 2319: ctrl_event(u_int type, int value, struct wsdisplay_softc *ws_sc, struct proc *p)
! 2320: {
! 2321: int i, error;
! 2322:
! 2323: if (type == WSCONS_EVENT_WSMOUSED_ON) {
! 2324: if (!ws_sc->sc_accessops->getchar)
! 2325: /* no wsmoused(8) support in the display driver */
! 2326: return (1);
! 2327: /* initialization of globals */
! 2328: sc = ws_sc;
! 2329: allocate_copybuffer(sc);
! 2330: Paste_avail = 0;
! 2331: ws_sc->wsmoused_dev = value;
! 2332: }
! 2333: if (type == WSCONS_EVENT_WSMOUSED_OFF) {
! 2334: Paste_avail = 0;
! 2335: ws_sc->wsmoused_dev = 0;
! 2336: return (0);
! 2337: }
! 2338: if (type == WSCONS_EVENT_WSMOUSED_SLEEP) {
! 2339: /* sleeping until next switch to text mode */
! 2340: ws_sc->wsmoused_sleep = 1;
! 2341: error = 0;
! 2342: while (ws_sc->wsmoused_sleep && error == 0)
! 2343: error = tsleep(&ws_sc->wsmoused_sleep, PPAUSE,
! 2344: "wsmoused_sleep", 0);
! 2345: return (error);
! 2346: }
! 2347: for (i = 0 ; i < WSDISPLAY_DEFAULTSCREENS ; i++)
! 2348: if (sc->sc_scr[i]) {
! 2349: sc->sc_scr[i]->mouse =
! 2350: ((WS_NCOLS(sc->sc_scr[i]) *
! 2351: WS_NROWS(sc->sc_scr[i])) / 2);
! 2352: sc->sc_scr[i]->cursor = sc->sc_scr[i]->mouse;
! 2353: sc->sc_scr[i]->cpy_start = 0;
! 2354: sc->sc_scr[i]->cpy_end = 0;
! 2355: sc->sc_scr[i]->orig_start = 0;
! 2356: sc->sc_scr[i]->orig_end = 0;
! 2357: sc->sc_scr[i]->mouse_flags = 0;
! 2358: }
! 2359: return (0);
! 2360: }
! 2361:
! 2362: void
! 2363: mouse_moverel(char dx, char dy)
! 2364: {
! 2365: unsigned short old_mouse = MOUSE;
! 2366: unsigned char mouse_col = (MOUSE % N_COLS);
! 2367: unsigned char mouse_row = (MOUSE / N_COLS);
! 2368:
! 2369: /* wscons has support for screen saver via the WSDISPLAYIO_{G,S}VIDEO
! 2370: with WSDISPLAY_VIDEO_OFF and WSDISPLAY_VIDEO_ON values.
! 2371: However, none of the pc display driver (pcdisplay.c or vga.c)
! 2372: support this ioctl. Only the alpha display driver (tga.c) support it.
! 2373:
! 2374: When screen saver support is available, /usr/sbin/screenblank can be
! 2375: used with the -m option, so that mice movements stop the screen
! 2376: saver.
! 2377: */
! 2378:
! 2379: /* update position */
! 2380:
! 2381: if (mouse_col + dx >= MAXCOL)
! 2382: mouse_col = MAXCOL;
! 2383: else {
! 2384: if (mouse_col + dx <= 0)
! 2385: mouse_col = 0;
! 2386: else
! 2387: mouse_col += dx;
! 2388: }
! 2389: if (mouse_row + dy >= MAXROW)
! 2390: mouse_row = MAXROW;
! 2391: else {
! 2392: if (mouse_row + dy <= 0)
! 2393: mouse_row = 0;
! 2394: else
! 2395: mouse_row += dy;
! 2396: }
! 2397: MOUSE = XY_TO_POS(mouse_col, mouse_row);
! 2398: /* if we have moved */
! 2399: if (old_mouse != MOUSE) {
! 2400: if (IS_SEL_IN_PROGRESS(sc->sc_focus)) {
! 2401: /* selection in progress */
! 2402: mouse_copy_extend();
! 2403: } else {
! 2404: inverse_char(MOUSE);
! 2405: if (IS_MOUSE_VISIBLE(sc->sc_focus))
! 2406: inverse_char(old_mouse);
! 2407: else
! 2408: MOUSE_FLAGS |= MOUSE_VISIBLE;
! 2409: }
! 2410: }
! 2411: }
! 2412:
! 2413: void
! 2414: inverse_char(unsigned short pos)
! 2415: {
! 2416: struct wsscreen_internal *dconf;
! 2417: struct wsdisplay_charcell cell;
! 2418: int fg, bg, ul;
! 2419: int flags;
! 2420: int tmp;
! 2421: long attr;
! 2422:
! 2423: dconf = sc->sc_focus->scr_dconf;
! 2424:
! 2425: GETCHAR(pos, &cell);
! 2426:
! 2427: (*dconf->emulops->unpack_attr)(dconf->emulcookie, cell.attr, &fg,
! 2428: &bg, &ul);
! 2429:
! 2430: /*
! 2431: * Display the mouse cursor as a color inverted cell whenever
! 2432: * possible. If this is not possible, ask for the video reverse
! 2433: * attribute.
! 2434: */
! 2435: flags = 0;
! 2436: if (dconf->scrdata->capabilities & WSSCREEN_WSCOLORS) {
! 2437: flags |= WSATTR_WSCOLORS;
! 2438: tmp = fg;
! 2439: fg = bg;
! 2440: bg = tmp;
! 2441: } else if (dconf->scrdata->capabilities & WSSCREEN_REVERSE) {
! 2442: flags |= WSATTR_REVERSE;
! 2443: }
! 2444: if ((*dconf->emulops->alloc_attr)(dconf->emulcookie, fg, bg, flags |
! 2445: (ul ? WSATTR_UNDERLINE : 0), &attr) == 0) {
! 2446: cell.attr = attr;
! 2447: PUTCHAR(pos, cell.uc, cell.attr);
! 2448: }
! 2449: }
! 2450:
! 2451: void
! 2452: inverse_region(unsigned short start, unsigned short end)
! 2453: {
! 2454: unsigned short current_pos;
! 2455: unsigned short abs_end;
! 2456:
! 2457: /* sanity check, useful because 'end' can be (0 - 1) = 65535 */
! 2458: abs_end = N_COLS * N_ROWS;
! 2459: if (end > abs_end)
! 2460: return;
! 2461: current_pos = start;
! 2462: while (current_pos <= end)
! 2463: inverse_char(current_pos++);
! 2464: }
! 2465:
! 2466: /*
! 2467: * Return the number of contiguous blank characters between the right margin
! 2468: * if border == 1 or between the next non-blank character and the current mouse
! 2469: * cursor if border == 0
! 2470: */
! 2471: unsigned char
! 2472: skip_spc_right(char border)
! 2473: {
! 2474: struct wsdisplay_charcell cell;
! 2475: unsigned short current = CPY_END;
! 2476: unsigned short mouse_col = (CPY_END % N_COLS);
! 2477: unsigned short limit = current + (N_COLS - mouse_col - 1);
! 2478: unsigned char res = 0;
! 2479:
! 2480: while (GETCHAR(current, &cell) == 0 && cell.uc == ' ' &&
! 2481: current <= limit) {
! 2482: current++;
! 2483: res++;
! 2484: }
! 2485: if (border == BORDER) {
! 2486: if (current > limit)
! 2487: return (res - 1);
! 2488: else
! 2489: return (0);
! 2490: } else {
! 2491: if (res)
! 2492: return (res - 1);
! 2493: else
! 2494: return (res);
! 2495: }
! 2496: }
! 2497:
! 2498: /*
! 2499: * Return the number of contiguous blank characters between the first of the
! 2500: * contiguous blank characters and the current mouse cursor
! 2501: */
! 2502: unsigned char
! 2503: skip_spc_left(void)
! 2504: {
! 2505: struct wsdisplay_charcell cell;
! 2506: short current = CPY_START;
! 2507: unsigned short mouse_col = (MOUSE % N_COLS);
! 2508: unsigned short limit = current - mouse_col;
! 2509: unsigned char res = 0;
! 2510:
! 2511: while (GETCHAR(current, &cell) == 0 && cell.uc == ' ' &&
! 2512: current >= limit) {
! 2513: current--;
! 2514: res++;
! 2515: }
! 2516: if (res)
! 2517: res--;
! 2518: return (res);
! 2519: }
! 2520:
! 2521: /*
! 2522: * Class of characters
! 2523: * Stolen from xterm sources of the Xfree project (see cvs tag below)
! 2524: * $TOG: button.c /main/76 1997/07/30 16:56:19 kaleb $
! 2525: */
! 2526: static const int charClass[256] = {
! 2527: /* NUL SOH STX ETX EOT ENQ ACK BEL */
! 2528: 32, 1, 1, 1, 1, 1, 1, 1,
! 2529: /* BS HT NL VT NP CR SO SI */
! 2530: 1, 32, 1, 1, 1, 1, 1, 1,
! 2531: /* DLE DC1 DC2 DC3 DC4 NAK SYN ETB */
! 2532: 1, 1, 1, 1, 1, 1, 1, 1,
! 2533: /* CAN EM SUB ESC FS GS RS US */
! 2534: 1, 1, 1, 1, 1, 1, 1, 1,
! 2535: /* SP ! " # $ % & ' */
! 2536: 32, 33, 34, 35, 36, 37, 38, 39,
! 2537: /* ( ) * + , - . / */
! 2538: 40, 41, 42, 43, 44, 45, 46, 47,
! 2539: /* 0 1 2 3 4 5 6 7 */
! 2540: 48, 48, 48, 48, 48, 48, 48, 48,
! 2541: /* 8 9 : ; < = > ? */
! 2542: 48, 48, 58, 59, 60, 61, 62, 63,
! 2543: /* @ A B C D E F G */
! 2544: 64, 48, 48, 48, 48, 48, 48, 48,
! 2545: /* H I J K L M N O */
! 2546: 48, 48, 48, 48, 48, 48, 48, 48,
! 2547: /* P Q R S T U V W */
! 2548: 48, 48, 48, 48, 48, 48, 48, 48,
! 2549: /* X Y Z [ \ ] ^ _ */
! 2550: 48, 48, 48, 91, 92, 93, 94, 48,
! 2551: /* ` a b c d e f g */
! 2552: 96, 48, 48, 48, 48, 48, 48, 48,
! 2553: /* h i j k l m n o */
! 2554: 48, 48, 48, 48, 48, 48, 48, 48,
! 2555: /* p q r s t u v w */
! 2556: 48, 48, 48, 48, 48, 48, 48, 48,
! 2557: /* x y z { | } ~ DEL */
! 2558: 48, 48, 48, 123, 124, 125, 126, 1,
! 2559: /* x80 x81 x82 x83 IND NEL SSA ESA */
! 2560: 1, 1, 1, 1, 1, 1, 1, 1,
! 2561: /* HTS HTJ VTS PLD PLU RI SS2 SS3 */
! 2562: 1, 1, 1, 1, 1, 1, 1, 1,
! 2563: /* DCS PU1 PU2 STS CCH MW SPA EPA */
! 2564: 1, 1, 1, 1, 1, 1, 1, 1,
! 2565: /* x98 x99 x9A CSI ST OSC PM APC */
! 2566: 1, 1, 1, 1, 1, 1, 1, 1,
! 2567: /* - i c/ L ox Y- | So */
! 2568: 160, 161, 162, 163, 164, 165, 166, 167,
! 2569: /* .. c0 ip << _ R0 - */
! 2570: 168, 169, 170, 171, 172, 173, 174, 175,
! 2571: /* o +- 2 3 ' u q| . */
! 2572: 176, 177, 178, 179, 180, 181, 182, 183,
! 2573: /* , 1 2 >> 1/4 1/2 3/4 ? */
! 2574: 184, 185, 186, 187, 188, 189, 190, 191,
! 2575: /* A` A' A^ A~ A: Ao AE C, */
! 2576: 48, 48, 48, 48, 48, 48, 48, 48,
! 2577: /* E` E' E^ E: I` I' I^ I: */
! 2578: 48, 48, 48, 48, 48, 48, 48, 48,
! 2579: /* D- N~ O` O' O^ O~ O: X */
! 2580: 48, 48, 48, 48, 48, 48, 48, 216,
! 2581: /* O/ U` U' U^ U: Y' P B */
! 2582: 48, 48, 48, 48, 48, 48, 48, 48,
! 2583: /* a` a' a^ a~ a: ao ae c, */
! 2584: 48, 48, 48, 48, 48, 48, 48, 48,
! 2585: /* e` e' e^ e: i` i' i^ i: */
! 2586: 48, 48, 48, 48, 48, 48, 48, 48,
! 2587: /* d n~ o` o' o^ o~ o: -: */
! 2588: 48, 48, 48, 48, 48, 48, 48, 248,
! 2589: /* o/ u` u' u^ u: y' P y: */
! 2590: 48, 48, 48, 48, 48, 48, 48, 48
! 2591: };
! 2592:
! 2593: /*
! 2594: * Find the first blank beginning after the current cursor position
! 2595: */
! 2596: unsigned char
! 2597: skip_char_right(unsigned short offset)
! 2598: {
! 2599: struct wsdisplay_charcell cell;
! 2600: unsigned short current = offset;
! 2601: unsigned short limit = current + (N_COLS - (MOUSE % N_COLS) - 1);
! 2602: unsigned char class;
! 2603: unsigned char res = 0;
! 2604:
! 2605: GETCHAR(current, &cell);
! 2606: class = charClass[cell.uc & 0xff];
! 2607: while (GETCHAR(current, &cell) == 0 &&
! 2608: charClass[cell.uc & 0xff] == class && current <= limit) {
! 2609: current++;
! 2610: res++;
! 2611: }
! 2612: if (res)
! 2613: res--;
! 2614: return (res);
! 2615: }
! 2616:
! 2617: /*
! 2618: * Find the first non-blank character before the cursor position
! 2619: */
! 2620: unsigned char
! 2621: skip_char_left(unsigned short offset)
! 2622: {
! 2623: struct wsdisplay_charcell cell;
! 2624: short current = offset;
! 2625: unsigned short limit = current - (MOUSE % N_COLS);
! 2626: unsigned char class;
! 2627: unsigned char res = 0;
! 2628:
! 2629: GETCHAR(current, &cell);
! 2630: class = charClass[cell.uc & 0xff];
! 2631: while (GETCHAR(current, &cell) == 0 &&
! 2632: charClass[cell.uc & 0xff] == class && current >= limit) {
! 2633: current--;
! 2634: res++;
! 2635: }
! 2636: if (res)
! 2637: res--;
! 2638: return (res);
! 2639: }
! 2640:
! 2641: /*
! 2642: * Compare character classes
! 2643: */
! 2644: unsigned char
! 2645: class_cmp(unsigned short first, unsigned short second)
! 2646: {
! 2647: struct wsdisplay_charcell cell;
! 2648: unsigned char first_class;
! 2649: unsigned char second_class;
! 2650:
! 2651: if (GETCHAR(first, &cell) != 0)
! 2652: return (1);
! 2653: first_class = charClass[cell.uc & 0xff];
! 2654: if (GETCHAR(second, &cell) != 0)
! 2655: return (1);
! 2656: second_class = charClass[cell.uc & 0xff];
! 2657:
! 2658: if (first_class != second_class)
! 2659: return (1);
! 2660: else
! 2661: return (0);
! 2662: }
! 2663:
! 2664: /*
! 2665: * Beginning of a copy operation
! 2666: */
! 2667: void
! 2668: mouse_copy_start(void)
! 2669: {
! 2670: unsigned char right;
! 2671: /* if no selection, then that's the first one */
! 2672:
! 2673: if (!Paste_avail)
! 2674: Paste_avail = 1;
! 2675:
! 2676: /* remove the previous selection */
! 2677:
! 2678: if (IS_SEL_EXISTS(sc->sc_focus))
! 2679: remove_selection(sc);
! 2680:
! 2681: /* initial show of the cursor */
! 2682: if (!IS_MOUSE_VISIBLE(sc->sc_focus))
! 2683: inverse_char(MOUSE);
! 2684:
! 2685: CPY_START = MOUSE;
! 2686: CPY_END = MOUSE;
! 2687: ORIG_START = CPY_START;
! 2688: ORIG_END = CPY_END;
! 2689: CURSOR = CPY_END + 1; /* init value */
! 2690:
! 2691: right = skip_spc_right(BORDER); /* useful later, in mouse_copy_extend */
! 2692: if (right)
! 2693: MOUSE_FLAGS |= BLANK_TO_EOL;
! 2694:
! 2695: MOUSE_FLAGS |= SEL_IN_PROGRESS;
! 2696: MOUSE_FLAGS |= SEL_EXISTS;
! 2697: MOUSE_FLAGS |= SEL_BY_CHAR; /* select by char */
! 2698: MOUSE_FLAGS &= ~SEL_BY_WORD;
! 2699: MOUSE_FLAGS &= ~SEL_BY_LINE;
! 2700: MOUSE_FLAGS &= ~MOUSE_VISIBLE; /* cursor hidden in selection */
! 2701: }
! 2702:
! 2703: /*
! 2704: * Copy of the word under the cursor
! 2705: */
! 2706: void
! 2707: mouse_copy_word()
! 2708: {
! 2709: struct wsdisplay_charcell cell;
! 2710: unsigned char right;
! 2711: unsigned char left;
! 2712:
! 2713: if (IS_SEL_EXISTS(sc->sc_focus))
! 2714: remove_selection(sc);
! 2715:
! 2716: if (IS_MOUSE_VISIBLE(sc->sc_focus))
! 2717: inverse_char(MOUSE);
! 2718:
! 2719: CPY_START = MOUSE;
! 2720: CPY_END = MOUSE;
! 2721:
! 2722: if (GETCHAR(MOUSE, &cell) == 0 && IS_ALPHANUM(cell.uc)) {
! 2723: right = skip_char_right(CPY_END);
! 2724: left = skip_char_left(CPY_START);
! 2725: } else {
! 2726: right = skip_spc_right(NO_BORDER);
! 2727: left = skip_spc_left();
! 2728: }
! 2729:
! 2730: CPY_START -= left;
! 2731: CPY_END += right;
! 2732: ORIG_START = CPY_START;
! 2733: ORIG_END = CPY_END;
! 2734: CURSOR = CPY_END + 1; /* init value, never happen */
! 2735: inverse_region(CPY_START, CPY_END);
! 2736:
! 2737: MOUSE_FLAGS |= SEL_IN_PROGRESS;
! 2738: MOUSE_FLAGS |= SEL_EXISTS;
! 2739: MOUSE_FLAGS &= ~SEL_BY_CHAR;
! 2740: MOUSE_FLAGS |= SEL_BY_WORD;
! 2741: MOUSE_FLAGS &= ~SEL_BY_LINE;
! 2742:
! 2743: /* mouse cursor hidden in the selection */
! 2744: MOUSE_FLAGS &= ~BLANK_TO_EOL;
! 2745: MOUSE_FLAGS &= ~MOUSE_VISIBLE;
! 2746: }
! 2747:
! 2748: /*
! 2749: * Copy of the current line
! 2750: */
! 2751: void
! 2752: mouse_copy_line(void)
! 2753: {
! 2754: unsigned char row = MOUSE / N_COLS;
! 2755:
! 2756: if (IS_SEL_EXISTS(sc->sc_focus))
! 2757: remove_selection(sc);
! 2758:
! 2759: if (IS_MOUSE_VISIBLE(sc->sc_focus))
! 2760: inverse_char(MOUSE);
! 2761:
! 2762: CPY_START = row * N_COLS;
! 2763: CPY_END = CPY_START + (N_COLS - 1);
! 2764: ORIG_START = CPY_START;
! 2765: ORIG_END = CPY_END;
! 2766: CURSOR = CPY_END + 1;
! 2767: inverse_region(CPY_START, CPY_END);
! 2768:
! 2769: MOUSE_FLAGS |= SEL_IN_PROGRESS;
! 2770: MOUSE_FLAGS |= SEL_EXISTS;
! 2771: MOUSE_FLAGS &= ~SEL_BY_CHAR;
! 2772: MOUSE_FLAGS &= ~SEL_BY_WORD;
! 2773: MOUSE_FLAGS |= SEL_BY_LINE;
! 2774:
! 2775: /* mouse cursor hidden in the selection */
! 2776: MOUSE_FLAGS &= ~BLANK_TO_EOL;
! 2777: MOUSE_FLAGS &= ~MOUSE_VISIBLE;
! 2778: }
! 2779:
! 2780: /*
! 2781: * End of a copy operation
! 2782: */
! 2783: void
! 2784: mouse_copy_end(void)
! 2785: {
! 2786: MOUSE_FLAGS &= ~(SEL_IN_PROGRESS);
! 2787: if (IS_SEL_BY_WORD(sc->sc_focus) || IS_SEL_BY_LINE(sc->sc_focus)) {
! 2788: if (CURSOR != (CPY_END + 1))
! 2789: inverse_char(CURSOR);
! 2790: CURSOR = CPY_END + 1;
! 2791: }
! 2792: }
! 2793:
! 2794:
! 2795: /*
! 2796: * Generic selection extend function
! 2797: */
! 2798: void
! 2799: mouse_copy_extend(void)
! 2800: {
! 2801: if (IS_SEL_BY_CHAR(sc->sc_focus))
! 2802: mouse_copy_extend_char();
! 2803: if (IS_SEL_BY_WORD(sc->sc_focus))
! 2804: mouse_copy_extend_word();
! 2805: if (IS_SEL_BY_LINE(sc->sc_focus))
! 2806: mouse_copy_extend_line();
! 2807: }
! 2808:
! 2809: /*
! 2810: * Extend a selected region, character by character
! 2811: */
! 2812: void
! 2813: mouse_copy_extend_char()
! 2814: {
! 2815: unsigned char right;
! 2816:
! 2817: if (!IS_SEL_EXT_AFTER(sc->sc_focus)) {
! 2818:
! 2819: if (IS_BLANK_TO_EOL(sc->sc_focus)) {
! 2820: /*
! 2821: * First extension of selection. We handle special
! 2822: * cases of blank characters to eol
! 2823: */
! 2824:
! 2825: right = skip_spc_right(BORDER);
! 2826: if (MOUSE > ORIG_START) {
! 2827: /* the selection goes to the lower part of
! 2828: the screen */
! 2829:
! 2830: /* remove the previous cursor, start of
! 2831: selection is now next line */
! 2832: inverse_char(CPY_START);
! 2833: CPY_START += (right + 1);
! 2834: CPY_END = CPY_START;
! 2835: ORIG_START = CPY_START;
! 2836: /* simulate the initial mark */
! 2837: inverse_char(CPY_START);
! 2838: } else {
! 2839: /* the selection goes to the upper part
! 2840: of the screen */
! 2841: /* remove the previous cursor, start of
! 2842: selection is now at the eol */
! 2843: inverse_char(CPY_START);
! 2844: ORIG_START += (right + 1);
! 2845: CPY_START = ORIG_START - 1;
! 2846: CPY_END = ORIG_START - 1;
! 2847: /* simulate the initial mark */
! 2848: inverse_char(CPY_START);
! 2849: }
! 2850: MOUSE_FLAGS &= ~ BLANK_TO_EOL;
! 2851: }
! 2852:
! 2853: if (MOUSE < ORIG_START && CPY_END >= ORIG_START) {
! 2854: /* we go to the upper part of the screen */
! 2855:
! 2856: /* reverse the old selection region */
! 2857: remove_selection(sc);
! 2858: CPY_END = ORIG_START - 1;
! 2859: CPY_START = ORIG_START;
! 2860: }
! 2861: if (CPY_START < ORIG_START && MOUSE >= ORIG_START) {
! 2862: /* we go to the lower part of the screen */
! 2863:
! 2864: /* reverse the old selection region */
! 2865:
! 2866: remove_selection(sc);
! 2867: CPY_START = ORIG_START;
! 2868: CPY_END = ORIG_START - 1;
! 2869: }
! 2870: /* restore flags cleared in remove_selection() */
! 2871: MOUSE_FLAGS |= SEL_IN_PROGRESS;
! 2872: MOUSE_FLAGS |= SEL_EXISTS;
! 2873: }
! 2874: /* beginning of common part */
! 2875:
! 2876: if (MOUSE >= ORIG_START) {
! 2877:
! 2878: /* lower part of the screen */
! 2879: if (MOUSE > CPY_END) {
! 2880: /* extending selection */
! 2881: inverse_region(CPY_END + 1, MOUSE);
! 2882: } else {
! 2883: /* reducing selection */
! 2884: inverse_region(MOUSE + 1, CPY_END);
! 2885: }
! 2886: CPY_END = MOUSE;
! 2887: } else {
! 2888: /* upper part of the screen */
! 2889: if (MOUSE < CPY_START) {
! 2890: /* extending selection */
! 2891: inverse_region(MOUSE,CPY_START - 1);
! 2892: } else {
! 2893: /* reducing selection */
! 2894: inverse_region(CPY_START,MOUSE - 1);
! 2895: }
! 2896: CPY_START = MOUSE;
! 2897: }
! 2898: /* end of common part */
! 2899: }
! 2900:
! 2901: /*
! 2902: * Extend a selected region, word by word
! 2903: */
! 2904: void
! 2905: mouse_copy_extend_word(void)
! 2906: {
! 2907: unsigned short old_cpy_end;
! 2908: unsigned short old_cpy_start;
! 2909:
! 2910: if (!IS_SEL_EXT_AFTER(sc->sc_focus)) {
! 2911:
! 2912: /* remove cursor in selection (black one) */
! 2913:
! 2914: if (CURSOR != (CPY_END + 1))
! 2915: inverse_char(CURSOR);
! 2916:
! 2917: /* now, switch between lower and upper part of the screen */
! 2918:
! 2919: if (MOUSE < ORIG_START && CPY_END >= ORIG_START) {
! 2920: /* going to the upper part of the screen */
! 2921: inverse_region(ORIG_END + 1, CPY_END);
! 2922: CPY_END = ORIG_END;
! 2923: }
! 2924:
! 2925: if (MOUSE > ORIG_END && CPY_START <= ORIG_START) {
! 2926: /* going to the lower part of the screen */
! 2927: inverse_region(CPY_START, ORIG_START - 1);
! 2928: CPY_START = ORIG_START;
! 2929: }
! 2930: }
! 2931:
! 2932: if (MOUSE >= ORIG_START) {
! 2933: /* lower part of the screen */
! 2934:
! 2935: if (MOUSE > CPY_END) {
! 2936: /* extending selection */
! 2937:
! 2938: old_cpy_end = CPY_END;
! 2939: CPY_END = MOUSE + skip_char_right(MOUSE);
! 2940: inverse_region(old_cpy_end + 1, CPY_END);
! 2941: } else {
! 2942: if (class_cmp(MOUSE, MOUSE + 1)) {
! 2943: /* reducing selection (remove last word) */
! 2944: old_cpy_end = CPY_END;
! 2945: CPY_END = MOUSE;
! 2946: inverse_region(CPY_END + 1, old_cpy_end);
! 2947: } else {
! 2948: old_cpy_end = CPY_END;
! 2949: CPY_END = MOUSE + skip_char_right(MOUSE);
! 2950: if (CPY_END != old_cpy_end) {
! 2951: /* reducing selection, from the end of
! 2952: * next word */
! 2953: inverse_region(CPY_END + 1,
! 2954: old_cpy_end);
! 2955: }
! 2956: }
! 2957: }
! 2958: } else {
! 2959: /* upper part of the screen */
! 2960: if (MOUSE < CPY_START) {
! 2961: /* extending selection */
! 2962: old_cpy_start = CPY_START;
! 2963: CPY_START = MOUSE - skip_char_left(MOUSE);
! 2964: inverse_region(CPY_START, old_cpy_start - 1);
! 2965: } else {
! 2966: if (class_cmp(MOUSE - 1, MOUSE)) {
! 2967: /* reducing selection (remove last word) */
! 2968: old_cpy_start = CPY_START;
! 2969: CPY_START = MOUSE;
! 2970: inverse_region(old_cpy_start,
! 2971: CPY_START - 1);
! 2972: } else {
! 2973: old_cpy_start = CPY_START;
! 2974: CPY_START = MOUSE - skip_char_left(MOUSE);
! 2975: if (CPY_START != old_cpy_start) {
! 2976: inverse_region(old_cpy_start,
! 2977: CPY_START - 1);
! 2978: }
! 2979: }
! 2980: }
! 2981: }
! 2982:
! 2983: if (!IS_SEL_EXT_AFTER(sc->sc_focus)) {
! 2984: /* display new cursor */
! 2985: CURSOR = MOUSE;
! 2986: inverse_char(CURSOR);
! 2987: }
! 2988: }
! 2989:
! 2990: /*
! 2991: * Extend a selected region, line by line
! 2992: */
! 2993: void
! 2994: mouse_copy_extend_line(void)
! 2995: {
! 2996: unsigned short old_row;
! 2997: unsigned short new_row;
! 2998: unsigned short old_cpy_start;
! 2999: unsigned short old_cpy_end;
! 3000:
! 3001: if (!IS_SEL_EXT_AFTER(sc->sc_focus)) {
! 3002: /* remove cursor in selection (black one) */
! 3003:
! 3004: if (CURSOR != (CPY_END + 1))
! 3005: inverse_char(CURSOR);
! 3006:
! 3007: /* now, switch between lower and upper part of the screen */
! 3008:
! 3009: if (MOUSE < ORIG_START && CPY_END >= ORIG_START) {
! 3010: /* going to the upper part of the screen */
! 3011: inverse_region(ORIG_END + 1, CPY_END);
! 3012: CPY_END = ORIG_END;
! 3013: }
! 3014:
! 3015: if (MOUSE > ORIG_END && CPY_START <= ORIG_START) {
! 3016: /* going to the lower part of the screen */
! 3017: inverse_region(CPY_START, ORIG_START - 1);
! 3018: CPY_START = ORIG_START;
! 3019: }
! 3020: }
! 3021:
! 3022: if (MOUSE >= ORIG_START) {
! 3023: /* lower part of the screen */
! 3024: if (CURSOR == (CPY_END + 1))
! 3025: CURSOR = CPY_END;
! 3026: old_row = CURSOR / N_COLS;
! 3027: new_row = MOUSE / N_COLS;
! 3028: old_cpy_end = CPY_END;
! 3029: CPY_END = (new_row * N_COLS) + MAXCOL;
! 3030: if (new_row > old_row)
! 3031: inverse_region(old_cpy_end + 1, CPY_END);
! 3032: else if (new_row < old_row)
! 3033: inverse_region(CPY_END + 1, old_cpy_end);
! 3034: } else {
! 3035: /* upper part of the screen */
! 3036: old_row = CURSOR / N_COLS;
! 3037: new_row = MOUSE / N_COLS;
! 3038: old_cpy_start = CPY_START;
! 3039: CPY_START = new_row * N_COLS;
! 3040: if (new_row < old_row)
! 3041: inverse_region(CPY_START, old_cpy_start - 1);
! 3042: else if (new_row > old_row)
! 3043: inverse_region(old_cpy_start, CPY_START - 1);
! 3044: }
! 3045:
! 3046: if (!IS_SEL_EXT_AFTER(sc->sc_focus)) {
! 3047: /* display new cursor */
! 3048: CURSOR = MOUSE;
! 3049: inverse_char(CURSOR);
! 3050: }
! 3051: }
! 3052:
! 3053: void
! 3054: mouse_hide(struct wsdisplay_softc *sc)
! 3055: {
! 3056: if (IS_MOUSE_VISIBLE(sc->sc_focus)) {
! 3057: inverse_char(MOUSE);
! 3058: MOUSE_FLAGS &= ~MOUSE_VISIBLE;
! 3059: }
! 3060: }
! 3061:
! 3062: /*
! 3063: * Add an extension to a selected region, word by word
! 3064: */
! 3065: void
! 3066: mouse_copy_extend_after(void)
! 3067: {
! 3068: unsigned short start_dist;
! 3069: unsigned short end_dist;
! 3070:
! 3071: if (IS_SEL_EXISTS(sc->sc_focus)) {
! 3072: MOUSE_FLAGS |= SEL_EXT_AFTER;
! 3073: mouse_hide(sc); /* hide current cursor */
! 3074:
! 3075: if (CPY_START > MOUSE)
! 3076: start_dist = CPY_START - MOUSE;
! 3077: else
! 3078: start_dist = MOUSE - CPY_START;
! 3079: if (MOUSE > CPY_END)
! 3080: end_dist = MOUSE - CPY_END;
! 3081: else
! 3082: end_dist = CPY_END - MOUSE;
! 3083: if (start_dist < end_dist) {
! 3084: /* upper part of the screen*/
! 3085: ORIG_START = MOUSE + 1;
! 3086: /* only used in mouse_copy_extend_line() */
! 3087: CURSOR = CPY_START;
! 3088: } else {
! 3089: /* lower part of the screen */
! 3090: ORIG_START = MOUSE;
! 3091: /* only used in mouse_copy_extend_line() */
! 3092: CURSOR = CPY_END;
! 3093: }
! 3094: if (IS_SEL_BY_CHAR(sc->sc_focus))
! 3095: mouse_copy_extend_char();
! 3096: if (IS_SEL_BY_WORD(sc->sc_focus))
! 3097: mouse_copy_extend_word();
! 3098: if (IS_SEL_BY_LINE(sc->sc_focus))
! 3099: mouse_copy_extend_line();
! 3100: mouse_copy_selection();
! 3101: }
! 3102: }
! 3103:
! 3104: /*
! 3105: * Remove a previously selected region
! 3106: */
! 3107: void
! 3108: remove_selection(struct wsdisplay_softc *sc)
! 3109: {
! 3110: if (IS_SEL_EXT_AFTER(sc->sc_focus)) {
! 3111: /* reset the flag indicating an extension of selection */
! 3112: MOUSE_FLAGS &= ~SEL_EXT_AFTER;
! 3113: }
! 3114: inverse_region(CPY_START, CPY_END);
! 3115: MOUSE_FLAGS &= ~SEL_IN_PROGRESS;
! 3116: MOUSE_FLAGS &= ~SEL_EXISTS;
! 3117: }
! 3118:
! 3119: /*
! 3120: * Put the current visual selection in the selection buffer
! 3121: */
! 3122: void
! 3123: mouse_copy_selection(void)
! 3124: {
! 3125: struct wsdisplay_charcell cell;
! 3126: unsigned short current = 0;
! 3127: unsigned short blank = current;
! 3128: unsigned short buf_end = ((N_COLS + 1) * N_ROWS);
! 3129: unsigned short sel_cur;
! 3130: unsigned short sel_end;
! 3131:
! 3132: sel_cur = CPY_START;
! 3133: sel_end = CPY_END;
! 3134:
! 3135: while (sel_cur <= sel_end && current < buf_end - 1) {
! 3136: if (GETCHAR(sel_cur, &cell) != 0)
! 3137: break;
! 3138: Copybuffer[current] = cell.uc;
! 3139: if (!IS_SPACE(Copybuffer[current]))
! 3140: blank = current + 1; /* first blank after non-blank */
! 3141: current++;
! 3142: if (POS_TO_X(sel_cur) == MAXCOL) {
! 3143: /* we are on the last col of the screen */
! 3144: Copybuffer[blank] = '\r'; /* carriage return */
! 3145: current = blank + 1; /* restart just after the carriage
! 3146: return in the buffer */
! 3147: blank = current;
! 3148: }
! 3149: sel_cur++;
! 3150: }
! 3151:
! 3152: Copybuffer[current] = '\0';
! 3153: }
! 3154:
! 3155: /*
! 3156: * Paste the current selection
! 3157: */
! 3158: void
! 3159: mouse_paste(void)
! 3160: {
! 3161: unsigned short len;
! 3162: unsigned char *current = Copybuffer;
! 3163:
! 3164: if (Paste_avail) {
! 3165: for (len = strlen(Copybuffer) ; len > 0; len--) {
! 3166: (*linesw[sc->sc_focus->scr_tty->t_line].l_rint)
! 3167: (*current++, sc->sc_focus->scr_tty);
! 3168: }
! 3169: }
! 3170: }
! 3171:
! 3172: /*
! 3173: * Handle the z axis.
! 3174: * The z axis (roller or wheel) is mapped by default to scrollback.
! 3175: */
! 3176: void
! 3177: mouse_zaxis(int z)
! 3178: {
! 3179: if (z < 0)
! 3180: wsscrollback(sc, WSDISPLAY_SCROLL_BACKWARD);
! 3181: else
! 3182: wsscrollback(sc, WSDISPLAY_SCROLL_FORWARD);
! 3183: }
! 3184:
! 3185: /*
! 3186: * Allocate the copy buffer. The size is:
! 3187: * (cols + 1) * (rows)
! 3188: * (+1 for '\n' at the end of lines),
! 3189: * where cols and rows are the maximum of column and rows of all screens.
! 3190: */
! 3191: void
! 3192: allocate_copybuffer(struct wsdisplay_softc *sc)
! 3193: {
! 3194: int nscreens = sc->sc_scrdata->nscreens;
! 3195: int i,s;
! 3196: const struct wsscreen_descr **screens_list = sc->sc_scrdata->screens;
! 3197: const struct wsscreen_descr *current;
! 3198: unsigned short size = Copybuffer_size;
! 3199:
! 3200: s = spltty();
! 3201: for (i = 0; i < nscreens; i++) {
! 3202: current = *screens_list;
! 3203: if (( (current->ncols + 1) * current->nrows) > size)
! 3204: size = ((current->ncols + 1) * current->nrows);
! 3205: screens_list++;
! 3206: }
! 3207: if ((size != Copybuffer_size) && (Copybuffer_size != 0)) {
! 3208: bzero(Copybuffer, Copybuffer_size);
! 3209: free(Copybuffer, M_DEVBUF);
! 3210: }
! 3211: if ((Copybuffer = (char *)malloc(size, M_DEVBUF, M_NOWAIT)) == NULL) {
! 3212: printf("wscons: copybuffer memory malloc failed\n");
! 3213: Copybuffer_size = 0;
! 3214: }
! 3215: Copybuffer_size = size;
! 3216: splx(s);
! 3217: }
! 3218:
! 3219:
! 3220: /* Remove selection and cursor on current screen */
! 3221: void
! 3222: mouse_remove(struct wsdisplay_softc *sc)
! 3223: {
! 3224: if (IS_SEL_EXISTS(sc->sc_focus))
! 3225: remove_selection(sc);
! 3226:
! 3227: mouse_hide(sc);
! 3228: }
! 3229:
! 3230: /* Send a wscons event to notify wsmoused(8) to release the mouse device */
! 3231: void
! 3232: wsmoused_release(struct wsdisplay_softc *sc)
! 3233: {
! 3234: #if NWSMOUSE > 0
! 3235: struct device *wsms_dev = NULL;
! 3236: struct device **wsms_dev_list;
! 3237: int is_wsmouse = 0;
! 3238: #if NWSMUX > 0
! 3239: int is_wsmux = 0;
! 3240: #endif /* NWSMUX > 0 */
! 3241:
! 3242: if (sc->wsmoused_dev) {
! 3243: /* wsmoused(8) is running */
! 3244:
! 3245: wsms_dev_list = (struct device **) wsmouse_cd.cd_devs;
! 3246: if (!wsms_dev_list)
! 3247: /* no wsmouse device exists */
! 3248: return ;
! 3249:
! 3250: /* test whether device opened by wsmoused(8) is a wsmux device
! 3251: * (/dev/wsmouse) or a wsmouse device (/dev/wsmouse{0..n} */
! 3252:
! 3253: #if NWSMUX > 0
! 3254: /* obtain major of /dev/wsmouse multiplexor device */
! 3255: /* XXX first member of wsmux_softc is of type struct device */
! 3256: if (cdevsw[major(sc->wsmoused_dev)].d_open == wsmuxopen)
! 3257: is_wsmux = 1;
! 3258:
! 3259: if (is_wsmux && (minor(sc->wsmoused_dev) == WSMOUSEDEVCF_MUX)) {
! 3260: /* /dev/wsmouse case */
! 3261: /* XXX at least, wsmouse0 exist */
! 3262: wsms_dev = wsms_dev_list[0];
! 3263: }
! 3264: #endif /* NWSMUX > 0 */
! 3265:
! 3266: /* obtain major of /dev/wsmouse{0..n} devices */
! 3267: if (wsmouse_cd.cd_ndevs > 0) {
! 3268: if (cdevsw[major(sc->wsmoused_dev)].d_open ==
! 3269: wsmouseopen)
! 3270: is_wsmouse = 1;
! 3271: }
! 3272:
! 3273: if (is_wsmouse && (minor(sc->wsmoused_dev) <= NWSMOUSE)) {
! 3274: /* /dev/wsmouseX case */
! 3275: if (minor(sc->wsmoused_dev) < wsmouse_cd.cd_ndevs) {
! 3276: wsms_dev =
! 3277: wsms_dev_list[minor(sc->wsmoused_dev)];
! 3278: }
! 3279: else
! 3280: /* no corresponding /dev/wsmouseX device */
! 3281: return;
! 3282: }
! 3283:
! 3284: /* inject event to notify wsmoused(8) to close mouse device */
! 3285: if (wsms_dev != NULL)
! 3286: wsmouse_input(wsms_dev, 0, 0, 0, 0, 0,
! 3287: WSMOUSE_INPUT_WSMOUSED_CLOSE);
! 3288:
! 3289: }
! 3290: #endif /* NWSMOUSE > 0 */
! 3291: }
! 3292:
! 3293: /* Wakeup wsmoused(8), so that the mouse device can be reopened */
! 3294: void
! 3295: wsmoused_wakeup(struct wsdisplay_softc *sc)
! 3296: {
! 3297: #if NWSMOUSE > 0
! 3298: if (sc->wsmoused_dev) {
! 3299: sc->wsmoused_sleep = 0;
! 3300: wakeup(&sc->wsmoused_sleep);
! 3301: }
! 3302: #endif /* NWSMOUSE > 0 */
! 3303: }
! 3304: #endif /* WSMOUSED_SUPPORT */
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to wsdisplay.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev / wscons