Exemple #1
0
int main(int argc, char **argv) {

    init_efl();

    char *theme = find_theme();
    if (!theme)
		fatal("Could not find theme");

    Ecore_Evas *ee = ecore_evas_software_x11_new(NULL, 0,  0, 0, 400, 400);
    if (!ee) {
		fprintf(stderr, "FATAL: Could not get an ee...\n");
		exit(1);
	}
    Ecore_X_Screen_Size sz = get_screen_size(ee);
    ecore_evas_resize(ee, sz.width, sz.height);
    ecore_evas_title_set(ee, "Launcher");
    ecore_evas_borderless_set(ee, 1);
    ecore_evas_fullscreen_set(ee, 1);

    Evas *evas = ecore_evas_get(ee);
    Evas_Object *edje = edje_object_add(evas);
    edje_object_file_set(edje, theme, "main");
    evas_object_move(edje, 0, 0);
    evas_object_resize(edje, sz.width, sz.height);
    evas_object_show(edje);

    ecore_evas_show(ee);
    ecore_main_loop_begin();

	shutdown_efl();

    return 0;

}
Exemple #2
0
int main() {
    log_file = fopen("./log_file.txt", "w+");
    init();
    init_buffer();
    refresh();
    struct real_coordinate origin = {-4.0, -4.0};
    plot(test, origin, 8, 5);

    get_screen_size();
//    mine_sweeper_init();
    refresh();
    plot(test, origin, 8, 5);

    ioctl(STDERR_FILENO, TIOCGWINSZ, &w);
    while (1) {
        ioctl(STDOUT_FILENO, TIOCGWINSZ, &w);
        if (old_w.ws_col != w.ws_col || old_w.ws_row != w.ws_row) {
            // system("clear");
            // printf("Width %d, Height %d\n", w.ws_col, w.ws_row); // You should output to the buffer now;
            old_w = w;
            buffer_changed = 1;
        }
        if (buffer_changed == 1) {
            refresh();
            // printf("f**k\n");
            buffer_changed = 0;
        }

    }
    getchar();
}
Exemple #3
0
void resizehandler( int sig )
{
  if ( screen_columns )
  {
    get_screen_size( );
  }
  return;
}
void clrscr()
{
  get_screen_size();
  fprintf(PRINTFAST, "\n\r");
  for (unsigned short i = 1; i < max_lines; i++)
    fprintf(PRINTFAST, "\n");
  move(1, 1);
}
Exemple #5
0
/* PROTO */
void
wordwrap_print(char *str, int offset)
{
	char           *linebuf = NULL;
	char           *curline;
	int             firstline = 1;
	int             xx = 0, yy, jj;

#ifdef __MINGW32__
	get_screen_size();
#endif

	curline = str;

	for (;;) {
		if (curline[xx] == 0)
			break;
		if (curline[xx] != ' ' && (curline[xx] != '\n')) {
			xx++;
			continue;
		}
		yy = xx + 1;
		while ((curline[yy] != ' ') && (curline[yy] != '\n')
		       && (curline[yy] != 0))
			yy++;

		if ((curline[xx] == '\n') || (yy > (screen_cols - offset - 4))) {
			linebuf = malloc(xx + 1);

			strncpy(linebuf, curline, xx);
			linebuf[xx] = 0;

			if (!firstline) {
				for (jj = 0; jj < offset; jj++)
					putchar(' ');
			} else {
				firstline = 0;
			}

			printf("%s\n", linebuf);
			curline += xx + 1;
			xx = 0;

			free(linebuf);

			continue;
		}
		xx++;
	}

	if (!firstline)
		for (jj = 0; jj < offset; jj++)
			putchar(' ');

	printf("%s\n", curline);
}
Exemple #6
0
Fichier : osd.c Projet : ihling/mpv
static int get_term_width(void)
{
    get_screen_size();
    int width = screen_width > 0 ? screen_width : 80;
#if defined(__MINGW32__) || defined(__CYGWIN__)
    /* Windows command line is broken (MinGW's rxvt works, but we
     * should not depend on that). */
    width--;
#endif
    return width;
}
Exemple #7
0
void draw_paddles() {
	int width;
	int height;
	
	get_screen_size(width, height);
	
	draw_paddle(width, height, 2, 2, false, 8, '!');
	draw_paddle(width, height, 4, 4, true, 8, '!');

	show_screen();
}
Exemple #8
0
/* PROTO */
void
wordwrap_print_echostr(char *str, char *echostr)
{
	char           *linebuf = NULL;
	char           *curline;
	int             offset;
	int             xx = 0, yy;

#ifdef __MINGW32__
	get_screen_size();
#endif

	offset = strlen(echostr) + 1;
	curline = str;

	for (;;) {
		if (curline[xx] == 0)
			break;
		if (curline[xx] != ' ') {
			xx++;
			continue;
		}
		yy = xx + 1;
		while (curline[yy] != ' ')
			if (curline[yy] == 0)
				break;
			else
				yy++;

		if (yy > (screen_cols - offset - 3)) {
			linebuf = malloc(xx + 1);

			strncpy(linebuf, curline, xx);
			linebuf[xx] = 0;

			set_color(COLOR_PROFILE_ECHOSTR);
			printf("%s", echostr);
			set_color(COLOR_PROFILE);
			printf(" %s\n", linebuf);
			curline += xx + 1;
			xx = 0;

			free(linebuf);
			continue;
		}
		xx++;
	}

	set_color(COLOR_PROFILE_ECHOSTR);
	printf("%s", echostr);
	set_color(COLOR_PROFILE);
	printf(" %s\n", curline);
	set_color(0);
}
Exemple #9
0
void display_setup(void)
{
    initscr();
    noecho();
    keypad(stdscr, 0);
    raw();
    move(0,0);
    refresh();
    get_screen_size();
    if (has_colors())
	start_color();
}
void screen_init(int top, int left, int bottom, int right)
{
    screen_close();				/* make sure "old" screen is closed	*/

    if (scroll_mode == 0)			/* if slow scrolling enabled...		*/
	return;					/* ...now using non-screen output form	*/

    get_screen_size(&max_rows, &max_cols);

    origin_y = top;				/* this is (1,1) of the history area	*/
    origin_x = left;

    /* The width (columns) assumes a worse possible (actually impossible) case where 	*/
    /* there were nothing but a line of xterm cursor positioning controls, i.e.,	*/
    /* "\033[r;cH" where r and c are the row and column screen coordinates and each is	*/
    /* a 3-digit number.  That's 10 bytes per column.					*/

    max_y = max_rows;				/* this many rows			*/
    max_x = max_cols + 10*max_cols;		/* worse possible case for width	*/

    screen       = gdb_malloc(max_y * max_x);	/* allocate the screen buffers...	*/
    prev_screen  = gdb_malloc(max_y * max_x);

    row_len	 = gdb_malloc(max_y * sizeof(int)); /* allocate the row size arrays...	*/
    prev_row_len = gdb_malloc(max_y * sizeof(int));

    memset(screen,      ' ', max_y * max_x);	/* init the screens to all blanks...	*/
    memset(prev_screen, ' ', max_y * max_x);

    memset(row_len,     0, max_y * sizeof(int));/* init the row sizes to all 0's	*/
    memset(prev_row_len,0, max_y * sizeof(int));

    cursor_y = bottom;				/* position the cursor just in case	*/
    cursor_x = left;

    #define TRY_SETVBUF 0
    #if TRY_SETVBUF
    stdout_fd = dup(STDOUT_FILENO);
    if (stdout_fd >= 0) {
	screen_stdout = fdopen(stdout_fd, "a");
	if (!screen_stdout) {
	    screen_stdout = stdout;
	    //close(stdout_fd); // ??
	    stdout_fd = -1;
	} else
	    //setvbuf(screen_stdout, NULL, _IOFBF, BUFSIZE);
	    //setvbuf(screen_stdout, NULL, _IOFBF, 2800);
	    setvbuf(screen_stdout, NULL, _IOFBF, 200);
    }
    #else
    screen_stdout = stdout;
    #endif
}
Exemple #11
0
void progress_bar(unsigned ctrl, unsigned x, unsigned n, unsigned w) {
	int i;
	FILE *stream = stdout;
	static int show_bar = 0;

	switch (ctrl) {
		case 0: /* init */
			if (quiet)
				break;

			if (!isatty(fileno(stream)))
				break;

			show_bar = 1;

			break;

		case 1: /* draw */
			if (show_bar != 1)
				return;

			if ((x != n) && (x % (n / 100 + 1) != 0))
				return;

			if (w == 0) {
				get_screen_size(fileno(stream), &w, NULL);
				w -= 8;
			}

			float ratio = x / (float) n;
			int   c     = ratio * w;

			fprintf(stream, " %3.0f%% [", ratio * 100);

			for (i = 0; i < c; i++)
				fputc('=', stream);

			for (i = c; i < w; i++)
				fputc(' ', stream);

			fprintf(stream, "]\r");
			fflush(stream);

			break;

		case 2: /* end */
			if (show_bar == 1)
				fputc('\n', stream);

			break;
	}
}
static void set_history_size(char *theSetting, Gdb_Set_Type type, void *value, int show,
			     int confirm)
{
    get_screen_size(&max_rows, &max_cols);

    if (new_max_history < max_rows)
    	gdb_error("the history size cannot be set smaller than the number of lines in the history area");
    else {
        if (macsbug_screen && new_max_history < max_history)
	   forget_some_history(new_max_history);
	max_history = new_max_history;
    }
}
Exemple #13
0
int OS_X11::get_current_screen() const {
        int x,y;
        Window child;
        XTranslateCoordinates( x11_display, x11_window, DefaultRootWindow(x11_display), 0, 0, &x, &y, &child);

	int count = get_screen_count();
	for(int i=0; i<count; i++) {
		Point2i pos = get_screen_position(i);
		Size2i size = get_screen_size(i);
		if( (x >= pos.x && x <pos.x + size.width) && (y >= pos.y && y < pos.y + size.height) )
			return i;
	}
	return 0;
}
Exemple #14
0
int main(void)
{
  game_t game;
  menu_t main_menu;
  VMGPFONT small_font;
  int submenus[1];
  bool_t done = FALSE;

  small_font.width = 4;
  small_font.height = 6;
  small_font.bpp = 1;
  small_font.palindex = 1;
  small_font.chartbl = SMALL_FONT+16; /* Which characters are present in the font? */
  small_font.fontdata = SMALL_FONT+16+256; /* The pixel data */

  get_screen_size(&screen_w, &screen_h);

  game_init(&game);

  menu_init(&main_menu, &small_font, main_menu_msgs,
	    0, game.p_title_screen->height, screen_w, screen_h);


  while (!done)
    {
      /* Display title screen */
      vSetTransferMode(MODE_BLOCK);
      vClearScreen(vRGB(0,0,0));
      vDrawObject(0,0, game.p_title_screen);

      switch(menu_select(&main_menu, ~0, submenus))
	{
	case 1:
	  break;
	case 6:
	  return 1;
	case -1:
	default:
	  break;
	}

      vSetTransferMode(MODE_TRANS);
      vPlayResource(NULL,0,SOUND_FLAG_STOP);

      level_goto(&game, &levels[submenus[0]], pt(0, 80));
      do_game(&game);
    }

  return 0;
}
Exemple #15
0
void OS_X11::set_current_screen(int p_screen) {
	int count = get_screen_count();
	if(p_screen >= count) return;

	if( current_videomode.fullscreen ) {
		Point2i position = get_screen_position(p_screen);
		Size2i size = get_screen_size(p_screen);

	        XMoveResizeWindow(x11_display, x11_window, position.x, position.y, size.x, size.y);
	}
	else {
		if( p_screen != get_current_screen() ) {
			Point2i position = get_screen_position(p_screen);
			XMoveWindow(x11_display, x11_window, position.x, position.y);
		}
	}
}
Exemple #16
0
/* Preparing the walls
 * -------------------
 * We use 4 lines as walls at the extreme ends of the screen.
 * Each line becomes a Chipmunk2D static_body.
 */
