Beispiel #1
0
        /*-------------------------------------------------
        *   push_mouse_leave_event - pushes a
        *   mouse leave event to the specified render_target
        *  -------------------------------------------------*/
        public void push_mouse_leave_event(render_target target)
        {
            ui_event evt = new ui_event(ui_event.type.NONE);

            evt.event_type = ui_event.type.MOUSE_LEAVE;
            evt.target     = target;
            push_event(evt);
        }
Beispiel #2
0
        /*-------------------------------------------------
        *   push_char_event - pushes a char event
        *   to the specified render_target
        *  -------------------------------------------------*/
        public void push_char_event(render_target target, char32_t ch)
        {
            ui_event evt = new ui_event(ui_event.type.NONE);

            evt.event_type = ui_event.type.IME_CHAR;
            evt.target     = target;
            evt.ch         = ch;
            push_event(evt);
        }
Beispiel #3
0
        //void push_mouse_rdown_event(render_target* target, INT32 x, INT32 y);

        //void push_mouse_rup_event(render_target* target, INT32 x, INT32 y);


        /*-------------------------------------------------
        *   push_mouse_double_click_event - pushes
        *   a mouse double-click event to the specified
        *   render_target
        *  -------------------------------------------------*/
        public void push_mouse_double_click_event(render_target target, s32 x, s32 y)
        {
            ui_event evt = new ui_event(ui_event.type.NONE);

            evt.event_type = ui_event.type.MOUSE_DOUBLE_CLICK;
            evt.target     = target;
            evt.mouse_x    = x;
            evt.mouse_y    = y;
            push_event(evt);
        }
Beispiel #4
0
        /*-------------------------------------------------
        *   push_mouse_down_event - pushes a mouse
        *   down event to the specified render_target
        *  -------------------------------------------------*/
        public void push_mouse_up_event(render_target target, s32 x, s32 y)
        {
            ui_event evt = new ui_event(ui_event.type.NONE);

            evt.event_type = ui_event.type.MOUSE_UP;
            evt.target     = target;
            evt.mouse_x    = x;
            evt.mouse_y    = y;
            push_event(evt);
        }
Beispiel #5
0
        /*-------------------------------------------------
        *   push_mouse_down_event - pushes a mouse
        *   down event to the specified render_target
        *  -------------------------------------------------*/
        public void push_mouse_down_event(render_target target, int x, int y)
        {
            ui_event evt = new ui_event(ui_event.type.NONE);

            evt.event_type = ui_event.type.MOUSE_DOWN;
            evt.target     = target;
            evt.mouse_x    = x;
            evt.mouse_y    = y;
            push_event(evt);
        }
Beispiel #6
0
        /*-------------------------------------------------
        *   push_mouse_wheel_event - pushes a mouse
        *   wheel event to the specified render_target
        *  -------------------------------------------------*/
        public void push_mouse_wheel_event(render_target target, s32 x, s32 y, short delta, int ucNumLines)
        {
            ui_event event_ = new ui_event(ui_event.type.NONE);

            event_.event_type = ui_event.type.MOUSE_WHEEL;
            event_.target     = target;
            event_.mouse_x    = x;
            event_.mouse_y    = y;
            event_.zdelta     = delta;
            event_.num_lines  = ucNumLines;
            push_event(event_);
        }
Beispiel #7
0
        // construction/destruction
        //-------------------------------------------------
        //  ui_input_manager - constructor
        //-------------------------------------------------
        public ui_input_manager(running_machine machine)
        {
            m_machine = machine;
            m_current_mouse_target = null;
            m_current_mouse_down   = false;
            m_current_mouse_field  = null;
            m_events_start         = 0;
            m_events_end           = 0;


            /* create the private data */
            m_current_mouse_x = -1;
            m_current_mouse_y = -1;

            /* add a frame callback to poll inputs */
            machine.add_notifier(machine_notification.MACHINE_NOTIFY_FRAME, frame_update);
        }
