Beispiel #1
0
void
TermView::_Init()
{
	SetFont(be_fixed_font);

	font_height height;
	GetFontHeight(&height);
	fFontHeight = (int)(ceilf(height.ascent) + ceilf(height.descent)
		+ ceilf(height.leading));
	fFontWidth = (int)be_fixed_font->StringWidth("X");
	fTerm = vterm_new(kDefaultHeight, kDefaultWidth);

	fTermScreen = vterm_obtain_screen(fTerm);
	vterm_screen_set_callbacks(fTermScreen, &sScreenCallbacks, this);
	vterm_screen_reset(fTermScreen, 1);

	vterm_parser_set_utf8(fTerm, 1);

	VTermScreenCell cell;
	VTermPos firstPos;
	firstPos.row = 0;
	firstPos.col = 0;
	_GetCell(firstPos, cell);

	rgb_color background;
	background.red = cell.bg.red;
	background.green = cell.bg.green;
	background.blue = cell.bg.blue;
	background.alpha = 255;

	SetViewColor(background);
	SetLineTerminator("\n");
}
Beispiel #2
0
int
vterm_init(vterm_state_t *s, int width, int height, volatile uint16_t *buffer) 
{
    memset(s, 0, sizeof(vterm_state_t));

    s->magic = VTERM_MAGIC;
    s->width = width;
    s->height = height;
    s->buffer = buffer;
    s->fgColour = VTERM_LIGHT_GRAY;
    s->bgColour = VTERM_BLACK;
    s->autoRenderUpdate = true;

    /* Initialise virtual terminal. */
    dprintf("Initialising %d x %d Virtual Terminal object...\n", width, height);
    s->vt = vterm_new(s->height, s->width);
    if (!s->vt) {
        ROS_ERROR("Failed to create terminal.\n");
        return EINVALID;
    }
    
    /* Grab the virtual screen & state object. */
    s->vts = vterm_obtain_screen(s->vt);
    s->vtstate = vterm_obtain_state(s->vt);
    assert(s->vts && s->vtstate);
    
    /* Set parameters. */
    vterm_parser_set_utf8(s->vt, true);
    vterm_state_set_bold_highbright(s->vtstate, true);
    vterm_screen_reset(s->vts, 1);

    return ESUCCESS;
}
Beispiel #3
0
int main(int argc, char *argv[])
{
  int use_colour = isatty(1);

  int opt;
  while((opt = getopt(argc, argv, "c")) != -1) {
    switch(opt) {
      case 'c': use_colour = 1; break;
    }
  }

  const char *file = argv[optind++];

  int fd;
  if(!file || streq(file, "-"))
    fd = 0; // stdin
  else {
    fd = open(file, O_RDONLY);
    if(fd == -1) {
      fprintf(stderr, "Cannot open %s - %s\n", file, strerror(errno));
      exit(1);
    }
  }

  if(use_colour) {
    special_begin = "\x1b[7m{";
    special_end   = "}\x1b[m";
  }

  /* Size matters not for the parser */
  VTerm *vt = vterm_new(25, 80);
  vterm_set_utf8(vt, 1);
  vterm_parser_set_callbacks(vt, &parser_cbs, NULL);

  int len;
  char buffer[1024];
  while((len = read(fd, buffer, sizeof(buffer))) > 0) {
    vterm_input_write(vt, buffer, len);
  }

  printf("\n");

  close(fd);
  vterm_free(vt);

  return 0;
}
Beispiel #4
0
TermView::TermView()
	:
	BView("TermView", B_WILL_DRAW | B_FRAME_EVENTS)
{
	SetFont(be_fixed_font);

	font_height height;
	GetFontHeight(&height);
	fFontHeight = height.ascent + height.descent + height.leading;
	fFontWidth = be_fixed_font->StringWidth("X");
	fTerm = vterm_new(kDefaultHeight, kDefaultWidth);

	fTermScreen = vterm_obtain_screen(fTerm);
	vterm_screen_set_callbacks(fTermScreen, &sScreenCallbacks, this);
	vterm_screen_reset(fTermScreen, 1);

	vterm_parser_set_utf8(fTerm, 1);
}
Beispiel #5
0
void term_init(struct aug_term *term, int rows, int cols) {
	VTermScreen *vts;
	VTermState *state;

	term->master = 0;
	term->vt = vterm_new(rows, cols);
	state = vterm_obtain_state(term->vt);
	/* have to cast default_color because the api isnt const correct */
	vterm_state_set_default_colors(state, &VTERM_DEFAULT_COLOR, &VTERM_DEFAULT_COLOR);	
	vterm_parser_set_utf8(term->vt, 1);

	vts = vterm_obtain_screen(term->vt);
	vterm_screen_enable_altscreen(vts, 1);
	vterm_screen_set_damage_merge(vts, VTERM_DAMAGE_SCROLL);
	vterm_screen_reset(vts, 1);

	term_inject_clear(term);
	term->user = NULL;
	term->io_callbacks.refresh = NULL;

	AUG_LOCK_INIT(term);
}
Beispiel #6
0
VTermMM::VTermMM(int rows, int columns)
  : fd(0),
    foreground(VTERMMM_WHITE),
    background(VTERMMM_BLACK),
    cells(rows, vrow(columns)),
    reverse(false),
    invalid_region()
{
  for(int row = 0; row < rows; ++row)
  {
    for(int col = 0; col < columns; ++col)
    {
      cells[row][col].SetX(col);
      cells[row][col].SetY(row);
    }
  }
  cursor.row = 0;
  cursor.col = 0;
  invalidate(0, rows, 0, columns);
  _term = vterm_new(rows, columns);
  vterm_parser_set_utf8(_term, 1);
  VTermState *vts = vterm_obtain_state(_term);
  vterm_state_set_callbacks(vts, &vterm_callbacks, this);
}
Beispiel #7
0
GLTerminal* init_gl_term() {
     int rc=0;
     GLTerminal* term  = (GLTerminal*)malloc(sizeof(GLTerminal));
     term->fd_master = posix_openpt(O_RDWR);
     if(term->fd_master < 0) {
        fprintf(stderr,"Error %d in posix_openpt()\n",errno);
        free(term);
        return NULL;
     }
     
     rc = grantpt(term->fd_master);
     if(rc != 0) {
        fprintf(stderr,"Error %d on grantpt()\n",errno);
        free(term);
        return NULL;
     }
     
     rc = unlockpt(term->fd_master);
     if(rc != 0) {
        fprintf(stderr,"Error %d on unlockpt()\n",errno);
        free(term);
        return NULL;
     }
     
     term->fd_slave = open(ptsname(term->fd_master), O_RDWR);

     term->vt = vterm_new(25,80);
     vterm_set_utf8(term->vt, false);
     term->vts = vterm_obtain_screen(term->vt);

     vterm_screen_reset(term->vts,1);
     int i=0;
     for(i=0; i<80*25; i++) vterm_input_write(term->vt," ",1);

     term->render_target_fb=0;

     // setup font
     glGenTextures(1,&(term->font_texture));
     glBindTexture(GL_TEXTURE_2D, term->font_texture);

     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

     glTexImage2D(GL_TEXTURE_2D,0, GL_RGB, Console_FontData.width,
                                           Console_FontData.height,
                                           0, GL_RGB, GL_UNSIGNED_BYTE, Console_FontData.pixel_data);

     // configure render target
     glGenFramebuffers(1,&(term->render_target_fb));
     glBindFramebuffer(GL_FRAMEBUFFER,term->render_target_fb);

     GLuint tex_id;
     glGenTextures(1,&tex_id);
     term->render_target = tex_id;
     glBindTexture(GL_TEXTURE_2D,tex_id);

     glTexImage2D(GL_TEXTURE_2D, 0,3, TERM_SIZE, TERM_SIZE, 0,GL_RGB, GL_UNSIGNED_BYTE,NULL);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
     glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
     glFramebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, term->render_target,0);
     GLenum DrawBuffers[1] = {GL_COLOR_ATTACHMENT0};
     glDrawBuffers(1,DrawBuffers);
     glBindFramebuffer(GL_FRAMEBUFFER,0);


     return term;
}
Beispiel #8
0
int fbterm_init(struct fbterm_ctx *ctx)
{
    if (!font) {
        font = font_open(DEFAULT_FONT);

        if (!font)
            return -1;
    }

    memset(ctx, 0, sizeof(struct fbterm_ctx));
    ctx->font = font;

    fb_term_init(ctx);
    fb_cook_wallpaper(ctx, DEFAULT_WALLPAPER);

    VTerm *vt = vterm_new(ctx->rows, ctx->cols);
    ctx->vt = vt;

    VTermScreen *sc = vterm_obtain_screen(vt);
    vterm_screen_set_callbacks(sc, &screen_cbs, ctx);
    vterm_screen_reset(sc, 0);
    ctx->screen = sc;

    VTermRect r = {.start_row = 0, .end_row = ctx->rows, .start_col = 0, .end_col = ctx->cols};
    damage(r, ctx);

    return 0;
}

