Example #1
0
void sdlwindow_modify_effect(running_machine *machine, sdl_window_info *window, int dir)
{

	if (video_config.mode == VIDEO_MODE_SOFT) 
	{
		sdlwindow_modify_yuv(machine, window, dir);
		return;
	}
	else if (USE_OPENGL)
	{
		int new_prescale_effect = window->prescale_effect;
		const char *effect_names[] = { "none", "scale2x" };

		if (dir > 0 && window->prescale_effect < 1)
			new_prescale_effect = window->prescale_effect + 1;
		if (dir < 0 && window->prescale_effect > 0)
			new_prescale_effect = window->prescale_effect - 1;
		
		if (new_prescale_effect != window->prescale_effect)
		{
			worker_param wp;

			clear_worker_param(&wp);
			wp.window = window;
			execute_async_wait(destroy_all_textures_wt, &wp);

			window->prescale_effect = new_prescale_effect;
			ui_popup_time(1, "Effect: %s", effect_names[window->prescale_effect]);
		}
	}
}
Example #2
0
File: window.c Project: clobber/UME
void sdlwindow_modify_prescale(running_machine &machine, sdl_window_info *window, int dir)
{
	worker_param wp;
	int new_prescale = window->prescale;

	clear_worker_param(&wp);

	wp.window = window;
	wp.m_machine = &machine;

	if (dir > 0 && window->prescale < 3)
		new_prescale = window->prescale + 1;
	if (dir < 0 && window->prescale > 1)
		new_prescale = window->prescale - 1;

	if (new_prescale != window->prescale)
	{
		if (window->fullscreen && video_config.switchres)
		{
			execute_async_wait(&sdlwindow_video_window_destroy_wt, &wp);

			window->prescale = new_prescale;

			execute_async_wait(&complete_create_wt, &wp);

		}
		else
		{
			execute_async_wait(destroy_all_textures_wt, &wp);
			window->prescale = new_prescale;
		}
		ui_popup_time(1, "Prescale %d", window->prescale);
	}
}
Example #3
0
static void sdlwindow_modify_yuv(running_machine *machine, sdl_window_info *window, int dir)
{
	int new_scale_mode = window->scale_mode;
	worker_param wp;
	const char *stemp;
	
	if (dir > 0)
		new_scale_mode = window->scale_mode + 1;
	if (dir < 0)
		new_scale_mode = window->scale_mode - 1;
	
	stemp = drawsdl_scale_mode_str(new_scale_mode);
	
	if (stemp==NULL)
		return;
	
	clear_worker_param(&wp);
	wp.window = window;
	wp.machine = machine;
	sdlwindow_sync();
	execute_async_wait(&sdlwindow_video_window_destroy_wt, &wp);
		
	window->scale_mode = new_scale_mode;
	
	ui_popup_time(1, "Scale mode %s", stemp);
	mame_printf_verbose("Scale mode %s\n", stemp);

	sdlwindow_sync();
	execute_async_wait(&complete_create_wt, &wp);
	sdlwindow_sync();

}
Example #4
0
void CLIB_DECL popmessage(const char *format, ...)
{
	// if the format is NULL, it is a signal to clear the popmessage
	if (format == NULL)
		ui_popup_time(0, " ");

	// otherwise, generate the buffer and call the UI to display the message
	else
	{
		astring temp;
		va_list arg;

		// dump to the buffer
		va_start(arg, format);
		temp.vprintf(format, arg);
		va_end(arg);

		// pop it in the UI
		ui_popup_time(temp.len() / 40 + 2, "%s", temp.cstr());
	}
}
Example #5
0
void sdlwindow_toggle_draw(running_machine *machine, sdl_window_info *window)
{
#if USE_OPENGL
	//FIXME: Not yet working in 1.3
#if (!SDL_VERSION_ATLEAST(1,3,0))
	worker_param wp;

	// If we are not fullscreen (windowed) remember our windowed size
	if (!window->fullscreen)
	{
		window->windowed_width = window->width;
		window->windowed_height = window->height;
	}

	clear_worker_param(&wp);

	wp.window = window;
	wp.machine = machine;
	execute_async_wait(&sdlwindow_video_window_destroy_wt, &wp);

	window->scale_mode = VIDEO_SCALE_MODE_NONE;

	if (video_config.mode == VIDEO_MODE_OPENGL)
	{
		video_config.mode = VIDEO_MODE_SOFT;
		drawsdl_init(&draw);
		ui_popup_time(1, "Using software rendering");
	}
	else
	{
		video_config.mode = VIDEO_MODE_OPENGL;
		drawogl_init(&draw);
		ui_popup_time(1, "Using OpenGL rendering");
	}

	execute_async_wait(&complete_create_wt, &wp);
#endif
#endif
}
Example #6
0
static void check_osd_inputs(running_machine &machine)
{
	sdl_window_info *window = sdlinput_get_focus_window(machine);

	// check for toggling fullscreen mode
	if (ui_input_pressed(machine, IPT_OSD_1))
		sdlwindow_toggle_full_screen(machine, window);

	if (ui_input_pressed(machine, IPT_OSD_2))
	{
		//FIXME: on a per window basis
		video_config.fullstretch = !video_config.fullstretch;
		ui_popup_time(1, "Uneven stretch %s", video_config.fullstretch? "enabled":"disabled");
	}

	if (ui_input_pressed(machine, IPT_OSD_4))
	{
		//FIXME: on a per window basis
		video_config.keepaspect = !video_config.keepaspect;
		ui_popup_time(1, "Keepaspect %s", video_config.keepaspect? "enabled":"disabled");
	}

	if (USE_OPENGL || SDLMAME_SDL2)
	{
		//FIXME: on a per window basis
		if (ui_input_pressed(machine, IPT_OSD_5))
		{
			video_config.filter = !video_config.filter;
			ui_popup_time(1, "Filter %s", video_config.filter? "enabled":"disabled");
		}
	}

	if (ui_input_pressed(machine, IPT_OSD_6))
		sdlwindow_modify_prescale(machine, window, -1);

	if (ui_input_pressed(machine, IPT_OSD_7))
		sdlwindow_modify_prescale(machine, window, 1);
}
void device_image_interface::message(const char *format, ...)
{
    va_list args;
    char buffer[256];

    /* format the message */
    va_start(args, format);
    vsnprintf(buffer, ARRAY_LENGTH(buffer), format, args);
    va_end(args);

    /* display the popup for a standard amount of time */
    ui_popup_time(5, "%s: %s",
        basename(),
        buffer);
}
Example #8
0
void nvram_load(running_machine &machine)
{
	int overrideNVram = 0;
	if(netCommon) {
          if(nvram_size(machine)>=32*1024*1024) {
            overrideNVram=1;
            ui_popup_time(3, "The NVRAM for this game is too big, not loading NVRAM.");
          }
	}

	if (machine.config().m_nvram_handler != NULL)
	{
		astring filename;
		emu_file file(machine.options().nvram_directory(), OPEN_FLAG_READ);
		if (!overrideNVram && file.open(nvram_filename(filename, machine.root_device()), ".nv") == FILERR_NONE)
		{
			(*machine.config().m_nvram_handler)(machine, &file, FALSE);
			file.close();
		}
		else
		{
			(*machine.config().m_nvram_handler)(machine, NULL, FALSE);
		}
	}

	nvram_interface_iterator iter(machine.root_device());
	for (device_nvram_interface *nvram = iter.first(); nvram != NULL; nvram = iter.next())
	{
		astring filename;
		emu_file file(machine.options().nvram_directory(), OPEN_FLAG_READ);
		if (file.open(nvram_filename(filename, nvram->device())) == FILERR_NONE)
		{
			astring filename;
			emu_file file(machine.options().nvram_directory(), OPEN_FLAG_READ);
			if (!overrideNVram && file.open(nvram_filename(filename, nvram->device())) == FILERR_NONE)
		{
			nvram->nvram_load(file);
			file.close();
		}
		else
			{
				nvram->nvram_reset();
			}
		}
		else
			nvram->nvram_reset();
	}
}
void ui_menu_control_device_image::test_create(bool &can_create, bool &need_confirm)
{
	astring path;
	osd_directory_entry *entry;
	osd_dir_entry_type file_type;

	/* assemble the full path */
	zippath_combine(path, current_directory, current_file);

	/* does a file or a directory exist at the path */
	entry = osd_stat(path);
	file_type = (entry != NULL) ? entry->type : ENTTYPE_NONE;

	switch(file_type)
	{
		case ENTTYPE_NONE:
			/* no file/dir here - always create */
			can_create = true;
			need_confirm = false;
			break;

		case ENTTYPE_FILE:
			/* a file exists here - ask for permission from the user */
			can_create = true;
			need_confirm = true;
			break;

		case ENTTYPE_DIR:
			/* a directory exists here - we can't save over it */
			ui_popup_time(5, "Cannot save over directory");
			can_create = false;
			need_confirm = false;
			break;

		default:
			fatalerror("Unexpected");
			can_create = false;
			need_confirm = false;
			break;
	}
}
Example #10
0
void ui_menu_file_create::handle()
{
    /* process the menu */
    const ui_menu_event *event = process(0);

    /* process the event */
    if (event != NULL)
    {
        /* handle selections */
        switch(event->iptkey)
        {
        case IPT_UI_SELECT:
            if ((event->itemref == ITEMREF_CREATE) || (event->itemref == ITEMREF_NEW_IMAGE_NAME))
            {
                astring tmp_file(filename_buffer);
                if (tmp_file.find(".") != -1 && tmp_file.find(".") < tmp_file.len() - 1)
                {
                    current_file.cpy(filename_buffer);
                    ui_menu::stack_pop(machine());
                }
                else
                    ui_popup_time(1, "Please enter a file extension too");
            }
            break;

        case IPT_SPECIAL:
            if (get_selection() == ITEMREF_NEW_IMAGE_NAME)
            {
                input_character(
                    filename_buffer,
                    ARRAY_LENGTH(filename_buffer),
                    event->unichar,
                    is_valid_filename_char);
                reset(UI_MENU_RESET_REMEMBER_POSITION);
            }
            break;
        }
    }
}
Example #11
0
void nvram_save(running_machine &machine)
{
  static bool first=true;
	if(netCommon) {
          if(nvram_size(machine)>=32*1024*1024) {
            if(first) {
              ui_popup_time(3, "The NVRAM for this game is too big, not saving NVRAM.");
              first = false;
            }
            return;
          }
	}

	if (machine.config().m_nvram_handler != NULL)
	{
		astring filename;
		emu_file file(machine.options().nvram_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS);
		if (file.open(nvram_filename(filename, machine.root_device()), ".nv") == FILERR_NONE)
		{
			(*machine.config().m_nvram_handler)(machine, &file, TRUE);
			file.close();
		}
	}

	nvram_interface_iterator iter(machine.root_device());
	for (device_nvram_interface *nvram = iter.first(); nvram != NULL; nvram = iter.next())
	{
		astring filename;
		emu_file file(machine.options().nvram_directory(), OPEN_FLAG_WRITE | OPEN_FLAG_CREATE | OPEN_FLAG_CREATE_PATHS);
		if (file.open(nvram_filename(filename, nvram->device())) == FILERR_NONE)
		{
			nvram->nvram_save(file);
			file.close();
		}
	}
}
Example #12
0
void ui_menu_file_selector::handle()
{
    file_error err;
    const file_selector_entry *entry;
    const file_selector_entry *selected_entry = NULL;
    int bestmatch = 0;

    /* process the menu */
    const ui_menu_event *event = process(0);
    if (event != NULL && event->itemref != NULL)
    {
        /* handle selections */
        if (event->iptkey == IPT_UI_SELECT)
        {
            entry = (const file_selector_entry *) event->itemref;
            switch(entry->type)
            {
            case SELECTOR_ENTRY_TYPE_EMPTY:
                /* empty slot - unload */
                *result = R_EMPTY;
                ui_menu::stack_pop(machine());
                break;

            case SELECTOR_ENTRY_TYPE_CREATE:
                /* create */
                *result = R_CREATE;
                ui_menu::stack_pop(machine());
                break;
            case SELECTOR_ENTRY_TYPE_SOFTWARE_LIST:
                *result = R_SOFTLIST;
                ui_menu::stack_pop(machine());
                break;
            case SELECTOR_ENTRY_TYPE_DRIVE:
            case SELECTOR_ENTRY_TYPE_DIRECTORY:
                /* drive/directory - first check the path */
                err = zippath_opendir(entry->fullpath, NULL);
                if (err != FILERR_NONE)
                {
                    /* this path is problematic; present the user with an error and bail */
                    ui_popup_time(1, "Error accessing %s", entry->fullpath);
                    break;
                }
                current_directory.cpy(entry->fullpath);
                reset((ui_menu_reset_options)0);
                break;

            case SELECTOR_ENTRY_TYPE_FILE:
                /* file */
                current_file.cpy(entry->fullpath);
                *result = R_FILE;
                ui_menu::stack_pop(machine());
                break;
            }

            // reset the char buffer when pressing IPT_UI_SELECT
            if (filename_buffer[0] != '\0')
                memset(filename_buffer, '\0', ARRAY_LENGTH(filename_buffer));
        }
        else if (event->iptkey == IPT_SPECIAL)
        {
            int buflen = strlen(filename_buffer);
            bool update_selected = FALSE;

            /* if it's a backspace and we can handle it, do so */
            if ((event->unichar == 8 || event->unichar == 0x7f) && buflen > 0)
            {
                *(char *)utf8_previous_char(&filename_buffer[buflen]) = 0;
                update_selected = TRUE;

                if (ARRAY_LENGTH(filename_buffer) > 0)
                    ui_popup_time(ERROR_MESSAGE_TIME, "%s", filename_buffer);
            }
            /* if it's any other key and we're not maxed out, update */
            else if (event->unichar >= ' ' && event->unichar < 0x7f)
            {
                buflen += utf8_from_uchar(&filename_buffer[buflen], ARRAY_LENGTH(filename_buffer) - buflen, event->unichar);
                filename_buffer[buflen] = 0;
                update_selected = TRUE;

                if (ARRAY_LENGTH(filename_buffer) > 0)
                    ui_popup_time(ERROR_MESSAGE_TIME, "%s", filename_buffer);
            }

            if (update_selected)
            {
                const file_selector_entry *cur_selected = (const file_selector_entry *)get_selection();

                // check for entries which matches our filename_buffer:
                // from current entry to the end
                for (entry = cur_selected; entry != NULL; entry = entry->next)
                {
                    if (entry->basename != NULL && filename_buffer != NULL)
                    {
                        int match = 0;
                        for (int i = 0; i < ARRAY_LENGTH(filename_buffer); i++)
                        {
                            if (mame_strnicmp(entry->basename, filename_buffer, i) == 0)
                                match = i;
                        }

                        if (match > bestmatch)
                        {
                            bestmatch = match;
                            selected_entry = entry;
                        }
                    }
                }
                // and from the first entry to current one
                for (entry = entrylist; entry != cur_selected; entry = entry->next)
                {
                    if (entry->basename != NULL && filename_buffer != NULL)
                    {
                        int match = 0;
                        for (int i = 0; i < ARRAY_LENGTH(filename_buffer); i++)
                        {
                            if (mame_strnicmp(entry->basename, filename_buffer, i) == 0)
                                match = i;
                        }

                        if (match > bestmatch)
                        {
                            bestmatch = match;
                            selected_entry = entry;
                        }
                    }
                }

                if (selected_entry != NULL && selected_entry != cur_selected)
                    set_selection((void *) selected_entry);
            }
        }
        else if (event->iptkey == IPT_UI_CANCEL)
        {
            // reset the char buffer also in this case
            if (filename_buffer[0] != '\0')
                memset(filename_buffer, '\0', ARRAY_LENGTH(filename_buffer));
        }
    }
}