static void init_walls(struct state* state)
{
    int w, h;
    get_screen_size(&w, &h);
    cpBody* static_body = cpSpaceGetStaticBody(state->space);
    cpVect walls[N_WALLS][2] = {{cpv(0, h), cpv(w, h)},
                                {cpv(0, 0), cpv(0, h)},
                                {cpv(w, 0), cpv(w, h)},
                                {cpv(0, 0), cpv(w, 0)}};

    for (int j = 0; j < N_WALLS; j++) {
        state->walls[j] =
            cpSegmentShapeNew(static_body, walls[j][0], walls[j][1], 0);
        cpShapeSetFriction(state->walls[j], 1);
        cpSpaceAddShape(state->space, state->walls[j]);
    }
}
int
WIN_VideoInit(_THIS)
{
	SDL_DisplayMode mode;

	mode.format = SDL_PIXELFORMAT_ABGR8888;
	get_screen_size(mode.w, mode.h);
	mode.refresh_rate = 0;
	mode.driverdata = NULL;
	if (SDL_AddBasicVideoDisplay(&mode) < 0) {
		return -1;
	}

	SDL_AddDisplayMode(&_this->displays[0], &mode);

    return 0;
}
Exemple #18
0
static void
__init_default_values()
{
    hotkey_t hk;
    position_t pos;
    double d;
    varchar str;
    int i;

    /* trigger key */
    hk.modifiers = ControlMask;
    hk.keysym = XK_space;
    settings_set(TRIGGER_KEY, &hk);

    /* eng key */
    hk.modifiers = 0;
    hk.keysym = XK_Shift_L;
    settings_set(ENG_KEY, &hk);

    get_screen_size(&(pos.x), &(pos.y));
    pos.x -= 100;
    pos.y -= 70;

    settings_set(ICBAR_POS, &pos);

    /* preedit opacity */
    d = 1.0;
    settings_set(PREEDIT_OPACITY, &d);

    memset(str, 0, sizeof(varchar));
    strcpy(str, "#FFFFB3");
    settings_set(PREEDIT_COLOR, str);

    memset(str, 0, sizeof(varchar));
    strcpy(str, "Sans 10");
    settings_set(PREEDIT_FONT, str);

    memset(str, 0, sizeof(varchar));
    strcpy(str, "#000000");
    settings_set(PREEDIT_FONT_COLOR, str);

    i = 10;
    settings_set(CANDIDATES_SIZE, &i);
}
Exemple #19
0
/* Mouse handling is a bit tricky. We want the user to move
 * tiles using the mouse but because tiles are dynamic bodies
 * managed by Chipmunk2D, we cannot directly control them.
 * This is resolved by creating a pivot joint between an
 * invisible mouse body that we can control and the tile body
 * that we cannot directly control.
 */
