Exemple #1
0
static void render_ui(ui_t *ui) {
  chat_tab = COLS-12;
  log_tab = COLS-6;
  render_tab_bar(ACTIVE_CHAT);

  ui->screen = newwin(LINES - 6, COLS - 1, 1, 1);
  scrollok(ui->screen, TRUE);
  box(ui->screen, 0, 0);
  ui->next_line = 1;
  CHAT = new_panel(ui->screen);
  chat_history = ui_history_create();

  ui->log = newwin(LINES - 6, COLS - 1, 1, 1);
  scrollok(ui->log, TRUE);
  box(ui->log, 0, 0);
  ui->next_log_line = 1;
  LOG = new_panel(ui->log);
  log_history = ui_history_create();

  ui->alert = newwin(3, COLS, 1, 0);
  ALERT = new_panel(ui->alert);

  set_panel_userptr(CHAT, LOG);
  set_panel_userptr(LOG, ALERT);
  set_panel_userptr(ALERT, CHAT);

  top_panel(CHAT);
  hide_panel(LOG);
  hide_panel(ALERT);
  update_panels();
  doupdate();

  ui->prompt = newwin(4, COLS - 1, LINES - 5, 1);
  show_prompt(ui, NULL);
}
Exemple #2
0
void tx_hide_listbox(struct scroll_list *list)
{
    hide_panel(list->panel);
    hide_panel(list->borderpanel);
    update_panels();
    doupdate();
}
Exemple #3
0
int
del_panel(PANEL *p)
{

	if (__predict_false(p == NULL))
		return ERR;

	(void) hide_panel(p);
	free(p);

	/*
	 * If the last panel is removed, remove the phantom stdscr
	 * panel as well.
	 *
	 * A program that wants to switch to a different screen with
	 * set_term(3), or ends and recreates curses session with
	 * endwin(3)/initscr(3), must delete all panels first, since
	 * their windows will become invalid.  When it will create its
	 * first new panel afterwards, it will pick up new stdscr.
	 */
	if (TAILQ_LAST(&_deck, deck) == &_stdscr_panel) {
		(void) hide_panel(&_stdscr_panel);
		assert(TAILQ_EMPTY(&_deck));
	}

	return OK;
}
void
menupan_hide(MENUPAN *menupan)
{
    assert(menupan);

    hide_panel(menupan->win);
    hide_panel(menupan->sub);
}
Exemple #5
0
void drawpause()
{
    if (game.paused) {
        box(stdscr, false, false);
        wattrset(stdscr, A_BOLD);
        mvwprintw(stdscr, (LINES/2)-1, (COLS/2)-4, "PAUSED");
        wattrset(stdscr, A_NORMAL);
        hide_panel(game.holdpan);
        hide_panel(game.brdpan);
        hide_panel(game.sidepan);
    }
}
static void
canned_panel(PANEL * px[MAX_PANELS + 1], NCURSES_CONST char *cmd)
{
    int which = cmd[1] - '0';

    saywhat(cmd);
    switch (*cmd) {
    case 'h':
	hide_panel(px[which]);
	break;
    case 's':
	show_panel(px[which]);
	break;
    case 't':
	top_panel(px[which]);
	break;
    case 'b':
	bottom_panel(px[which]);
	break;
    case 'd':
	rmpanel(px[which]);
	break;
    }
    pflush();
    wgetch(stdscr);
}
Exemple #7
0
void show_chat(ui_t *ui) {
  chat_tab = COLS-12;
  log_tab = COLS-6;
  render_tab_bar(ACTIVE_CHAT);

  hide_panel(ALERT);
  reset_borders(ui);
  wclear(ui->screen);
  wresize(ui->screen, LINES - 6, COLS - 1);
  restore_history(ui->screen, chat_history, &ui->next_line);
  box(ui->screen, 0, 0);
  hide_panel(LOG);
  top_panel(CHAT);
  update_panels();
  doupdate();
}
Exemple #8
0
void
shNCursesInterface::delTempWin ()
{
    hide_panel (mPan[kTemp]);
    del_panel (mPan[kTemp]);
    update_panels ();
}
Exemple #9
0
void show_log(ui_t *ui) {
  chat_tab = COLS-12;
  log_tab = COLS-6;
  render_tab_bar(ACTIVE_LOG);

  hide_panel(ALERT);
  reset_borders(ui);
  wclear(ui->log);
  wresize(ui->log, LINES - 6, COLS - 1);
  mvwin(ui->log, 1, 1);
  restore_history(ui->log, log_history, &ui->next_log_line);
  box(ui->log, 0, 0);
  hide_panel(CHAT);
  top_panel(LOG);
  update_panels();
  doupdate();
}
Exemple #10
0
void console::initQuitDialog() {
	this -> quit_window = newwin(5, 40, 5, 5);
	this -> quit_panel = new_panel(this -> quit_window);
	hide_panel(this -> quit_panel);
	update_panels();
	mvwprintw(this -> quit_window, 2, 2, "Do you want really quit (Y/n)?");
	box(this -> quit_window, 0, 0);
	doupdate();
}
Exemple #11
0
void console::initGameOverDialog() {
	this -> game_over_window = newwin(5, 15, 5, 5);
	this -> game_over_panel = new_panel(this -> game_over_window);
	hide_panel(this -> game_over_panel);
	update_panels();
	mvwprintw(this -> game_over_window, 2, 2, "GAME OVER");
	box(this -> game_over_window, 0, 0);
	doupdate();
}
Exemple #12
0
/**
 * map_control -- draw a cursor on the screen and accept control from FSM
 * @ch: the input word from the FSM
 */