Beispiel #8
0
        // pushes a single event onto the queue

        /*-------------------------------------------------
        *   push_event - pushes a single event
        *   onto the queue
        *  -------------------------------------------------*/
        bool push_event(ui_event evt)
        {
            // some pre-processing (this is an icky place to do this stuff!)
            switch (evt.event_type)
            {
            case ui_event.type.MOUSE_MOVE:
                m_current_mouse_target = evt.target;
                m_current_mouse_x      = evt.mouse_x;
                m_current_mouse_y      = evt.mouse_y;
                break;

            case ui_event.type.MOUSE_LEAVE:
                if (m_current_mouse_target == evt.target)
                {
                    m_current_mouse_target = null;
                    m_current_mouse_x      = -1;
                    m_current_mouse_y      = -1;
                }
                break;

            case ui_event.type.MOUSE_DOWN:
                m_current_mouse_down = true;
                break;

            case ui_event.type.MOUSE_UP:
                m_current_mouse_down = false;
                break;

            default:
                /* do nothing */
                break;
            }

            // is the queue filled up?
            if ((m_events_end + 1) % (int)std.size(m_events) == m_events_start)
            {
                return(false);
            }

            m_events[m_events_end++] = evt;
            m_events_end            %= (int)std.size(m_events);
            return(true);
        }
Beispiel #9
0
        // construction/destruction
        //-------------------------------------------------
        //  ui_input_manager - constructor
        //-------------------------------------------------
        public ui_input_manager(running_machine machine)
        {
            m_machine              = machine;
            m_presses_enabled      = true;
            m_current_mouse_target = null;
            m_current_mouse_x      = -1;
            m_current_mouse_y      = -1;
            m_current_mouse_down   = false;
            m_current_mouse_field  = null;
            m_events_start         = 0;
            m_events_end           = 0;


            std.fill(m_next_repeat, (osd_ticks_t)0);
            std.fill(m_seqpressed, (u8)0);


            // add a frame callback to poll inputs
            machine.add_notifier(machine_notification.MACHINE_NOTIFY_FRAME, frame_update);
        }
Beispiel #10
0
        // construction/destruction

        //-------------------------------------------------
        //  video_manager - constructor
        //-------------------------------------------------
        public video_manager(running_machine machine)
        {
            m_machine = machine;
            m_screenless_frame_timer = null;
            m_output_changed         = false;
            m_throttle_realtime      = attotime.zero;
            m_throttle_emutime       = attotime.zero;
            m_throttle_history       = 0;
            m_speed_last_realtime    = 0;
            m_speed_last_emutime     = attotime.zero;
            m_speed_percent          = 1.0;
            m_overall_real_seconds   = 0;
            m_overall_real_ticks     = 0;
            m_overall_emutime        = attotime.zero;
            m_overall_valid_counter  = 0;
            m_frame_update_counter   = 0;
            m_throttled           = true;
            m_throttle_rate       = 1.0f;
            m_fastforward         = false;
            m_seconds_to_run      = (u32)machine.options().seconds_to_run();
            m_auto_frameskip      = machine.options().auto_frameskip();
            m_speed               = (u32)original_speed_setting();
            m_low_latency         = machine.options().low_latency();
            m_empty_skip_count    = 0;
            m_frameskip_max       = m_auto_frameskip ? (u8)machine.options().frameskip() : (u8)0;
            m_frameskip_level     = m_auto_frameskip ? (u8)0 : (u8)machine.options().frameskip();
            m_frameskip_counter   = 0;
            m_frameskip_adjust    = 0;
            m_skipping_this_frame = false;
            m_average_oversleep   = 0;
            m_snap_target         = null;
            m_snap_native         = true;
            m_snap_width          = 0;
            m_snap_height         = 0;


            // request a callback upon exiting
            machine.add_notifier(machine_notification.MACHINE_NOTIFY_EXIT, exit);
            machine.save().register_postload(postload);

            // extract initial execution state from global configuration settings
            update_refresh_speed();

            unsigned screen_count = (unsigned)(new screen_device_enumerator(machine.root_device()).count());
            bool     no_screens   = screen_count == 0;

            // create a render target for snapshots
            string viewname = machine.options().snap_view();

            m_snap_native = !no_screens && std.strcmp(viewname, "native") == 0;

            // the native target is hard-coded to our internal layout and has all options disabled
            if (m_snap_native)
            {
                throw new emu_unimplemented();
            }
            else
            {
                // other targets select the specified view and turn off effects
                m_snap_target = machine.render().target_alloc(null, RENDER_CREATE_HIDDEN);
                m_snap_target.set_view(m_snap_target.configured_view(viewname, 0, 1));
                m_snap_target.set_screen_overlay_enabled(false);
            }

            // extract snap resolution if present
            //if (sscanf(machine.options().snap_size(), "%dx%d", &m_snap_width, &m_snap_height) != 2)
            var parts = machine.options().snap_size().Split('x');

            if (parts.Length == 2)
            {
                m_snap_width  = Convert.ToInt32(parts[0]);
                m_snap_height = Convert.ToInt32(parts[1]);
            }
            else
            {
                m_snap_width = m_snap_height = 0;
            }

            // if no screens, create a periodic timer to drive updates
            if (no_screens)
            {
                m_screenless_frame_timer = machine.scheduler().timer_alloc(screenless_update_callback, this);
                m_screenless_frame_timer.adjust(screen_device.DEFAULT_FRAME_PERIOD, 0, screen_device.DEFAULT_FRAME_PERIOD);
                machine.output().set_global_notifier(video_notifier_callback, this);
            }
        }