static void apply_mouse_motion(struct state* state)
{
    struct mouse m;
    update_mouse(&m);
    int w, h;
    get_screen_size(&w, &h);
    int x = m.x_position * w;
    int y = m.y_position * h;
    cpVect mouse_pos = cpv(x, y);
    cpVect new_point =
        cpvlerp(cpBodyGetPosition(state->mouse_body), mouse_pos, 0.25f);
    cpBodySetVelocity(
        state->mouse_body,
        cpvmult(cpvsub(new_point, cpBodyGetPosition(state->mouse_body)),
                60.0f));
    cpBodySetPosition(state->mouse_body, new_point);
    if (m.left_click && state->mouse_joint == NULL) {
        cpFloat radius = 5.0;
        cpPointQueryInfo info = { 0 };
        cpShape* shape = cpSpacePointQueryNearest(state->space, mouse_pos,
                                                  radius, GRAB_FILTER, &info);
        if (shape && cpBodyGetMass(cpShapeGetBody(shape)) < INFINITY) {
            cpVect nearest = (info.distance > 0.0f ? info.point : mouse_pos);
            cpBody* body = cpShapeGetBody(shape);
            state->mouse_joint =
                cpPivotJointNew2(state->mouse_body, body, cpvzero,
                                 cpBodyWorldToLocal(body, nearest));
            cpConstraintSetMaxForce(state->mouse_joint, 5000000.0f);
            cpConstraintSetErrorBias(state->mouse_joint,
                                     cpfpow(1.0f - 0.15f, 60.0f));
            cpSpaceAddConstraint(state->space, state->mouse_joint);
        }
    }
    if (m.left_click == false && state->mouse_joint != NULL) {
        cpSpaceRemoveConstraint(state->space, state->mouse_joint);                                                 
        cpConstraintFree(state->mouse_joint);                                                               
        state->mouse_joint = NULL;  
    }
}
Exemple #20
0
void display_setup(void)
{
    SLtt_get_terminfo();

    if (SLang_init_tty (ABORT, 1, 0) == -1) {
	fprintf(stderr, "tweak: SLang_init_tty: returned error code\n");
	exit (1);
    }
    SLang_set_abort_signal (NULL);
    SLtt_Use_Ansi_Colors = TRUE;

    get_screen_size ();
    if (SLsmg_init_smg () < 0) {
	fprintf(stderr, "tweak: SLsmg_init_smg: returned error code\n");
	SLang_reset_tty ();
	exit (1);
    }

#if defined(unix) && !defined(GO32)
    signal (SIGWINCH, (void *) sigwinch);
#endif
}
Exemple #21
0
/*
 * Allow the player to examine other sectors on the map
 */
void do_cmd_locate(void)
{
    int        dir, y1, x1, y2, x2;

    char    tmp_val[80];

    char    out_val[160];

    int wid, hgt;

    /* Get size */
    get_screen_size(&wid, &hgt);


    /* Start at current panel */
    y2 = y1 = panel_row_min;
    x2 = x1 = panel_col_min;

    /* Show panels until done */
    while (1)
    {
        /* Describe the location */
        if ((y2 == y1) && (x2 == x1))
        {
            tmp_val[0] = '\0';

        }
        else
        {
            sprintf(tmp_val, "%s%s of",
                ((y2 < y1) ? " North" : (y2 > y1) ? " South" : ""),
                ((x2 < x1) ? " West" : (x2 > x1) ? " East" : ""));

        }

        /* Prepare to ask which way to look */
        sprintf(out_val,
            "Map sector [%d(%02d),%d(%02d)], which is%s your sector.  Direction?",

            y2 / (hgt / 2), y2 % (hgt / 2),
            x2 / (wid / 2), x2 % (wid / 2), tmp_val);

        /* Assume no direction */
        dir = 0;

        /* Get a direction */
        while (!dir)
        {
            char command;

            /* Get a command (or Cancel) */
            if (!get_com(out_val, &command, TRUE)) break;
            if (command == '5') break;

            /* Extract the action (if any) */
            dir = get_keymap_dir(command);

            /* Error */
            if (!dir) bell();
        }

        /* No direction */
        if (!dir) break;

        /* Apply the motion */
        if (change_panel(ddy[dir], ddx[dir]))
        {
            y2 = panel_row_min;
            x2 = panel_col_min;
        }
    }


    /* Recenter the map around the player */
    verify_panel();

    /* Update stuff */
    p_ptr->update |= (PU_MONSTERS);

    /* Redraw map */
    p_ptr->redraw |= (PR_MAP);

    /* Window stuff */
    p_ptr->window |= (PW_OVERHEAD | PW_DUNGEON);

    /* Handle stuff */
    handle_stuff();
}
Exemple #22
0
void OS_X11::initialize(const VideoMode& p_desired,int p_video_driver,int p_audio_driver) {

	last_button_state=0;

	xmbstring=NULL;
	event_id=0;
	x11_window=0;
	last_click_ms=0;
	args=OS::get_singleton()->get_cmdline_args();
	current_videomode=p_desired;
	main_loop=NULL;
	last_timestamp=0;
	last_mouse_pos_valid=false;
	last_keyrelease_time=0;

	if (get_render_thread_mode()==RENDER_SEPARATE_THREAD) {
		XInitThreads();
	}

	/** XLIB INITIALIZATION **/
	x11_display = XOpenDisplay(NULL);

	char * modifiers = XSetLocaleModifiers ("@im=none");
	ERR_FAIL_COND( modifiers == NULL );

	xim = XOpenIM (x11_display, NULL, NULL, NULL);


	if (xim == NULL) {
		WARN_PRINT("XOpenIM failed");
		xim_style=0L;
	} else {
		::XIMStyles *xim_styles=NULL;
		xim_style=0L;
		char *imvalret=NULL;
		imvalret = XGetIMValues(xim, XNQueryInputStyle, &xim_styles, NULL);
		if (imvalret != NULL || xim_styles == NULL) {
			fprintf (stderr, "Input method doesn't support any styles\n");
		}

		if (xim_styles) {
			xim_style = 0L;
			for (int i=0;i<xim_styles->count_styles;i++) {

				if (xim_styles->supported_styles[i] ==
				    (XIMPreeditNothing | XIMStatusNothing)) {

					    xim_style = xim_styles->supported_styles[i];
					    break;
				    }
			}

			XFree (xim_styles);
		}
		XFree( imvalret );
	}

	/*
	char* windowid = getenv("GODOT_WINDOWID");
	if (windowid) {

		//freopen("/home/punto/stdout", "w", stdout);
		//reopen("/home/punto/stderr", "w", stderr);
		x11_window = atol(windowid);

		XWindowAttributes xwa;
		XGetWindowAttributes(x11_display,x11_window,&xwa);

		current_videomode.width = xwa.width;
		current_videomode.height = xwa.height;
	};
	*/

	// maybe contextgl wants to be in charge of creating the window
	//print_line("def videomode "+itos(current_videomode.width)+","+itos(current_videomode.height));
#if defined(OPENGL_ENABLED) || defined(LEGACYGL_ENABLED)

	context_gl = memnew( ContextGL_X11( x11_display, x11_window,current_videomode, false ) );
	context_gl->initialize();

	rasterizer = memnew( RasterizerGLES2 );

#endif
	visual_server = memnew( VisualServerRaster(rasterizer) );

	if (get_render_thread_mode()!=RENDER_THREAD_UNSAFE) {

		visual_server =memnew(VisualServerWrapMT(visual_server,get_render_thread_mode()==RENDER_SEPARATE_THREAD));
	}

#if 1
	// NEW_WM_API
	// borderless fullscreen window mode
	if (current_videomode.fullscreen) {
	// needed for lxde/openbox, possibly others
		Hints hints;
		Atom property;
		hints.flags = 2;
		hints.decorations = 0;
		property = XInternAtom(x11_display, "_MOTIF_WM_HINTS", True);
		XChangeProperty(x11_display, x11_window, property, property, 32, PropModeReplace, (unsigned char *)&hints, 5);
		XMapRaised(x11_display, x11_window);
		XWindowAttributes xwa;
		XGetWindowAttributes(x11_display, DefaultRootWindow(x11_display), &xwa);
		XMoveResizeWindow(x11_display, x11_window, 0, 0, xwa.width, xwa.height);

		// code for netwm-compliants
		XEvent xev;
		Atom wm_state = XInternAtom(x11_display, "_NET_WM_STATE", False);
		Atom fullscreen = XInternAtom(x11_display, "_NET_WM_STATE_FULLSCREEN", False);

		memset(&xev, 0, sizeof(xev));
		xev.type = ClientMessage;
		xev.xclient.window = x11_window;
		xev.xclient.message_type = wm_state;
		xev.xclient.format = 32;
		xev.xclient.data.l[0] = 1;
		xev.xclient.data.l[1] = fullscreen;
		xev.xclient.data.l[2] = 0;

		XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureNotifyMask, &xev);
	}

	// disable resizable window
	if (!current_videomode.resizable) {
		XSizeHints *xsh;
		xsh = XAllocSizeHints();
		xsh->flags = PMinSize | PMaxSize;
		XWindowAttributes xwa;
		if (current_videomode.fullscreen) {
			XGetWindowAttributes(x11_display,DefaultRootWindow(x11_display),&xwa);
		} else {
			XGetWindowAttributes(x11_display,x11_window,&xwa);
		}
		xsh->min_width = xwa.width;
		xsh->max_width = xwa.width;
		xsh->min_height = xwa.height;
		xsh->max_height = xwa.height;
		XSetWMNormalHints(x11_display, x11_window, xsh);
		XFree(xsh);
	}
