Beispiel #1
0
void win_textgrid_init_line(window_t *win, char *buffer, int buflen, 
  int readpos)
{
  window_textgrid_t *cutwin = win->data;
  int len;
  
  len = cutwin->width - cutwin->cursorx;
  if (buflen < len)
    len = buflen;
  
  cutwin->buflen = buflen;
  cutwin->buffer = buffer;
  cutwin->inputlen = 0;

  cutwin->inputmaxlen = len;
  cutwin->inputdot.begline = cutwin->cursory;
  cutwin->inputdot.endline = cutwin->cursory;
  cutwin->inputdot.begchar = cutwin->cursorx;
  cutwin->inputdot.endchar = cutwin->inputdot.begchar + len;
  cutwin->originalattr = cutwin->owner->style;
  cutwin->owner->style = style_Input;

  if (readpos) {
    /* The terp has to enter the text. */
    insert_input(cutwin, cutwin->inputdot.begchar, buffer, readpos);
    win_textgrid_layout(cutwin, FALSE);
  }

  /*cutwin->historypos = cutwin->historynum;*/

  if (gli_register_arr) {
    cutwin->inarrayrock = (*gli_register_arr)(buffer, buflen, "&+#!Cn");
  }
}
Beispiel #2
0
static void restore_input(brl_t *brl)
{
    reset_input(brl);

    if (brl->saved != NULL) {
        insert_input(brl, brl->saved, strlen(brl->saved));
        brl_free(brl->saved);
        brl->saved = NULL;
    }
}
Beispiel #3
0
void xgc_grid_insert(window_textgrid_t *cutwin, int ch)
{
  char realch;
  int ix, pos;
  
  /* ### not perfect -- should be all typable chars */
  if (ch < 32 || ch >= 127)
    ch = ' ';

  realch = ch;
  
  if (!DOT_EXISTS(&cutwin->dot)) {
    cutwin->dot.begline = 0;
    cutwin->dot.begchar = 0;
    collapse_dot_back(cutwin);
  }
  
  if (!DOT_LENGTH_ZERO(&cutwin->dot)) {
    kill_input(cutwin, cutwin->dot.begchar, cutwin->dot.endchar);
    collapse_dot_back(cutwin);
  }
  
  ix = compare_pos_to_dot(cutwin, &cutwin->inputdot, cutwin->dot.begchar, cutwin->dot.begline);
  if (ix == 0) {
    pos = cutwin->inputdot.begchar;
  }
  else if (ix == 3) {
    pos = cutwin->inputdot.begchar + cutwin->inputlen;
  }
  else {
    pos = cutwin->dot.begchar;
    if (pos > cutwin->inputdot.begchar + cutwin->inputlen)
      pos = cutwin->inputdot.begchar + cutwin->inputlen;
  }
  cutwin->cursory = cutwin->inputdot.begline;
  
  insert_input(cutwin, pos, &realch, 1);
  
  win_textgrid_layout(cutwin, FALSE);
}
Beispiel #4
0
static void process_input(brl_t *brl)
{
    unsigned char c;
    int           mapped, type, in, n, diff;
    char          out, *line, *hentry;

    while((n = read(brl->fd, &c, sizeof(c))) > 0) {
        if (brl->esc) {
            if (brl->seq_len < (int)sizeof(brl->seq))
                brl->seq[brl->seq_len++] = c;

            if (brl->seq_len == 2) {
                if (c != '[') {
                    mapped = map_esc_sequence(brl);
                    brl->esc = FALSE;
                }
                else
                    continue;
            }
            else {
                if (0x40 <= c && c <= 0x7e) {
                    mapped = map_ctrl_sequence(brl);
                    brl->esc = FALSE;
                }
                else {
                    if (brl->seq_len == (int)sizeof(brl->seq)) {
                        mapped = BRL_TYPE_INVALID;
                        brl->esc = FALSE;
                    }
                    else
                        continue;
                }
            }
        }
        else
            mapped = map_input(brl, c);

        type = BRL_INPUT_TYPE(mapped);
        in   = BRL_INPUT_DATA(mapped);

        switch (type) {
        case BRL_TYPE_SELF:
            out = (char)(in & 0xff);
            insert_input(brl, &out, 1);
            redraw_prompt(brl);
            break;

        case BRL_TYPE_COMMAND:
            switch (in) {
            case BRL_CMD_PREV_LINE:
                if (brl->h.srch == 0)
                    save_input(brl);
                hentry = ringbuf_search(&brl->h, -1, 0, (char *)brl->saved);
                debug(brl, "s:%d,'%s'", brl->h.srch,
                      brl->saved ? brl->saved : "-");
                if (hentry != NULL) {
                    reset_input(brl);
                    insert_input(brl, hentry, strlen(hentry));
                    redraw_prompt(brl);
                }
                else
                    bell(brl);
                break;

            case BRL_CMD_NEXT_LINE:
                hentry = ringbuf_search(&brl->h, +1, 0, (char *)brl->saved);
                debug(brl, "s:%d,'%s'", brl->h.srch,
                      brl->saved ? brl->saved : "-");
                if (hentry != NULL) {
                    if (hentry == brl->saved)
                        restore_input(brl);
                    else {
                        reset_input(brl);
                        insert_input(brl, hentry, strlen(hentry));
                    }
                    redraw_prompt(brl);
                }
                else
                    bell(brl);
                break;

            case BRL_CMD_BACKWARD:
                move_cursor(brl, -1);
                redraw_prompt(brl);
                break;
            case BRL_CMD_FORWARD:
                move_cursor(brl, +1);
                redraw_prompt(brl);
                break;

            case BRL_CMD_LINE_START:
                move_cursor(brl, -brl->offs);
                redraw_prompt(brl);
                break;
            case BRL_CMD_LINE_END:
                move_cursor(brl, brl->data - brl->offs);
                redraw_prompt(brl);
                break;

            case BRL_CMD_ERASE_BEFORE:
                erase_input(brl, -1);
                if (brl->offs < brl->data)
                    move_cursor(brl, -1);
                redraw_prompt(brl);
                break;
            case BRL_CMD_ERASE_AT:
                erase_input(brl, 1);
                redraw_prompt(brl);
                break;

            case BRL_CMD_ERASE_REST:
                save_yank(brl, brl->offs, brl->data);
                erase_input(brl, brl->data - brl->offs);
                redraw_prompt(brl);
                break;
            case BRL_CMD_ERASE_ALL:
                save_yank(brl, 0, brl->data);
                reset_input(brl);
                redraw_prompt(brl);
                break;
            case BRL_CMD_YANK:
                insert_input(brl, (char *)brl->yank, brl->yank_data);
                redraw_prompt(brl);
                break;

            case BRL_CMD_PREV_WORD:
                diff = input_delimiter(brl, -1);
                move_cursor(brl, diff);
                redraw_prompt(brl);
                break;

            case BRL_CMD_NEXT_WORD:
                diff = input_delimiter(brl, +1);
                move_cursor(brl, diff);
                redraw_prompt(brl);
                break;

            case BRL_CMD_REDRAW:
                redraw_prompt(brl);
                break;

            case BRL_CMD_ENTER:
                dprintf(brl->fd, "\n\r");
                if (brl->line_cb != NULL) {
                    line = alloca(brl->data + 1);
                    strncpy(line, (char *)brl->buf, brl->data);
                    line[brl->data] = '\0';
                    reset_input(brl);
                    restore_rawmode(brl);
                    brl->line_cb(brl, line, brl->user_data);
                    enable_rawmode(brl);
                    ringbuf_reset_search(&brl->h);
                    debug(brl, "");
                    redraw_prompt(brl);
                }
                else
                    return;
                break;

            default:
#if 0
                printf("editing command 0x%x\n\r", in);
#endif
                bell(brl);
            }
            break;

        case BRL_TYPE_CSEQ:
            brl->esc     = TRUE;
            brl->seq[0]  = c;
            brl->seq_len = 1;
            break;

        case BRL_TYPE_INVALID:
        default:
            bell(brl);
            break;
        }
    }
}
Beispiel #5
0
 void insert_inout(PropTraits<T> const &t)
 {
     auto out = t.create();
     *dst_ << out;
     insert_input(t.name, setter(out));
 }