int map_control(int ch)
{
        bool dozoom = false;
        struct map_t *tmp;

        if (!nav_win)
                map_cursor_init();

        top_panel(nav_pan);

        switch (ch) 
        {
        case MODE_STARTED:
                map_controls_active = true;
                cursor->Show(cursor);
                show_panel(nav_pan);
                break;
                
        /* Scroll the map in a direction */
        case 'w': case 'a': case 's': case 'd':
        case 'W': case 'A': case 'S': case 'D':
                map_scroll(MAPBOOK->active, ch);
                break;

        /* Move the zoom frame in a direction */
        case 'h': case 'j': case 'k': case 'l':
        case 'H': case 'J': case 'K': case 'L':
                cursor->Move(cursor, ch);
                break;

        /* Select the current zoom frame */
        case '\n':
                dozoom = true;
                break;

        case KEY_ESC:
        case 'm':
                map_controls_active = false;
                show_dock();
                cursor->Hide(cursor);
                hide_panel(nav_pan);
                return MODE_RELEASE;
        }

        /* Adjust for changing y0 or x0 of the map pad */
        y_map = pos_y(cursor->pos) + pos_y(ACTIVE->pos);
        x_map = pos_x(cursor->pos) + pos_x(ACTIVE->pos);
        zoomlevel = MAPBOOK->page;

        print_map_control(y_map, x_map);
        draw_zoom_box(ACTIVE, y_map, x_map);

        if (dozoom)
                set_zoom(MAPBOOK, y_map, x_map);

        return MODE_PERSIST;
}
bool top_globalstats_resize(void *ptr, int width, int height,
			    int *consumed_height) {
    struct globalstat_controller *c = ptr;
    int i;
    
    top_log("%s\n", __func__);

    *consumed_height = 0;
    
    setup_globalstats_geometry(c, width, height, consumed_height);
   
    if(ERR == wresize(c->window, *consumed_height, width)) {
	top_log("wresize error: height %d width %d\n",
		*consumed_height, width);
	return true;
    }

    if(ERR == move_panel(c->panel, 0, 0)) {
	top_log("move_panel error: 0 0\n");
	return true;
    }    

    for(i = 0; i < GLOBALSTAT_TOTAL; ++i) {
	struct globalstat *gs = c->stats + i;
	
	// MWW: Skip the frameworks window if we've got them disabled
	if (!top_prefs_get_frameworks() && (i == GLOBALSTAT_SHAREDLIBS)) continue;

	if(skip_globalstat(i)) {
	    /* Skip and hide the panels for these. */
	    hide_panel(gs->panel);
	    continue;
	}

	gs = c->stats + i;

	/* 
	 * Avoid errors below by resizing and moving the panel to a known
	 * good size/offfset.
	 */
	wresize(gs->window, 1, 1);
	move_panel(gs->panel, 0, 0);

	if(ERR == move_panel(gs->panel, gs->y, gs->x))
	    return true;
	
	if(ERR == wresize(gs->window, gs->size.height, gs->size.width))
	    return true;

	if(ERR == werase(gs->window))
	    return true;
    }

    return false;
}
Exemple #14
0
void console::initNewGameDialog() {
	this -> new_game_window = newwin(7, 40, 5, 5);
	this -> new_game_panel = new_panel(this -> new_game_window);
	hide_panel(this -> new_game_panel);
	update_panels();
	mvwprintw(this -> new_game_window, 2, 2, "Novice");
	mvwprintw(this -> new_game_window, 3, 2, "Normal");
	mvwprintw(this -> new_game_window, 4, 2, "Hard");
	box(this -> new_game_window, 0, 0);
	doupdate();
}
Exemple #15
0
/*
  window.["hidden"] = true/false
  hide or unhide the window.

  Stack:
  1: the instance table
  2: the accessed key
  3: the value to set
*/
int		lui_window_set_hidden(lua_State *L)
{
    PANEL		*p = check_window(L, 1);

    if (lua_toboolean(L, 3))	/* hidden = true -> hide the window */
        hide_panel(p);
    else			       /* hidden = false -> show the window */
        show_panel(p);
    update_panels();
    return 0;			/* TODO: send something ? */
}
Exemple #16
0
void drawctrls()
{
    if (game.paused) {
        box(stdscr, false, false);
        wattrset(stdscr, A_BOLD);
        mvwprintw(stdscr, (LINES/2)-4, (COLS/2)-3, "CONTROLS");
        wattrset(stdscr, A_NORMAL);
        mvwprintw(stdscr, (LINES/2)-3, (COLS/2)-6, "right - right/h");
        mvwprintw(stdscr, (LINES/2)-2, (COLS/2)-5, "left - left/l");
        mvwprintw(stdscr, (LINES/2)-1, (COLS/2)-7, "rotate - up/k");
        mvwprintw(stdscr, (LINES/2)+0, (COLS/2)-5, "down - down/j");
        mvwprintw(stdscr, (LINES/2)+1, (COLS/2)-5, "drop - space");
        mvwprintw(stdscr, (LINES/2)+2, (COLS/2)-6, "pause - p");
        mvwprintw(stdscr, (LINES/2)+3, (COLS/2)-9, "controls - ?");
        mvwprintw(stdscr, (LINES/2)+4, (COLS/2)-5, "quit - q");
        hide_panel(game.holdpan);
        hide_panel(game.brdpan);
        hide_panel(game.sidepan);
    }
}
Exemple #17
0
static int lcp_show_panel(lua_State *L)
{
    PANEL *p = lcp_check(L, 1);

    if (lua_isnoneornil(L, 2) || lua_toboolean(L, 2))
        lua_pushboolean(L, B(show_panel(p)));
    else
        lua_pushboolean(L, B(hide_panel(p)));

    return 1;
}
Exemple #18
0
void CWidget::hide()
{
	DEBUG_ui("CWidget::hide [" + _name + "]");
	hide_panel(_panel);
	_visible = false;

	// Hide subwidgets too
	if(_layout)
		_layout->hide();

	_changed = true;
}
static void remove_tail(struct statistics_controller *c) {
    int i;

    for(i = c->get_total_possible(c) - 1; i >= 0; --i) {
	if(c->state[i].instance && c->state[i].instance->visible) {
	    c->state[i].instance->visible = false;
	    hide_panel(c->state[i].instance->panel);
	    c->total_active_statistics--;
	    return;
	}	 
    }
}
Exemple #20
0
static void read_window_close_current(void)
{
	gui_remove_key_listener(&close_listener);
	if (resize_listener_added)
	{
		gui_remove_resize_listener(&resize_listener);
		resize_listener_added = 0;
	}

	hide_panel(read_panel);
	update_panels();
	doupdate();
}
Exemple #21
0
int del_panel(PANEL *pan)
{
    if (pan)
    {
        if (_panel_is_linked(pan))
            hide_panel(pan);

        free((char *)pan);
        return OK;
    }

    return ERR;
}
Exemple #22
0
int show_panel(PANEL *pan)
{
    if (!pan)
        return ERR;

    if (pan == _top_panel)
        return OK;

    if (_panel_is_linked(pan))
        hide_panel(pan);

    _panel_link_top(pan);

    return OK;
}
Exemple #23
0
int bottom_panel(PANEL *pan)
{
    if (!pan)
        return ERR;

    if (pan == _bottom_panel)
        return OK;

    if (_panel_is_linked(pan))
        hide_panel(pan);

    _panel_link_bottom(pan);

    return OK;
}
Exemple #24
0
int
bottom_panel(PANEL *p)
{

	if (__predict_false(p == NULL))
		return ERR;

	if (__predict_false(PANEL_HIDDEN(p)))
		return ERR;

	(void) hide_panel(p);

	DECK_INSERT_BOTTOM(p);
	return OK;
}
Exemple #25
0
//------------------------------------------------------------------------------
int del_panel( PANEL* pan )
{
	__QCS_FCONTEXT( "del_panel" );

    if( pan )
    {
		if( _panel_is_linked( pan ) )
		{
            hide_panel( pan );
		}

        free( (char*)pan );
        return 0;
    }

    return ERR;
}
Exemple #26
0
void
ui_destroy(ui_t *ui)
{
    // If there is no ui panel, we're done
    if (!ui || !ui->panel)
        return;

    // Hide this panel before destroying
    hide_panel(ui->panel);

    // If panel has a destructor function use it
    if (ui->destroy)
        ui->destroy(ui->panel);

    // Initialize panel pointer
    ui->panel = NULL;
}
Exemple #27
0
void show_split(ui_t *ui) {
  chat_tab = (COLS/2)-7;
  log_tab = COLS-6;
  render_tab_bar(ACTIVE_CHAT);

  hide_panel(ALERT);
  reset_borders(ui);
  wresize(ui->screen, LINES - 6, COLS/2 - 1);
  box(ui->screen, 0, 0);
  show_panel(CHAT);
  wresize(ui->log, LINES - 6, COLS/2);
  mvwin(ui->log, 1, COLS/2);
  box(ui->log, 0, 0);
  show_panel(LOG);
  update_panels();
  doupdate();
  show_prompt(ui, NULL);
}
Exemple #28
0
int display_bridging_locked(WINDOW *mainw,struct panel_state *ps){
	memset(ps,0,sizeof(*ps));
	if(new_display_panel(mainw,ps,BRIDGEROWS,0,L"press 'b' to dismiss display")){
		goto err;
	}
	//update_bridge_details(panel_window(ps->p));
	return OK;

err:
	if(ps->p){
		WINDOW *psw = panel_window(ps->p);

		hide_panel(ps->p);
		del_panel(ps->p);
		delwin(psw);
	}
	memset(ps,0,sizeof(*ps));
	return ERR;
}
Exemple #29
0
int display_network_locked(WINDOW *mainw,struct panel_state *ps){
	memset(ps,0,sizeof(*ps));
	if(new_display_panel(mainw,ps,NETWORKROWS,0,L"press 'n' to dismiss display")){
		goto err;
	}
	update_network_details(panel_window(ps->p));
	return OK;

err:
	if(ps->p){
		WINDOW *psw = panel_window(ps->p);

		hide_panel(ps->p);
		del_panel(ps->p);
		delwin(psw);
	}
	memset(ps,0,sizeof(*ps));
	return ERR;
}
Exemple #30
0
/*
 *  Functions definitions
 */
void send_xy(out_t *info){
    int xy[2];
    char buff[BUFF_S];
    char tmp[5];
    char *lin_col[2];
    char *end;
    int (*attr_ch)(WINDOW*, int);

    lin_col[0] = "Digite a linha [0-99]: ";
    lin_col[1] = "Digite a coluna [0-99]: ";

    flushinp();
    show_panel(info->panel);

    for( int i = 0; i < 2; i++ ){
        attr_ch = wattroff;

        do{
            attr_ch(info->win, COLOR_PAIR(1));

            memset(tmp, 0, 5);

            wclear(info->win);
            box(info->win, 0, 0);

            mvwaddstr(info->win, 1, 1, lin_col[i]);
            wgetnstr(info->win, tmp, 5);
            xy[i] = strtol(tmp, &end, 10);

            attr_ch = wattron;
        }while( tmp == end || *end != 0 || xy[i] < 0 || xy[i] > 99 );
    }

    sprintf(buff, "%d*%d", xy[0], xy[1]);
    send(info->socket, buff, strlen(buff), 0);
    memset(buff, 0, BUFF_S);

    hide_panel(info->panel);
    update_panels();

    return;
}