#else
	capture_idle = 0;
	minimized = false;
	maximized = false;

	if (current_videomode.fullscreen) {
		//set_wm_border(false);
		set_wm_fullscreen(true);
	}
	if (!current_videomode.resizable) {
		int screen = get_current_screen();
		Size2i screen_size = get_screen_size(screen);
		set_window_size(screen_size);
		set_window_resizable(false);
	}
#endif

	AudioDriverManagerSW::get_driver(p_audio_driver)->set_singleton();

	audio_driver_index=p_audio_driver;
	if (AudioDriverManagerSW::get_driver(p_audio_driver)->init()!=OK) {

		bool success=false;
		audio_driver_index=-1;
		for(int i=0;i<AudioDriverManagerSW::get_driver_count();i++) {
			if (i==p_audio_driver)
				continue;
			AudioDriverManagerSW::get_driver(i)->set_singleton();
			if (AudioDriverManagerSW::get_driver(i)->init()==OK) {
				success=true;
				print_line("Audio Driver Failed: "+String(AudioDriverManagerSW::get_driver(p_audio_driver)->get_name()));
				print_line("Using alternate audio driver: "+String(AudioDriverManagerSW::get_driver(i)->get_name()));
				audio_driver_index=i;
				break;
			}
		}
		if (!success) {
			ERR_PRINT("Initializing audio failed.");
		}

	}

	sample_manager = memnew( SampleManagerMallocSW );
	audio_server = memnew( AudioServerSW(sample_manager) );
	audio_server->init();
	spatial_sound_server = memnew( SpatialSoundServerSW );
	spatial_sound_server->init();
	spatial_sound_2d_server = memnew( SpatialSound2DServerSW );
	spatial_sound_2d_server->init();


	ERR_FAIL_COND(!visual_server);
	ERR_FAIL_COND(x11_window==0);

	XSetWindowAttributes new_attr;

	new_attr.event_mask=KeyPressMask | KeyReleaseMask | ButtonPressMask |
			   ButtonReleaseMask | EnterWindowMask |
			   LeaveWindowMask | PointerMotionMask |
			   Button1MotionMask |
			   Button2MotionMask | Button3MotionMask |
			   Button4MotionMask | Button5MotionMask |
			   ButtonMotionMask | KeymapStateMask |
			   ExposureMask | VisibilityChangeMask |
			   StructureNotifyMask |
			   SubstructureNotifyMask | SubstructureRedirectMask |
			   FocusChangeMask | PropertyChangeMask |
			   ColormapChangeMask | OwnerGrabButtonMask;

	XChangeWindowAttributes(x11_display, x11_window,CWEventMask,&new_attr);

	XClassHint* classHint;

	/* set the titlebar name */
	XStoreName(x11_display, x11_window, "Godot");

	/* set the name and class hints for the window manager to use */
	classHint = XAllocClassHint();
	if (classHint) {
		classHint->res_name = (char *)"Godot";
		classHint->res_class = (char *)"Godot";
	}
	XSetClassHint(x11_display, x11_window, classHint);
	XFree(classHint);

	wm_delete = XInternAtom(x11_display, "WM_DELETE_WINDOW", true);
	XSetWMProtocols(x11_display, x11_window, &wm_delete, 1);


	if (xim && xim_style) {

		xic = XCreateIC (xim,XNInputStyle, xim_style,XNClientWindow,x11_window,XNFocusWindow, x11_window, (char*)NULL);
	} else {

		xic=NULL;
		WARN_PRINT("XCreateIC couldn't create xic");

	}

	XcursorSetTheme(x11_display,"default");
	cursor_size = XcursorGetDefaultSize(x11_display);
	cursor_theme = XcursorGetTheme(x11_display);

	if (!cursor_theme) {
		print_line("not found theme");
		cursor_theme="default";
	}

	for(int i=0;i<CURSOR_MAX;i++) {

		cursors[i]=None;
		img[i]=NULL;
	}

	current_cursor=CURSOR_ARROW;

	if (cursor_theme) {
		//print_line("cursor theme: "+String(cursor_theme));
		for(int i=0;i<CURSOR_MAX;i++) {

			static const char *cursor_file[]={
				"left_ptr",
				"xterm",
				"hand2",
				"cross",
				"watch",
				"left_ptr_watch",
				"fleur",
				"hand1",
				"X_cursor",
				"sb_v_double_arrow",
				"sb_h_double_arrow",
				"size_bdiag",
				"size_fdiag",
				"hand1",
				"sb_v_double_arrow",
				"sb_h_double_arrow",
				"question_arrow"
			};

			img[i] = XcursorLibraryLoadImage(cursor_file[i],cursor_theme,cursor_size);
			if (img[i]) {
				cursors[i]=XcursorImageLoadCursor(x11_display,img[i]);
				//print_line("found cursor: "+String(cursor_file[i])+" id "+itos(cursors[i]));
			} else {
				if (OS::is_stdout_verbose())
					print_line("failed cursor: "+String(cursor_file[i]));
			}
		}
	}


	{
		Pixmap cursormask;
		 XGCValues xgc;
		 GC gc;
		 XColor col;
		 Cursor cursor;

		cursormask = XCreatePixmap(x11_display, RootWindow(x11_display,DefaultScreen(x11_display)), 1, 1, 1);
		xgc.function = GXclear;
		gc = XCreateGC(x11_display, cursormask, GCFunction, &xgc);
		XFillRectangle(x11_display, cursormask, gc, 0, 0, 1, 1);
		col.pixel = 0;
		col.red = 0;
		col.flags = 4;
		cursor = XCreatePixmapCursor(x11_display,
			      cursormask, cursormask,
			      &col, &col, 0, 0);
		 XFreePixmap(x11_display, cursormask);
		 XFreeGC(x11_display, gc);



		 if (cursor == None)
		 {
			 ERR_PRINT("FAILED CREATING CURSOR");
		 }

		 null_cursor=cursor;
	}
	set_cursor_shape(CURSOR_BUSY);


	visual_server->init();
	//
	physics_server = memnew( PhysicsServerSW );
	physics_server->init();
	//physics_2d_server = memnew( Physics2DServerSW );
	physics_2d_server = Physics2DServerWrapMT::init_server<Physics2DServerSW>();
	physics_2d_server->init();

	input = memnew( InputDefault );