int kbd_fd = -1;
int pty    = -1;

int fbterm_main()
{
    struct fbterm_ctx *active = &term[0]; 

    struct winsize ws;
    ws.ws_row = active->rows;
    ws.ws_col = active->cols;
    ioctl(pty, TIOCSWINSZ, &ws);

    fbterm_redraw(active);

    size_t len;
    char buf[1024];

    while (1) {
        /* Read input */
        if ((len = read(pty, buf, sizeof(buf))) > 0) {
            vterm_input_write(active->vt, buf, len);
        }

        fbterm_redraw(active);

        /* Write output */
        while (vterm_output_get_buffer_current(active->vt) > 0) {
            size_t s = vterm_output_read(active->vt, buf, 1024);
            write(pty, buf, s);
        }
    }

    return 0;
}

char *pts_fn = NULL;    /* XXX */
void launch_shell()
{
    int shell_pid = 0;
relaunch:
    if (shell_pid = fork()) {   /* Relaunch shell if died */
        int s, pid;
        do {
            pid = waitpid(shell_pid, &s, 0);
        } while (pid != shell_pid);

        /* Uh..Oh shell died */
        goto relaunch;
    } else {
        for (int i = 0; i < 10; ++i)
            close(i);

        int stdin_fd  = open(pts_fn, O_RDONLY);
        int stdout_fd = open(pts_fn, O_WRONLY);
        int stderr_fd = open(pts_fn, O_WRONLY);

        /* run login shell */
        char *argp[] = {DEFAULT_SHELL, "login", NULL};
        char *envp[] = {"PWD=/", "TERM=VT100", NULL};
        execve(DEFAULT_SHELL, argp, envp);
        for (;;);
    }
}