Beispiel #11
0
        protected machine_static_info(ui_options options, machine_config config, ioport_list ports)
        {
            m_options             = options;
            m_flags               = config.gamedrv().flags;
            m_unemulated_features = config.gamedrv().type.unemulated_features();
            m_imperfect_features  = config.gamedrv().type.imperfect_features();
            m_has_bioses          = false;
            m_has_dips            = false;
            m_has_configs         = false;
            m_has_keyboard        = false;
            m_has_test_switch     = false;
            m_has_analog          = false;


            ioport_list local_ports = new ioport_list();
            string      sink;

            foreach (device_t device in new device_enumerator(config.root_device()))
            {
                // the "no sound hardware" warning doesn't make sense when you plug in a sound card
                if (device.GetClassInterface <device_sound_interface>() != null)  // dynamic_cast<device_sound_interface *>(&device))
                {
                    m_flags &= ~machine_flags.type.NO_SOUND_HW;
                }

                // build overall emulation status
                m_unemulated_features |= device.type().unemulated_features();
                m_imperfect_features  |= device.type().imperfect_features();

                // look for BIOS options
                device_t parent            = device.owner();
                device_slot_interface slot = device.GetClassInterface <device_slot_interface>();  //device_slot_interface const *const slot(dynamic_cast<device_slot_interface const *>(parent));
                if (parent == null || (slot != null && (slot.get_card_device() == device)))
                {
                    for (Pointer <tiny_rom_entry> rom = device.rom_region(); !m_has_bioses && rom != null && !ROMENTRY_ISEND(rom.op); ++rom)  //for (tiny_rom_entry const *rom = device.rom_region(); !m_has_bioses && rom && !ROMENTRY_ISEND(rom); ++rom)
                    {
                        if (ROMENTRY_ISSYSTEM_BIOS(rom.op))
                        {
                            m_has_bioses = true;
                        }
                    }
                }
            }

            // suppress "requires external artwork" warning when external artwork was loaded
            if (config.root_device().has_running_machine())
            {
                for (render_target target = config.root_device().machine().render().first_target(); target != null; target = target.next())
                {
                    if (!target.hidden() && target.external_artwork())
                    {
                        m_flags &= ~machine_flags.type.REQUIRES_ARTWORK;
                        break;
                    }
                }
            }

            // unemulated trumps imperfect when aggregating (always be pessimistic)
            m_imperfect_features &= ~m_unemulated_features;

            // scan the input port array to see what options we need to enable
            foreach (var port in (ports != null ? ports : local_ports))
            {
                foreach (ioport_field field in port.Value.fields())
                {
                    switch (field.type())
                    {
                    case ioport_type.IPT_DIPSWITCH: m_has_dips = true;          break;

                    case ioport_type.IPT_CONFIG:    m_has_configs = true;       break;

                    case ioport_type.IPT_KEYBOARD:  m_has_keyboard = true;      break;

                    case ioport_type.IPT_SERVICE:   m_has_test_switch = true;   break;

                    default: break;
                    }

                    if (field.is_analog())
                    {
                        m_has_analog = true;
                    }
                }
            }
        }