Beispiel #6
0
void xgc_grid_cutbuf(window_textgrid_t *cutwin, int op)
{
  long len, num;
  char *buf, *cx;
  
  if (op != op_Copy) {
    if (!cutwin->buffer) {
      xmsg_set_message("You are not editing input in this window.", FALSE);
      return;
    }
  }
  
  switch (op) {
  case op_Copy:
    buf = xgrid_alloc_selection(cutwin, &cutwin->dot, &len);
    if (buf) {
      xglk_store_scrap(buf, len);
      free(buf);
    }
    break;
  case op_Wipe:
    buf = xgrid_alloc_selection(cutwin, &cutwin->dot, &len);
    if (buf) {
      xglk_store_scrap(buf, len);
      free(buf);
    }
    if (dot_contains_dot(cutwin, &cutwin->inputdot, &cutwin->dot)) {
      if (!DOT_LENGTH_ZERO(&cutwin->dot)) {
	kill_input(cutwin, cutwin->dot.begchar, cutwin->dot.endchar);
      }
    }
    break;
  case op_Erase:
    if (dot_contains_dot(cutwin, &cutwin->inputdot, &cutwin->dot)) {
      if (!DOT_LENGTH_ZERO(&cutwin->dot)) {
	kill_input(cutwin, cutwin->dot.begchar, cutwin->dot.endchar);
      }
    }
    break;
  case op_YankReplace:
    if (!dot_contains_dot(cutwin, &cutwin->inputdot, &cutwin->dot))
      break;
    xglk_fetch_scrap(&cx, &num);
    xglk_strip_garbage(cx, num);
    if (cx && num) {
      if (!DOT_LENGTH_ZERO(&cutwin->dot)) {
	kill_input(cutwin, cutwin->dot.begchar, cutwin->dot.endchar);
      }
      insert_input(cutwin, cutwin->dot.begchar, cx, num);
      free(cx);
    }
    break;
  case op_Untype:
    if (cutwin->inputlen > 0) {
      kill_input(cutwin, cutwin->inputdot.begchar, 
	cutwin->inputdot.begchar + cutwin->inputlen);
    }
    break;
  }

  win_textgrid_layout(cutwin, FALSE);
}