#ifdef JOYDEV_ENABLED
	joystick = memnew( joystick_linux(input));
#endif
	_ensure_data_dir();
}
Exemple #23
0
void display_recheck_size(void)
{
    get_screen_size ();
}
Exemple #24
0
/*
 * Program entry point
 */
uint main(uint argc, uchar* argv[])
{
  uchar* title_info = "L:     F1:Save ESC:Exit"; /* const */
  uchar  line_ibcd[4]; /* To store line number digits */
  uint   ibcdt;

  uint i = 0;
  uint n = 0;
  uint result = 0;

  /* buff is fixed size and allocated in far memory so it
   * can be big enough.
   * buff_size is the size in bytes actually used in buff
   * buff_cursor_offset is the linear offset of current
   * cursor position inside buff
   */
  lp_t buff = 0;
  ul_t buff_size = 0;
  ul_t buff_cursor_offset = 0;

  /* First line number to display in the editor area */
  uint current_line = 0;

  /* Var to get key presses */
  uint k = 0;

  struct FS_ENTRY entry;

  /* Chck usage */
  if(argc != 2) {
    putstr("Usage: %s <file>\n\r\n\r", argv[0]);
    putstr("<file> can be:\n\r");
    putstr("-an existing file path: opens existing file to edit\n\r");
    putstr("-a new file path: opens empty editor. File will be created on save\n\r");
    putstr("\n\r");
    return 1;
  }

  /* Allocate fixed size text buffer */
  buff = lmalloc(0xFFFFL);
  if(buff == 0) {
    putstr("Error: can't allocate memory\n\r");
    return 1;
  }

  /* Find file */
  n = get_entry(&entry, argv[1], UNKNOWN_VALUE, UNKNOWN_VALUE);

  /* Load file or show error */
  if(n<ERROR_ANY && (entry.flags & FST_FILE)) {
    ul_t offset = 0;
    uchar cbuff[512];
    setlc(buff, entry.size, 0);
    buff_size = entry.size;
    while(result = read_file(cbuff, argv[1], (uint)offset, sizeof(cbuff))) {
      if(result >= ERROR_ANY) {
        lmfree(buff);
        putstr("Can't read file %s (error=%x)\n\r", argv[1], result);
        return 1;
      }
      lmemcpy(buff + offset, lp(cbuff), (ul_t)result);
      offset += result;
    }
    if(offset != entry.size) {
      lmfree(buff);
      putstr("Can't read file (readed %d bytes, expected %d)\n\r",
        (uint)offset, entry.size);
      return 1;
    }
    /* Buffer must finish with a 0 and */
    /* must fit at least this 0, so buff_size can't be 0 */
    if(buff_size == 0 || getlc(buff + buff_size-1L) != 0) {
      buff_size++;
    }
  }

  /* Create 1 byte buffer if this is a new file */
  /* This byte is for the final 0 */
  if(buff_size == 0) {
    buff_size = 1;
    lmemset(buff, 0, buff_size);
  }

  /* Get screen size */
  get_screen_size(SSM_CHARS, &SCREEN_WIDTH, &SCREEN_HEIGHT);

  /* Allocate screen buffer */
  screen_buff = lmalloc((ul_t)(SCREEN_WIDTH*(SCREEN_HEIGHT-1)));
  if(screen_buff == 0) {
    putstr("Error: can't allocate memory\n\r");
    lmfree(buff);
    return 1;
  }

  /* Clear screen buffer */
  lmemset(screen_buff, 0, (ul_t)(SCREEN_WIDTH*(SCREEN_HEIGHT-1)));

  /* Write title */
  for(i=0; i<strlen(argv[1]); i++) {
    putchar_attr(i, 0, argv[1][i], TITLE_ATTRIBUTES);
  }
  for(; i<SCREEN_WIDTH-strlen(title_info); i++) {
    putchar_attr(i, 0, ' ', TITLE_ATTRIBUTES);
  }
  for(; i<SCREEN_WIDTH; i++) {
    putchar_attr(i, 0,
      title_info[i+strlen(title_info)-SCREEN_WIDTH], TITLE_ATTRIBUTES);
  }

  /* Show buffer and set cursor at start */
  set_show_cursor(HIDE_CURSOR);
  show_buffer_at_line(buff, current_line);
  set_cursor_position(0, 1);
  set_show_cursor(SHOW_CURSOR);

  /* Main loop */
  while(k != KEY_ESC) {
    uint col, line;

    /* Getmouse state */
    get_mouse_state(SSM_CHARS, &mouse_x, &mouse_y, &mouse_buttons);

    /* Process buttons */
    if(mouse_buttons & MOUSE_LEFT_BUTTON) {
      buff_cursor_offset = linecol_to_buffer_offset(buff, mouse_x, mouse_y-1);
    }

    /* Get key press */
    k = getkey(KM_NO_WAIT);

    /* Process key actions */

    /* Keys to ignore */
    if((k>KEY_F1 && k<=KEY_F10) ||
      k==KEY_F11 || k==KEY_F12 ||
      k==KEY_PRT_SC || k==KEY_INS ||
      k==0) {
      continue;

    /* Key F1: Save */
    } else if(k == KEY_F1) {
      ul_t offset = 0;
      uchar cbuff[512];
      result = 0;
      while(offset<buff_size && result<ERROR_ANY) {
        ul_t to_copy = min(sizeof(cbuff), buff_size-offset);
        lmemcpy(lp(cbuff), buff + offset, to_copy);
        result = write_file(cbuff, argv[1], (uint)offset, (uint)to_copy, FWF_CREATE | FWF_TRUNCATE);
        offset += to_copy;
      }

      /* Update state indicator */
      if(result < ERROR_ANY) {
        putchar_attr(strlen(argv[1]), 0, ' ', TITLE_ATTRIBUTES);
      } else {
        putchar_attr(strlen(argv[1]), 0, '*', (TITLE_ATTRIBUTES&0xF0)|AT_T_RED);
      }
      /* This opperation takes some time, so clear keyboard buffer */
      getkey(KM_CLEAR_BUFFER);

    /* Cursor keys: Move cursor */
    } else if(k == KEY_UP) {
      buffer_offset_to_linecol(buff, buff_cursor_offset, &col, &line);
      if(line > 0) {
        line -= 1;
        buff_cursor_offset = linecol_to_buffer_offset(buff, col, line);
      }

    } else if(k == KEY_DOWN) {
      buffer_offset_to_linecol(buff, buff_cursor_offset, &col, &line);
      line += 1;
      buff_cursor_offset = linecol_to_buffer_offset(buff, col, line);

    } else if(k == KEY_LEFT) {
      if(buff_cursor_offset > 0) {
        buff_cursor_offset--;
      }

    } else if(k == KEY_RIGHT) {
      if(buff_cursor_offset < buff_size - 1) {
        buff_cursor_offset++;
      }

    /* HOME, END, PG_UP and PG_DN keys */
    } else if(k == KEY_HOME) {
      buffer_offset_to_linecol(buff, buff_cursor_offset, &col, &line);
      col = 0;
      buff_cursor_offset = linecol_to_buffer_offset(buff, col, line);

    } else if(k == KEY_END) {
      buffer_offset_to_linecol(buff, buff_cursor_offset, &col, &line);
      col = 0xFFFF;
      buff_cursor_offset = linecol_to_buffer_offset(buff, col, line);

    } else if(k == KEY_PG_DN) {
      buffer_offset_to_linecol(buff, buff_cursor_offset, &col, &line);
      line += SCREEN_HEIGHT-1;
      buff_cursor_offset = linecol_to_buffer_offset(buff, col, line);

    } else if(k == KEY_PG_UP) {
      buffer_offset_to_linecol(buff, buff_cursor_offset, &col, &line);
      line -= min(line, SCREEN_HEIGHT-1);
      buff_cursor_offset = linecol_to_buffer_offset(buff, col, line);


    /* Backspace key: delete char before cursor and move cursor there */
    } else if(k == KEY_BACKSPACE) {
      if(buff_cursor_offset > 0) {
        lmemcpy(buff+buff_cursor_offset-1L, buff+buff_cursor_offset, buff_size-buff_cursor_offset);
        buff_size--;
        putchar_attr(strlen(argv[1]), 0, '*', TITLE_ATTRIBUTES);
        buff_cursor_offset--;
      }

    /* Del key: delete char at cursor */
    } else if(k == KEY_DEL) {
      if(buff_cursor_offset < buff_size-1) {
        lmemcpy(buff+buff_cursor_offset, buff+buff_cursor_offset+1, buff_size-buff_cursor_offset-1);
        buff_size--;
        putchar_attr(strlen(argv[1]), 0, '*', TITLE_ATTRIBUTES);
      }

    /* Any other key but esc: insert char at cursor */
    } else if(k != KEY_ESC && k != 0) {

      if(k == KEY_RETURN) {
        k = '\n';
      }
      if(k == KEY_TAB) {
        k = '\t';
      }
      lmemcpy(buff+buff_cursor_offset+1, buff+buff_cursor_offset, buff_size-buff_cursor_offset);
      setlc(buff, buff_cursor_offset++, k);
      buff_size++;
      putchar_attr(strlen(argv[1]), 0, '*', TITLE_ATTRIBUTES);
    }

    /* Update cursor position and display */
    buffer_offset_to_linecol(buff, buff_cursor_offset, &col, &line);
    if(line < current_line) {
      current_line = line;
    } else if(line > current_line + SCREEN_HEIGHT - 2) {
      current_line = line - SCREEN_HEIGHT + 2;
    }

    /* Update line number in title */
    /* Compute bcd value (reversed) */
    ibcdt = min(9999, buffer_offset_to_fileline(buff, buff_cursor_offset)+1);
    n = SCREEN_WIDTH-strlen(title_info)+2;
    for(i=0; i<4; i++) {
      line_ibcd[i] = ibcdt%10;
      ibcdt /= 10;
      if(ibcdt==0) {
        ibcdt = i;
        break;
      }
    }
    /* Display it */
    for(i=0; i<4; i++) {
      uchar c = i<=ibcdt?line_ibcd[ibcdt-i]+'0':' ';
      putchar_attr(n+i, 0, c, TITLE_ATTRIBUTES);
    }

    set_show_cursor(HIDE_CURSOR);
    show_buffer_at_line(buff, current_line);
    line -= current_line;
    line += 1;
    set_cursor_position(col, line);
    set_show_cursor(SHOW_CURSOR);
  }

  /* Free screen buffer */
  lmfree(screen_buff);

  /* Free buffer */
  lmfree(buff);

  /* Reset screen */
  clear_screen();
  set_cursor_position(0, 0);

  return 0;
}
Exemple #25
0
void kbd_init (int first)
    {
    struct winsize winsize_ri;
    int fd;

    if(!config.test) {
      fd = open("/dev/tty4", O_RDWR);
      write(fd, "Startup...\n", sizeof "Startup...\n" - 1);
      close(fd);
    }

    kbd_unimode();

    if(config.kbd_fd == -1) config.kbd_fd = open(config.console, O_RDWR);
    tcgetattr (config.kbd_fd, &kbd_norm_tio_rm);
    kbd_tio_rm = kbd_norm_tio_rm;
    if (config.linemode)
        {
	kbd_tio_rm.c_lflag &= ~ISIG;
	tcsetattr (config.kbd_fd, TCSAFLUSH, &kbd_tio_rm);
	if (first)
	    {
	    max_x_ig = X_DEFAULT;
	    max_y_ig = Y_DEFAULT;
	    }
	return;
	}
    kbd_tio_rm.c_cc [VMIN] = 1;
    kbd_tio_rm.c_cc [VTIME] = 0;
    kbd_tio_rm.c_lflag &= ~(ECHO | ICANON | ISIG);
    kbd_tio_rm.c_iflag &= ~(INLCR | IGNCR | ICRNL);
    if (first && !ioctl (config.kbd_fd, TIOCGWINSZ, &winsize_ri))
        {
        if (winsize_ri.ws_col >= MIN_X && winsize_ri.ws_row >= MIN_Y)
            {
            max_x_ig = winsize_ri.ws_col;
            max_y_ig = winsize_ri.ws_row;
            }

        }

    tcsetattr (config.kbd_fd, TCSAFLUSH, &kbd_tio_rm);

    if (config.utf8)
    {
      write(config.kbd_fd, "\033[?1l", sizeof "\033[?1l" - 1);
      fsync(config.kbd_fd);

      write(config.kbd_fd, "\033%G", sizeof "\033%G" - 1);
      fsync(config.kbd_fd);
    }

    if(first && config.serial) {
      get_screen_size(config.kbd_fd);

      if(max_x_ig > MAX_X) max_x_ig = MAX_X;
      if(max_y_ig > MAX_Y) max_y_ig = MAX_Y;

      if(max_x_ig < MIN_X || max_y_ig < MIN_Y) {
        max_x_ig = X_DEFAULT;
        max_y_ig = Y_DEFAULT;
      }

      if(!config.had_segv) fprintf(stderr, "Window size: %d x %d\n", max_x_ig, max_y_ig);

      memset(&winsize_ri, 0, sizeof winsize_ri);

      winsize_ri.ws_col = max_x_ig;
      winsize_ri.ws_row = max_y_ig;

      ioctl(config.kbd_fd, TIOCSWINSZ, &winsize_ri);
    }

    }