Beispiel #12
0
        public override void init(running_machine machine)
        {
            // call our parent
            base.init(machine);

            set_verbose(true);

            string stemp;
            osd_options_WinForms options = (osd_options_WinForms)machine.options();

            // determine if we are benchmarking, and adjust options appropriately
            int bench = options.bench();
            if (bench > 0)
            {
                options.set_value(emu_options.OPTION_THROTTLE, 0, OPTION_PRIORITY_MAXIMUM);
                options.set_value(osd_options.OSDOPTION_SOUND, "none", OPTION_PRIORITY_MAXIMUM);
                options.set_value(osd_options.OSDOPTION_VIDEO, "none", OPTION_PRIORITY_MAXIMUM);
                options.set_value(emu_options.OPTION_SECONDS_TO_RUN, bench, OPTION_PRIORITY_MAXIMUM);
            }

            // determine if we are profiling, and adjust options appropriately
            int profile = options.profile();
            if (profile > 0)
            {
                options.set_value(emu_options.OPTION_THROTTLE, 0, OPTION_PRIORITY_MAXIMUM);
                options.set_value(osd_options.OSDOPTION_NUMPROCESSORS, 1, OPTION_PRIORITY_MAXIMUM);
            }

#if false
            // thread priority
            if ((machine.debug_flags_get() & running_machine.DEBUG_FLAG_OSD_ENABLED) == 0)
                SetThreadPriority(GetCurrentThread(), options.priority());
#endif

            // get number of processors
            stemp = options.numprocessors();

#if false
            osd_num_processors = 0;

            if (stemp != "auto")
            {
                osd_num_processors = Convert.ToInt32(stemp);
                if (osd_num_processors < 1)
                {
                    osdcore_global.m_osdcore.osd_printf_warning("Warning: numprocessors < 1 doesn't make much sense. Assuming auto ...\n");
                    osd_num_processors = 0;
                }
            }
#endif

            // initialize the subsystems
            init_subsystems();

#if false
            // notify listeners of screen configuration
            string tempstring;
            for (win_window_info info = win_window_list; info != null; info = info.m_next)
            {
                string tmp = utf8_from_tstring(info.m_monitor.info.szDevice);
                string tempstring = string.Format("Orientation({0})", tmp);
                output_set_value(tempstring, info.m_targetorient);
                //osd_free(tmp);
            }
#endif


            // hook up the debugger log
            if (options.oslog())
                machine.add_logerror_callback(osdcore_interface.osd_printf_debug);


#if false
            // crank up the multimedia timer resolution to its max
            // this gives the system much finer timeslices
            timeresult = timeGetDevCaps(&timecaps, sizeof(timecaps));
            if (timeresult == TIMERR_NOERROR)
                timeBeginPeriod(timecaps.wPeriodMin);
#endif

#if false
            // if a watchdog thread is requested, create one
            int watchdog = options.watchdog();
            if (watchdog != 0)
            {
                watchdog_reset_event = CreateEvent(NULL, FALSE, FALSE, NULL);
                emucore_global.assert_always(watchdog_reset_event != null, "Failed to create watchdog reset event");
                watchdog_exit_event = CreateEvent(NULL, TRUE, FALSE, NULL);
                emucore_global.assert_always(watchdog_exit_event != null, "Failed to create watchdog exit event");
                watchdog_thread = CreateThread(NULL, 0, watchdog_thread_entry, (LPVOID)(FPTR)watchdog, 0, NULL);
                emucore_global.assert_always(watchdog_thread != null, "Failed to create watchdog thread");
            }
#endif

#if false
            // create and start the profiler
            if (profile > 0)
            {
                profiler = new sampling_profiler(1000, profile - 1));
                profiler.start();
            }
#endif

#if false
            // initialize sockets
            win_init_sockets();
#endif

#if false
            // note the existence of a machine
            g_current_machine = &machine; 
#endif


            /////////////////////////////////////////////
            // custom code below

            validity_checker valid = new validity_checker(machine.options());
            valid.set_validate_all(true);
            string sysname = machine.options().system_name();
            bool result = valid.check_all_matching(string.IsNullOrEmpty(sysname) ? "*" : sysname);
            if (!result)
                throw new emu_fatalerror(main_global.EMU_ERR_FAILED_VALIDITY, "Validity check failed ({0} errors, {1} warnings in total)\n", valid.errors(), valid.warnings());
            valid.Dispose();

            /**
             *  Save away the machine, we'll need it in osd_customize_input_type_list
             **/
            //g_state.machine = machine;
    
            /**
             * Create the render_target that tells MAME the rendering parameters it
             * will use.
             **/
            m_target = machine.render().target_alloc();


            /**
             * Have this target hold every view since we only support one target
             **/
            m_target.set_view(m_target.configured_view("auto", 0, 1));

            /**
             * Set render target bounds to 10000 x 10000 and allow the callback to
             * scale that to whatever they want.
             **/
            //m_target.set_bounds(640, 480, 1.0f);
            m_target.set_bounds(400, 400, 1.0f);


            screenbufferptr = new RawBufferPointer(screenbuffer);


            {
                keyboard_state = new intref[(int)input_item_id.ITEM_ID_ABSOLUTE_MAXIMUM];
                for (int i = 0; i < (int)input_item_id.ITEM_ID_ABSOLUTE_MAXIMUM; i++)
                    keyboard_state[i] = new intref();

                input_device keyboard_device;
                keyboard_device = machine.input().device_class(input_device_class.DEVICE_CLASS_KEYBOARD).add_device("Keyboard", "Keyboard0");
                if (keyboard_device == null)
                    throw new emu_fatalerror("osd_interface.init() - FAILED - add_device() failed\n");

                foreach (var entry in mameForm.Form1.keymap)
                {
                    string defname = entry.Key.ToString();  //string.Format("Scan{0}", count++);
                    input_item_id itemid = entry.Value;
                    keyboard_device.add_item(defname, itemid, keyboard_get_state, keyboard_state[(int)itemid]);
                }
            }


            {
                mouse_axis_state = new intref[2];
                for (int i = 0; i < 2; i++)
                    mouse_axis_state[i] = new intref();

                input_device mouse_device;
                mouse_device = machine.input().device_class(input_device_class.DEVICE_CLASS_MOUSE).add_device("Mouse", "Mouse0");
                if (mouse_device == null)
                    throw new emu_fatalerror("osd_interface.init() - FAILED - add_device() failed\n");

                string defname;
                defname = string.Format("X {0}", mouse_device.name());
                mouse_device.add_item(defname, input_item_id.ITEM_ID_XAXIS, mouse_axis_get_state, mouse_axis_state[0]);
                defname = string.Format("Y {0}", mouse_device.name());
                mouse_device.add_item(defname, input_item_id.ITEM_ID_YAXIS, mouse_axis_get_state, mouse_axis_state[1]);


                mouse_button_state = new intref[5];
                for (int i = 0; i < 5; i++)
                    mouse_button_state[i] = new intref();

                defname = string.Format("B1");
                mouse_device.add_item(defname, input_item_id.ITEM_ID_BUTTON1, mouse_button_get_state, mouse_button_state[0]);
                defname = string.Format("B2");
                mouse_device.add_item(defname, input_item_id.ITEM_ID_BUTTON2, mouse_button_get_state, mouse_button_state[1]);
                defname = string.Format("B3");
                mouse_device.add_item(defname, input_item_id.ITEM_ID_BUTTON3, mouse_button_get_state, mouse_button_state[2]);
                defname = string.Format("B4");
                mouse_device.add_item(defname, input_item_id.ITEM_ID_BUTTON4, mouse_button_get_state, mouse_button_state[3]);
                defname = string.Format("B5");
                mouse_device.add_item(defname, input_item_id.ITEM_ID_BUTTON5, mouse_button_get_state, mouse_button_state[4]);
            }


            //System.Windows.Forms.Application.Run(new mameForm.Form1());
            //System.Windows.Forms.Form mainForm = new mameForm.Form1();
            //mainForm.FormClosed += (_sender, _args) => { System.Windows.Forms.Application.ExitThread(); };
            //mainForm.Show();

            //Console.WriteLine("After Show()");
        }