Exemple #26
0
static inline void reserve_video_memory(void)
{
#if USE_DUALMON
    if (!config.max_umb || config.dualmon) {
#else
    if (!config.max_umb) {
#endif
        if (config.dualmon)
	    v_printf("CONF: Unable to maximize UMB's due to dual monitor setup\n");
	if (config.mem_size > 640) {
	    /* memcheck_reserve('v', config.mem_size * 1024, 0xC0000 - addr_start); */
	} else {
	    /* memcheck_reserve('v', GRAPH_BASE, GRAPH_SIZE); */
	}
    } else {
	int graph_base, graph_size;

	/* Okay, the usual procedure would be to reserve 128K of memory for
	   video unconditionally.  Clearly this is insane.  If you're running
	   in an x-term or across the network, you're wasting memory. */

	v_printf("CONF: Trying to set minimum video memory to maximize UMB's\n");

	if (config.usesX) {
	    graph_base = 0xB0000;
	    graph_size = 64 * 1024;
	    v_printf("CONF: X-Windows.  Assuming %uKB video memory @ 0x%5.5X\n",
		     graph_size / 1024, graph_base);
	} else if (!config.console_video) {
	    graph_base = 0xB0000;
	    graph_size = 64 * 1024;
	    v_printf("CONF: remote session.  Assuming %uKB video memory @ 0x%5.5X\n",
		     graph_size / 1024, graph_base);
	} else {
	    switch (config.cardtype) {
	    case CARD_MDA:
		graph_base = 0xB0000;
		graph_size = 64 * 1024;
		v_printf("CONF: MDA video card w/%uKB video memory @ 0x%5.5X\n",
			 graph_size / 1024, graph_base);
		break;
	    case CARD_CGA:
		graph_base = 0xB8000;
		graph_size = 32 * 1024;
		v_printf("CONF: CGA video card w/%uKB video memory @ 0x%5.5X\n",
			 graph_size / 1024, graph_base);
		break;
	    case CARD_EGA:
		graph_base = 0xB0000;
		graph_size = 64 * 1024;
		v_printf("CONF: EGA video card w/%uKB video memory @ 0x%5.5X\n",
			 graph_size / 1024, graph_base);
		break;
	    case CARD_VGA:
		graph_base = 0xA0000;
		graph_size = 128 * 1024;
		v_printf("CONF: VGA video card w/%uKB video memory @ 0x%5.5X\n",
			 graph_size / 1024, graph_base);
		break;
	    default:
		graph_base = 0xA0000;
		graph_size = 128 * 1024;
		v_printf("CONF: default video, guessing %uKB video memory @ 0x%5.5X\n",
			 graph_size / 1024, graph_base);
		break;
	    }
	}
	debug("graph_base=0x%08x  size=0x%08x\n", graph_base, graph_size);
    }
}


#if 0
void gettermcap(int i)
{
    struct winsize ws;		/* buffer for TIOCSWINSZ */

    li = LI;
    co = CO;
    if (ioctl(STDOUT_FILENO, TIOCGWINSZ, &ws) >= 0) {
	li = ws.ws_row;
	co = ws.ws_col;
    }
    if (li == 0 || co == 0) {

	error("unknown window sizes li=%d  co=%d, setting to 80x25\n", li, co);
	li = LI;
	co = CO;
    } else
	v_printf("VID: Setting windows size to li=%d, co=%d\n", li, co);
    get_screen_size();
    set_video_bios_size();
}
#endif

void set_video_bios_size(void)
{
    WRITE_WORD(BIOS_SCREEN_COLUMNS, co);	/* chars per line */
    WRITE_BYTE(BIOS_ROWS_ON_SCREEN_MINUS_1, li - 1); /* lines on screen - 1 */
    WRITE_WORD(BIOS_VIDEO_MEMORY_USED, TEXT_SIZE);   /* size of video regen area in bytes */
}
Exemple #27
0
int main( int argc, char **argv )
{
  int eax;
  double fp7;
  int i;
  char *cp = &ebx;
  double numerator, denominator;
  double new_size;
  int coption, boption, wide_flag;
  init_gvars( );
  default_out = stdout;
  gfp = stdout;
  wide_flag = 0;
  coption = 0;
  if ( i >= 0 )
  {
    if ( i + -98 + -98 <= 22 )
    {
      ;
    }
    usage( );
    exit( 2 );
  }
  else
  {
    if ( n_tokens <= 99 )
    {
      __fprintf_chk( stderr, 1, "%s: Expression array size too small.\n", prog_name );
      exit( 2 );
    }
    if ( init_mem( ) == 0 )
    {
      __fprintf_chk( stderr, 1, "%s: Not enough memory.\n", prog_name );
      exit( 2 );
    }
    if ( readline_enabled )
    {
      if ( numerator && prog_name )
      {
        __snprintf_chk( history_filename_storage, 4096, 1, 4096, "%s/.%s_history", cp, prog_name );
        history_filename = history_filename_storage;
      }
      rl_initialize( );
      using_history( );
      stifle_history( 500 );
      rl_inhibit_completion = 1;
      if ( html_flag == 0 )
      {
        color_flag = tigetnum( "colors" ) > 7;
      }
      read_history( history_filename );
    }
    get_screen_size( );
    if ( html_flag )
      __printf_chk( 1, "&lt;pre&gt;\n" );
    if ( test_mode == 0 )
    {
      if ( quiet_mode == 0 )
      {
        if ( security_level > 1 )
          __printf_chk( 1, "Secure " );
        __printf_chk( 1, "Mathomatic version %s (www.mathomatic.org)\n", "15.1.1" );
        __printf_chk( 1, "Copyright (C) 1987-2010 George Gesslein II.\n" );
        __printf_chk( 1, "%d equation spaces available, %ld kilobytes per equation space.\n", 100, (/*HI*/int)( ( n_tokens << 5 ) * 0x10624dd3 ) >> 6 );
        if ( test_mode == 0 )
          goto B32;
      }
B32:;
      if ( load_rc( ) == 0 )
        __fprintf_chk( stderr, 1, "%s: Error loading set options from \"%s\".\n", prog_name, rc_file );
    }
    if ( wide_flag )
    {
      screen_columns = 0;
      screen_rows = 0;
    }
    if ( coption & 1 )
      color_flag = color_flag == 0;
    if ( 0 )
    {
      color_flag = 1;
      bold_colors = 1;
    }
    if ( test_mode )
      color_flag = 0;
    if ( quiet_mode == 0 && color_flag )
    {
      __printf_chk( 1, "%s%s color mode enabled", html_flag != 0 ? "ANSI" : "HTML", bold_colors == 0 ? " bold" : "" );
      if ( 0 )
        __printf_chk( 1, ".\n" );
      else
        __printf_chk( 1, "; disable with the -c option or \"set no color\".\n" );
    }
    i = _setjmp( &jmp_save[0].__jmpbuf[0] );
    if ( _setjmp( &jmp_save[0].__jmpbuf[0] ) )
    {
      clean_up( );
      if ( i == 14 )
        error( "Expression too large." );
      __printf_chk( 1, "Operation aborted.\n" );
    }
    else
    {
      if ( set_signals( ) == 0 )
        __fprintf_chk( stderr, 1, "signal(2) setting failed.\n" );
      if ( !f_to_fraction( 0.500000000000, &denominator, ebp_36 ) || denominator != 1.000000000000 || ebp_36 != 2.000000000000 || 0 || !f_to_fraction( 0.333333333333, &denominator, ebp_36 ) || denominator != 1.000000000000 || 0 || ebp_36 != 3.000000000000 || ebp_36 != 3.000000000000 )
      {
        __fprintf_chk( stderr, 1, "%s: Cannot convert any floating point values to fractions.\n", prog_name );
        __fprintf_chk( stderr, 1, "Roots will not work properly.\n" );
      }
      i = optind;
      if ( argc <= optind || argv[ i ] == 0 )
      {
        main_io_loop( );
        exit_program( 0 );
        return 0;
      }
    {
      /* phantom */ size_t __s1_len;
      /* phantom */ size_t __s2_len;
      unsigned char *__s1;
      /* phantom */ int __result;
      do
      {
        if ( '-' == argv[ i ][0] && argv[ i ][1] == 0 )
          main_io_loop( );
        else
        {
          if ( read_file( argv[ i ] ) == 0 )
          {
            __fprintf_chk( stderr, 1, "Read of file \"%s\" failed.\n", argv[ i ] );
            exit_program( 1 );
          }
        }
        i++;
      }
      while ( i + 1 < argc && argv[ i + 1 + 1 ] );
    }
    }
  }
}
static void my_signal_handler(int signo)
{
    char prompt[1024];

    switch (signo) {
    	case SIGTSTP:				/* program stopped (e.g., ^Z)		*/
	    if (macsbug_screen)
	    	position_cursor_for_shell_input();
    	    if (log_stream) 			/* close log in case we don't come back	*/
	    	fclose(log_stream);		/* ...are we paranoid or what?		*/
	    signal(SIGTSTP, SIG_DFL);		/* we need to do what gdb does or we	*/
    	    sigsetmask(0);			/* don't get control back here because	*/
    	    kill(getpid(), SIGTSTP);		/* of this kill() call			*/
    	    signal(SIGTSTP, my_signal_handler);
    	    break;

	    /* Note: SIGTSTP is currently not used since gdb reestablishes its own	*/
	    /*       every time a command is processed.  Sigh :-(			*/

    	case SIGCONT:				/* continue execution (e.g., after ^Z)	*/
    	    if (prev_SIGCONT_handler)
    	    	prev_SIGCONT_handler(signo);
	    signal(SIGCONT, my_signal_handler);
	    if (macsbug_screen) {
	    	restore_current_prompt();
	    	refresh(NULL, 0);
	    }
	    #if 0
	    if (log_stream) {			/* reopen log now that we're back :-)	*/
	    	log_stream  = fopen(log_filename, "a");
		if (!log_stream)
		    gdb_fprintf(gdb_current_stderr, "Cannot reopen log file: %s", strerror(errno));
	    }
	    #endif
	    fprintf(stderr, "%s", gdb_get_prompt(prompt));
	    if (macsbug_screen && target_is_running)
	    	raise(SIGINT);
    	    break;

    	case SIGWINCH:				/* terminal screen changed		*/
    	    if (prev_SIGWINCH_handler)
    	    	prev_SIGWINCH_handler(signo);
	    signal(SIGWINCH, my_signal_handler);
    	    __window_size(NULL, 0);
	    get_screen_size(&max_rows, &max_cols);
	    save_stack(max_rows);
	    if (macsbug_screen) {
		if (max_rows < MIN_SCREEN_ROWS || max_cols < MIN_SCREEN_COLS) {
		    macsbug_off(0);
		    gdb_error(COLOR_RED "Terminal window too small (must be at least %ld rows and %ld columns)." COLOR_OFF "\n",
				    MIN_SCREEN_ROWS, MIN_SCREEN_COLS);
		    return;
		}
		restore_current_prompt();
	    	refresh(NULL, 0);
	    	fprintf(stderr, "%s", gdb_get_prompt(prompt));
		if (macsbug_screen && target_is_running)
		    raise(SIGINT);
	    }
    	    break;

	/* It looks like this one is reset by just like SIGTSTP is...damit :-(		*/
	case SIGINT:				/* terminal interrupt (^C)		*/
	    //printf("My SIGINT\n");
	    control_level = reading_raw = 0;
    	    if (prev_SIGINT_handler)
    	    	prev_SIGINT_handler(signo);
	    signal(SIGINT, my_signal_handler);
	    break;

    	default:
	   gdb_internal_error("Unexpected signal detected in MacsBug signal handler");
    	   break;
    }
}
Exemple #29
0
int main(void){
    int input;
    int width, height;
    struct sigaction sa;
    sa.sa_handler =  &signalCatch;
    sa.sa_flags = 0;
    sigaction(SIGINT, &sa, NULL);
    sigaction(SIGQUIT, &sa, NULL);
    sigaction(SIGTERM, &sa, NULL);
    screen_init();

    get_screen_size(&width, &height);

    srand((unsigned int)time(NULL));
    init_map();

    player.x = 1;
    player.y = 1;
    player.ele = 0;
    player.type = CREA_EARTH_PONY;
    player.inv = 0;
    player.health = 1;

    SQUARE(get_tile(0,0,0)->tile.sq, 1,1)->c = &player;

    struct item* spikes = malloc(sizeof(struct item));
    spikes->type = ITEM_HOOF_SPIKES;

    struct itemlist* a_list = malloc(sizeof(struct itemlist));
    a_list->item = spikes;
    a_list->next = 0;

    SQUARE(get_tile(0,0,0)->tile.sq, 4,2)->i = a_list;

    struct creature *earth_pony = malloc(sizeof(struct creature));
    earth_pony->type = 0;
    earth_pony->health = 5; /* test value */
    earth_pony->dex = 5;

    SQUARE(get_tile(0,0,0)->tile.sq, 3,3)->c = earth_pony;

    draw_map(1,1,0);

    while(1){
        input = getchar();
        switch(input){
            case 'h':
                move_player(W);
                break;
            case 'j':
                move_player(S);
                break;
            case 'k':
                move_player(N);
                break;
            case 'l':
                move_player(E);
                break;
            case 'y':
                move_player(NW);
                break;
            case 'u':
                move_player(NE);
                break;
            case 'n':
                move_player(SE);
                break;
            case 'b':
                move_player(SW);
                break;
            case ',':
                pick_up();
                break;
            case 'q':
                screen_free();
                return 0;
        }
    }
}
Exemple #30
0
void print_status(struct MPContext *mpctx)
{
    struct MPOpts *opts = mpctx->opts;

    update_window_title(mpctx, false);

    if (!opts->use_terminal)
        return;

    if (opts->quiet || !(mpctx->initialized_flags & INITIALIZED_PLAYBACK)) {
        term_osd_set_status(mpctx, "");
        return;
    }

    if (opts->status_msg) {
        char *r = mp_property_expand_escaped_string(mpctx, opts->status_msg);
        term_osd_set_status(mpctx, r);
        talloc_free(r);
        return;
    }

    char *line = NULL;

    // Playback status
    if (mpctx->paused_for_cache && !opts->pause) {
        saddf(&line, "(Buffering) ");
    } else if (mpctx->paused) {
        saddf(&line, "(Paused) ");
    }

    if (mpctx->d_audio)
        saddf(&line, "A");
    if (mpctx->d_video)
        saddf(&line, "V");
    saddf(&line, ": ");

    // Playback position
    double cur = get_current_time(mpctx);
    sadd_hhmmssff(&line, cur, mpctx->opts->osd_fractions);

    double len = get_time_length(mpctx);
    if (len >= 0) {
        saddf(&line, " / ");
        sadd_hhmmssff(&line, len, mpctx->opts->osd_fractions);
    }

    sadd_percentage(&line, get_percent_pos(mpctx));

    // other
    if (opts->playback_speed != 1)
        saddf(&line, " x%4.2f", opts->playback_speed);

    // A-V sync
    if (mpctx->d_audio && mpctx->d_video && mpctx->sync_audio_to_video) {
        if (mpctx->last_av_difference != MP_NOPTS_VALUE)
            saddf(&line, " A-V:%7.3f", mpctx->last_av_difference);
        else
            saddf(&line, " A-V: ???");
        if (fabs(mpctx->total_avsync_change) > 0.05)
            saddf(&line, " ct:%7.3f", mpctx->total_avsync_change);
    }

#if HAVE_ENCODING
    double position = get_current_pos_ratio(mpctx, true);
    char lavcbuf[80];
    if (encode_lavc_getstatus(mpctx->encode_lavc_ctx, lavcbuf, sizeof(lavcbuf),
            position) >= 0)
    {
        // encoding stats
        saddf(&line, " %s", lavcbuf);
    } else
#endif
    {
        // VO stats
        if (mpctx->d_video && mpctx->drop_frame_cnt)
            saddf(&line, " Late: %d", mpctx->drop_frame_cnt);
    }

    int cache = mp_get_cache_percent(mpctx);
    if (cache >= 0)
        saddf(&line, " Cache: %d%%", cache);

    if (opts->term_osd_bar) {
        saddf(&line, "\n");
        get_screen_size();
        add_term_osd_bar(mpctx, &line, screen_width);
    }

    // end
    term_osd_set_status(mpctx, line);
    talloc_free(line);
}