OSDN > Finden Software > Software Development > csp-qt > SCM > git > common_source_project-fm7 > Commit

csp-qt
Fork

R/O
HTTP
SSH
HTTPS

common_source_project-fm7: Commit

Common Source Code Project for Qt (a.k.a for FM-7).

Commit MetaInfo

Revision	e4bd170370208d08e492747df856e618a4f8a7ec (tree)
Zeit	2023-02-06 19:10:00
Autor	K.Ohta <whatisthis.sowhat@gmai...>
Commiter	K.Ohta

Log Message

[UI][Qt][EMU][WIP] Improve OSD calling around Virtual floppy disk menus.

Ändern Zusammenfassung

modified: source/src/emu.cpp (diff)
modified: source/src/osdcall_types.h (diff)
modified: source/src/qt/common/emu_thread_slots.cpp (diff)
modified: source/src/qt/common/qt_utils.cpp (diff)
modified: source/src/qt/common/util_fd2.cpp (diff)
modified: source/src/qt/gui/emu_thread_tmpl.cpp (diff)
modified: source/src/qt/gui/emu_thread_tmpl.h (diff)
modified: source/src/qt/gui/mainwidget_base.h (diff)
modified: source/src/qt/gui/menu_metaclass.cpp (diff)
modified: source/src/qt/gui/util_fd.cpp (diff)
modified: source/src/qt/osd_base.cpp (diff)

Diff

--- a/source/src/emu.cpp

+++ b/source/src/emu.cpp

		@@ -2368,16 +2368,16 @@ void EMU::update_media()
2368	2368	#ifdef USE_FLOPPY_DISK
2369	2369	for(int drv = 0; drv < USE_FLOPPY_DISK; drv++) {
2370	2370	if(floppy_disk_status[drv].wait_count != 0 && --floppy_disk_status[drv].wait_count == 0) {
2371		- vm->open_floppy_disk(drv, floppy_disk_status[drv].path, floppy_disk_status[drv].bank & 0x7f);
	2371	+ vm->open_floppy_disk(drv, floppy_disk_status[drv].path, floppy_disk_status[drv].bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK);
2372	2372	#if USE_FLOPPY_DISK > 1
2373	2373	out_message(_T("FD%d: %s"), drv + BASE_FLOPPY_DISK_NUM, floppy_disk_status[drv].path);
2374	2374	#else
2375	2375	out_message(_T("FD: %s"), floppy_disk_status[drv].path);
2376	2376	#endif
2377		- osd->string_message_from_emu(EMU_MEDIA_TYPE::FLOPPY_DISK \| (floppy_disk_status[drv].bank & 0xff),
2378		- drv,
2379		- EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
2380		- floppy_disk_status[drv].path);
	2377	+ osdcall_string(EMU_MEDIA_TYPE::FLOPPY_DISK \| (floppy_disk_status[drv].bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK),
	2378	+ drv,
	2379	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	2380	+ floppy_disk_status[drv].path);
2381	2381	}
2382	2382	}
2383	2383	#endif

		@@ -2390,6 +2390,10 @@ void EMU::update_media()
2390	2390	#else
2391	2391	out_message(_T("QD: %s"), quick_disk_status[drv].path);
2392	2392	#endif
	2393	+ osdcall_string(EMU_MEDIA_TYPE::QUICK_DISK,
	2394	+ drv,
	2395	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	2396	+ (_TCHAR *)quick_disk_status[drv].path);
2393	2397	}
2394	2398	}
2395	2399	#endif

		@@ -2402,6 +2406,10 @@ void EMU::update_media()
2402	2406	#else
2403	2407	out_message(_T("HD: %s"), hard_disk_status[drv].path);
2404	2408	#endif
	2409	+ osdcall_string(EMU_MEDIA_TYPE::HARD_DISK,
	2410	+ drv,
	2411	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	2412	+ (_TCHAR *)hard_disk_status[drv].path);
2405	2413	}
2406	2414	}
2407	2415	#endif

		@@ -2418,6 +2426,10 @@ void EMU::update_media()
2418	2426	#else
2419	2427	out_message(_T("CMT: %s"), tape_status[drv].path);
2420	2428	#endif
	2429	+ osdcall_string(EMU_MEDIA_TYPE::TAPE,
	2430	+ drv,
	2431	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	2432	+ (_TCHAR *)tape_status[drv].path);
2421	2433	}
2422	2434	}
2423	2435	#endif

		@@ -2430,6 +2442,10 @@ void EMU::update_media()
2430	2442	#else
2431	2443	out_message(_T("CD: %s"), compact_disc_status[drv].path);
2432	2444	#endif
	2445	+ osdcall_string(EMU_MEDIA_TYPE::COMPACT_DISC,
	2446	+ drv,
	2447	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	2448	+ (_TCHAR *)compact_disc_status[drv].path);
2433	2449	}
2434	2450	}
2435	2451	#endif

		@@ -2442,18 +2458,26 @@ void EMU::update_media()
2442	2458	#else
2443	2459	out_message(_T("LD: %s"), laser_disc_status[drv].path);
2444	2460	#endif
	2461	+ osdcall_string(EMU_MEDIA_TYPE::LASER_DISC,
	2462	+ drv,
	2463	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	2464	+ (_TCHAR *)laser_disc_status[drv].path);
2445	2465	}
2446	2466	}
2447	2467	#endif
2448	2468	#ifdef USE_BUBBLE
2449	2469	for(int drv = 0; drv < USE_BUBBLE; drv++) {
2450	2470	if(bubble_casette_status[drv].wait_count != 0 && --bubble_casette_status[drv].wait_count == 0) {
2451		- vm->open_bubble_casette(drv, bubble_casette_status[drv].path, bubble_casette_status[drv].bank);
	2471	+ vm->open_bubble_casette(drv, bubble_casette_status[drv].path, bubble_casette_status[drv].bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK);
2452	2472	#if USE_BUBBLE > 1
2453	2473	out_message(_T("Bubble%d: %s"), drv + BASE_BUBBLE_NUM, bubble_casette_status[drv].path);
2454	2474	#else
2455	2475	out_message(_T("Bubble: %s"), bubble_casette_status[drv].path);
2456	2476	#endif
	2477	+ osdcall_string(EMU_MEDIA_TYPE::BUBBLE_CASETTE \| (bubble_casette_status[drv].bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK),
	2478	+ drv,
	2479	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	2480	+ (_TCHAR *)bubble_casette_status[drv].path);
2457	2481	}
2458	2482	}
2459	2483	#endif

		@@ -2476,11 +2500,11 @@ void EMU::restore_media()
2476	2500	#ifdef USE_FLOPPY_DISK
2477	2501	for(int drv = 0; drv < USE_FLOPPY_DISK; drv++) {
2478	2502	if(floppy_disk_status[drv].path[0] != _T('\0')) {
2479		- vm->open_floppy_disk(drv, floppy_disk_status[drv].path, floppy_disk_status[drv].bank & 0x7f);
2480		- osd->string_message_from_emu(EMU_MEDIA_TYPE::FLOPPY_DISK \| (floppy_disk_status[drv].bank & 0xff),
2481		- drv,
2482		- EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
2483		- floppy_disk_status[drv].path);
	2503	+ vm->open_floppy_disk(drv, floppy_disk_status[drv].path, floppy_disk_status[drv].bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK);
	2504	+ osdcall_string(EMU_MEDIA_TYPE::FLOPPY_DISK \| (floppy_disk_status[drv].bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK),
	2505	+ drv,
	2506	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	2507	+ floppy_disk_status[drv].path);
2484	2508	}
2485	2509	}
2486	2510	#endif

		@@ -2544,6 +2568,10 @@ void EMU::open_cart(int drv, const _TCHAR* file_path)
2544	2568	}
2545	2569	my_tcscpy_s(cart_status[drv].path, _MAX_PATH, file_path);
2546	2570	out_message(_T("Cart%d: %s"), drv + 1, file_path);
	2571	+ osdcall_string(EMU_MEDIA_TYPE::CARTRIDGE,
	2572	+ drv,
	2573	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	2574	+ (_TCHAR *)file_path);
2547	2575	#if !defined(_USE_QT)
2548	2576	// restart recording
2549	2577	bool s = osd->now_record_sound;

		@@ -2567,6 +2595,10 @@ void EMU::close_cart(int drv)
2567	2595	#else
2568	2596	out_message(_T("Cart: Ejected"));
2569	2597	#endif
	2598	+ osdcall_int(EMU_MEDIA_TYPE::CARTRIDGE,
	2599	+ drv,
	2600	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	2601	+ 0);
2570	2602	#if !defined(_USE_QT)
2571	2603	// stop recording
2572	2604	stop_record_video();

		@@ -2648,7 +2680,7 @@ void EMU::open_floppy_disk(int drv, const _TCHAR* file_path, int bank)
2648	2680	d88_file[drv].bank_num++;
2649	2681	}
2650	2682	my_tcscpy_s(d88_file[drv].path, _MAX_PATH, file_path);
2651		- d88_file[drv].cur_bank = bank & 0x7f;
	2683	+ d88_file[drv].cur_bank = bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK;
2652	2684	} catch(...) {
2653	2685	d88_file[drv].bank_num = 0;
2654	2686	}

		@@ -2666,17 +2698,21 @@ void EMU::open_floppy_disk(int drv, const _TCHAR* file_path, int bank)
2666	2698	#else
2667	2699	out_message(_T("FD: Ejected"));
2668	2700	#endif
2669		- } else if(floppy_disk_status[drv].wait_count == 0) {
2670		- vm->open_floppy_disk(drv, file_path, bank & 0x7f);
	2701	+ osdcall_int(EMU_MEDIA_TYPE::FLOPPY_DISK,
	2702	+ drv,
	2703	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	2704	+ 0);
	2705	+ } else if(floppy_disk_status[drv].wait_count == 0) {
	2706	+ vm->open_floppy_disk(drv, file_path, bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK);
2671	2707	#if USE_FLOPPY_DISK > 1
2672	2708	out_message(_T("FD%d: %s"), drv + BASE_FLOPPY_DISK_NUM, file_path);
2673	2709	#else
2674	2710	out_message(_T("FD: %s"), file_path);
2675	2711	#endif
2676		- osd->string_message_from_emu(EMU_MEDIA_TYPE::FLOPPY_DISK \| (bank & 0xff),
2677		- drv,
2678		- EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
2679		- (_TCHAR *)file_path);
	2712	+ osdcall_string(EMU_MEDIA_TYPE::FLOPPY_DISK \| (bank & EMU_MEDIA_TYPE::MULTIPLE_SLOT_MASK),
	2713	+ drv,
	2714	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	2715	+ (_TCHAR *)file_path);
2680	2716	}
2681	2717	my_tcscpy_s(floppy_disk_status[drv].path, _MAX_PATH, file_path);
2682	2718	floppy_disk_status[drv].bank = bank;

		@@ -2697,6 +2733,10 @@ void EMU::close_floppy_disk(int drv)
2697	2733	#else
2698	2734	out_message(_T("FD: Ejected"));
2699	2735	#endif
	2736	+ osdcall_int(EMU_MEDIA_TYPE::FLOPPY_DISK,
	2737	+ drv,
	2738	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	2739	+ 0);
2700	2740	}
2701	2741	}
2702	2742

		@@ -2759,6 +2799,10 @@ void EMU::open_quick_disk(int drv, const _TCHAR* file_path)
2759	2799	#else
2760	2800	out_message(_T("QD: Ejected"));
2761	2801	#endif
	2802	+ osdcall_int(EMU_MEDIA_TYPE::QUICK_DISK,
	2803	+ drv,
	2804	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	2805	+ 0);
2762	2806	} else if(quick_disk_status[drv].wait_count == 0) {
2763	2807	vm->open_quick_disk(drv, file_path);
2764	2808	#if USE_QUICK_DISK > 1

		@@ -2766,6 +2810,10 @@ void EMU::open_quick_disk(int drv, const _TCHAR* file_path)
2766	2810	#else
2767	2811	out_message(_T("QD: %s"), file_path);
2768	2812	#endif
	2813	+ osdcall_string(EMU_MEDIA_TYPE::QUICK_DISK,
	2814	+ drv,
	2815	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	2816	+ (_TCHAR*)file_path);
2769	2817	}
2770	2818	my_tcscpy_s(quick_disk_status[drv].path, _MAX_PATH, file_path);
2771	2819	}

		@@ -2781,6 +2829,10 @@ void EMU::close_quick_disk(int drv)
2781	2829	#else
2782	2830	out_message(_T("QD: Ejected"));
2783	2831	#endif
	2832	+ osdcall_int(EMU_MEDIA_TYPE::QUICK_DISK,
	2833	+ drv,
	2834	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	2835	+ 0);
2784	2836	}
2785	2837	}
2786	2838

		@@ -2907,6 +2959,10 @@ void EMU::open_hard_disk(int drv, const _TCHAR* file_path)
2907	2959	#else
2908	2960	out_message(_T("HD: Unmounted"));
2909	2961	#endif
	2962	+ osdcall_int((EMU_MEDIA_TYPE::HARD_DISK,
	2963	+ drv,
	2964	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	2965	+ 0);
2910	2966	} else if(hard_disk_status[drv].wait_count == 0) {
2911	2967	vm->open_hard_disk(drv, file_path);
2912	2968	#if USE_HARD_DISK > 1

		@@ -2914,6 +2970,10 @@ void EMU::open_hard_disk(int drv, const _TCHAR* file_path)
2914	2970	#else
2915	2971	out_message(_T("HD: %s"), file_path);
2916	2972	#endif
	2973	+ osdcall_string(EMU_MEDIA_TYPE::HARD_DISK,
	2974	+ drv,
	2975	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	2976	+ (_TCHAR*)file_path);
2917	2977	}
2918	2978	my_tcscpy_s(hard_disk_status[drv].path, _MAX_PATH, file_path);
2919	2979	my_tcscpy_s(config.last_hard_disk_path[drv], _MAX_PATH, file_path);

		@@ -2930,6 +2990,10 @@ void EMU::close_hard_disk(int drv)
2930	2990	#else
2931	2991	out_message(_T("HD: Unmounted"));
2932	2992	#endif
	2993	+ osdcall_int((EMU_MEDIA_TYPE::HARD_DISK,
	2994	+ drv,
	2995	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	2996	+ 0);
2933	2997	config.last_hard_disk_path[drv][0] = '\0';
2934	2998	}
2935	2999	}

		@@ -2963,6 +3027,10 @@ void EMU::play_tape(int drv, const _TCHAR* file_path)
2963	3027	#else
2964	3028	out_message(_T("CMT: Ejected"));
2965	3029	#endif
	3030	+ osdcall_int(EMU_MEDIA_TYPE::TAPE,
	3031	+ drv,
	3032	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	3033	+ 0);
2966	3034	} else if(tape_status[drv].wait_count == 0) {
2967	3035	vm->play_tape(drv, file_path);
2968	3036	#if USE_TAPE > 1

		@@ -2970,6 +3038,10 @@ void EMU::play_tape(int drv, const _TCHAR* file_path)
2970	3038	#else
2971	3039	out_message(_T("CMT: %s"), file_path);
2972	3040	#endif
	3041	+ osdcall_string(EMU_MEDIA_TYPE::TAPE,
	3042	+ drv,
	3043	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	3044	+ (_TCHAR*)file_path);
2973	3045	}
2974	3046	my_tcscpy_s(tape_status[drv].path, _MAX_PATH, file_path);
2975	3047	tape_status[drv].play = true;

		@@ -2988,6 +3060,10 @@ void EMU::rec_tape(int drv, const _TCHAR* file_path)
2988	3060	#else
2989	3061	out_message(_T("CMT: Ejected"));
2990	3062	#endif
	3063	+ osdcall_int(EMU_MEDIA_TYPE::TAPE,
	3064	+ drv,
	3065	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	3066	+ 0);
2991	3067	} else if(tape_status[drv].wait_count == 0) {
2992	3068	vm->rec_tape(drv, file_path);
2993	3069	#if USE_TAPE > 1

		@@ -2995,6 +3071,10 @@ void EMU::rec_tape(int drv, const _TCHAR* file_path)
2995	3071	#else
2996	3072	out_message(_T("CMT: %s"), file_path);
2997	3073	#endif
	3074	+ osdcall_string(EMU_MEDIA_TYPE::TAPE,
	3075	+ drv,
	3076	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	3077	+ (_TCHAR*)file_path);
2998	3078	}
2999	3079	my_tcscpy_s(tape_status[drv].path, _MAX_PATH, file_path);
3000	3080	tape_status[drv].play = false;

		@@ -3011,6 +3091,10 @@ void EMU::close_tape(int drv)
3011	3091	#else
3012	3092	out_message(_T("CMT: Ejected"));
3013	3093	#endif
	3094	+ osdcall_int(EMU_MEDIA_TYPE::TAPE,
	3095	+ drv,
	3096	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	3097	+ 0);
3014	3098	}
3015	3099	}
3016	3100

		@@ -3115,6 +3199,10 @@ void EMU::open_compact_disc(int drv, const _TCHAR* file_path)
3115	3199	#else
3116	3200	out_message(_T("CD: Ejected"));
3117	3201	#endif
	3202	+ osdcall_int(EMU_MEDIA_TYPE::COMPACT_DISC,
	3203	+ drv,
	3204	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	3205	+ 0);
3118	3206	} else if(compact_disc_status[drv].wait_count == 0) {
3119	3207	vm->open_compact_disc(drv, file_path);
3120	3208	#if USE_COMPACT_DISC > 1

		@@ -3122,6 +3210,10 @@ void EMU::open_compact_disc(int drv, const _TCHAR* file_path)
3122	3210	#else
3123	3211	out_message(_T("CD: %s"), file_path);
3124	3212	#endif
	3213	+ osdcall_string(EMU_MEDIA_TYPE::COMPACT_DISC,
	3214	+ drv,
	3215	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	3216	+ (_TCHAR*)file_path);
3125	3217	}
3126	3218	my_tcscpy_s(compact_disc_status[drv].path, _MAX_PATH, file_path);
3127	3219	}

		@@ -3137,6 +3229,10 @@ void EMU::close_compact_disc(int drv)
3137	3229	#else
3138	3230	out_message(_T("CD: Ejected"));
3139	3231	#endif
	3232	+ osdcall_int(EMU_MEDIA_TYPE::COMPACT_DISC,
	3233	+ drv,
	3234	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	3235	+ 0);
3140	3236	}
3141	3237	}
3142	3238

		@@ -3168,6 +3264,10 @@ void EMU::open_laser_disc(int drv, const _TCHAR* file_path)
3168	3264	#else
3169	3265	out_message(_T("LD: Ejected"));
3170	3266	#endif
	3267	+ osdcall_int(EMU_MEDIA_TYPE::LASER_DISC,
	3268	+ drv,
	3269	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	3270	+ 0);
3171	3271	} else if(laser_disc_status[drv].wait_count == 0) {
3172	3272	vm->open_laser_disc(drv, file_path);
3173	3273	#if USE_LASER_DISC > 1

		@@ -3175,6 +3275,10 @@ void EMU::open_laser_disc(int drv, const _TCHAR* file_path)
3175	3275	#else
3176	3276	out_message(_T("LD: %s"), file_path);
3177	3277	#endif
	3278	+ osdcall_string(EMU_MEDIA_TYPE::LASER_DISC,
	3279	+ drv,
	3280	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	3281	+ (_TCHAR*)file_path);
3178	3282	}
3179	3283	my_tcscpy_s(laser_disc_status[drv].path, _MAX_PATH, file_path);
3180	3284	}

		@@ -3190,6 +3294,10 @@ void EMU::close_laser_disc(int drv)
3190	3294	#else
3191	3295	out_message(_T("LD: Ejected"));
3192	3296	#endif
	3297	+ osdcall_int(EMU_MEDIA_TYPE::LASER_DISC,
	3298	+ drv,
	3299	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	3300	+ 0);
3193	3301	}
3194	3302	}
3195	3303

		@@ -3253,6 +3361,10 @@ void EMU::open_bubble_casette(int drv, const _TCHAR* file_path, int bank)
3253	3361	#else
3254	3362	out_message(_T("Bubble: Ejected"));
3255	3363	#endif
	3364	+ osdcall_int(EMU_MEDIA_TYPE::BUBBLE_CASETTE,
	3365	+ drv,
	3366	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	3367	+ 0);
3256	3368	} else if(bubble_casette_status[drv].wait_count == 0) {
3257	3369	vm->open_bubble_casette(drv, file_path, bank);
3258	3370	#if USE_BUBBLE > 1

		@@ -3260,6 +3372,10 @@ void EMU::open_bubble_casette(int drv, const _TCHAR* file_path, int bank)
3260	3372	#else
3261	3373	out_message(_T("Bubble: %s"), file_path);
3262	3374	#endif
	3375	+ osdcall_string(EMU_MEDIA_TYPE::BUBBLE_CASETTE \| (bank & EMU_MEDIA_TYPE::MULIPLE_SLOT_MASK),
	3376	+ drv,
	3377	+ EMU_MESSAGE_TYPE::MEDIA_MOUNTED,
	3378	+ (_TCHAR*)file_path);
3263	3379	}
3264	3380	my_tcscpy_s(bubble_casette_status[drv].path, _MAX_PATH, file_path);
3265	3381	bubble_casette_status[drv].bank = bank;

		@@ -3276,6 +3392,10 @@ void EMU::close_bubble_casette(int drv)
3276	3392	#else
3277	3393	out_message(_T("Bubble: Ejected"));
3278	3394	#endif
	3395	+ osdcall_int(EMU_MEDIA_TYPE::BUBBLE_CASETTE,
	3396	+ drv,
	3397	+ EMU_MESSAGE_TYPE::MEDIA_REMOVED,
	3398	+ 0);
3279	3399	}
3280	3400	}
3281	3401

--- a/source/src/osdcall_types.h

+++ b/source/src/osdcall_types.h

		@@ -25,11 +25,19 @@ namespace EMU_MEDIA_TYPE {
25	25	QUICK_DISK = 8 << 16,
26	26	TAPE = 9 << 16,
27	27
28		- AUDIO = (1 << 18) + (30 << 16),
29		- VIDEO = (2 << 18) + (30 << 16),
30		- ANY_MEDIA = (7 << 18) + (30 << 16),
	28	+ AUDIO = (28 << 16),
	29	+ VIDEO = (29 << 16),
	30	+ ANY_MEDIA = (127 << 16),
	31	+ UI_MEDIA_MASK = (127 << 16),
	32	+ UI_MESSAGE_MASK = ((0xffffffff) << 32),
	33	+
	34	+ EMU_SLOT_MASK = 0x7f,
	35	+ MULTIPLE_SLOT_MASK = 0xff,
	36	+
31	37	END = UINT64_MAX
32	38	};
	39	+ const type_t MULTIPLE_SLOT_DETECT_MASK = ((~EMU_SLOT_MASK) & MULTIPLE_SLOT_MASK);
	40	+
33	41	}
34	42
35	43

--- a/source/src/qt/common/emu_thread_slots.cpp

+++ b/source/src/qt/common/emu_thread_slots.cpp

		@@ -501,15 +501,19 @@ void EmuThreadClassBase::do_stop_auto_key(void)
501	501	void EmuThreadClassBase::do_write_protect_disk(int drv, bool flag)
502	502	{
503	503	//QMutexLocker _locker(&uiMutex);
504		- if(using_flags->is_use_fd()) {
	504	+ std::shared_ptr<USING_FLAGS> p = using_flags;
	505	+ if(p.get() == nullptr) return;
	506	+ if((p->get_max_drive() > drv) && (p->is_use_fd())) {
505	507	p_emu->is_floppy_disk_protected(drv, flag);
506	508	}
507	509	}
508	510
509		-void EmuThreadClassBase::do_close_disk(int drv)
	511	+void EmuThreadClassBase::do_close_floppy_disk(int drv)
510	512	{
511	513	//QMutexLocker _locker(&uiMutex);
512		- if(using_flags->is_use_fd()) {
	514	+ std::shared_ptr<USING_FLAGS> p = using_flags;
	515	+ if(p.get() == nullptr) return;
	516	+ if((p->get_max_drive() > drv) && (p->is_use_fd())) {
513	517	p_emu->close_floppy_disk(drv);
514	518	//fd_open_wait_count[drv] = (int)(get_emu_frame_rate() * 1.0);
515	519	emit sig_change_virtual_media(CSP_DockDisks_Domain_FD, drv, QString::fromUtf8(""));

		@@ -518,13 +522,15 @@ void EmuThreadClassBase::do_close_disk(int drv)
518	522	}
519	523	}
520	524
521		-void EmuThreadClassBase::do_open_disk(int drv, QString path, int bank)
	525	+void EmuThreadClassBase::do_open_floppy_disk(int drv, QString path, int bank)
522	526	{
523	527	if(path.isEmpty()) return;
524	528	if(path.isNull()) return;
525	529
526		- if(using_flags.get() == nullptr) return;
	530	+ std::shared_ptr<USING_FLAGS> p = using_flags;
	531	+ if(p.get() == nullptr) return;
527	532	if(!(using_flags->is_use_fd())) return;
	533	+ if(!((p->get_max_drive() > drv) && (p->is_use_fd()))) return;
528	534
529	535	const _TCHAR file_path = (const _TCHAR )(path.toLocal8Bit().constData());
530	536	if(!(FILEIO::IsFileExisting(file_path))) return; // File not found.

		@@ -537,56 +543,6 @@ void EmuThreadClassBase::do_open_disk(int drv, QString path, int bank)
537	543	}
538	544
539	545	// Signal from EMU:: -> OSD:: -> EMU_THREAD (-> GUI)
540		-void EmuThreadClassBase::done_open_floppy_disk(int drive, QString path)
541		-{
542		- if((using_flags.get() == nullptr) \|\| (p_config == nullptr)) return;
543		-
544		- if(!(using_flags->is_use_fd())) return;
545		- if((drive < 0) \|\| (drive >= using_flags->get_max_drive())) return;
546		-
547		- QStringList list;
548		- _TCHAR path_shadow[_MAX_PATH] = {0};
549		- strncpy(path_shadow, path.toLocal8Bit().constData(), _MAX_PATH - 1);
550		- UPDATE_HISTORY(path_shadow, p_config->recent_floppy_disk_path[drive], list);
551		-
552		- const _TCHAR* __dir = get_parent_dir((const _TCHAR *)path_shadow);
553		- strncpy(p_config->initial_floppy_disk_dir, __dir, _MAX_PATH - 1);
554		-
555		- emit sig_ui_update_floppy_list(drive, list);
556		- emit sig_ui_clear_d88(drive);
557		-
558		- bool _f = check_file_extension(path_shadow, ".d88");
559		- _f \|= check_file_extension(path_shadow, ".d77");
560		- QString relpath = QString::fromUtf8("");
561		- if(strlen(&(__dir[0])) > 1) {
562		- relpath = QString::fromLocal8Bit(&(__dir[1]));
563		- }
564		-
565		- if(_f) {
566		- if(p_emu != nullptr) {
567		- int slot = p_emu->d88_file[drive].cur_bank;
568		- for(int i = 0; i < p_emu->d88_file[drive].bank_num; i++) {
569		- if(i >= 64) break;
570		- _TCHAR tmpname[128] = {0};
571		- my_strcpy_s(tmpname, 127, p_emu->d88_file[drive].disk_name[i]);
572		- QString tmps = QString::fromLocal8Bit(tmpname);
573		- emit sig_ui_update_d88(drive, i, tmps);
574		- if(i == slot) {
575		- emit sig_ui_select_d88(drive, i);
576		- relpath = tmps;
577		- }
578		- }
579		- }
580		- }
581		- emit sig_change_virtual_media(CSP_DockDisks_Domain_FD, drive, relpath);
582		-}
583		-
584		-void EmuThreadClassBase::done_close_floppy_disk(int drive)
585		-{
586		- emit sig_ui_close_floppy_disk(drive);
587		- emit sig_change_virtual_media(CSP_DockDisks_Domain_FD, drive, QString::fromUtf8(""));
588		-}
589		-
590	546	void EmuThreadClassBase::done_select_d88(int drive, int slot)
591	547	{
592	548	if(p_emu == nullptr) return;

--- a/source/src/qt/common/qt_utils.cpp

+++ b/source/src/qt/common/qt_utils.cpp

		@@ -160,9 +160,9 @@ void Ui_MainWindow::LaunchEmuThread(EmuThreadClassBase *m)
160	160	}
161	161	}
162	162	#if defined(USE_FLOPPY_DISK)
163		- connect(this, SIGNAL(sig_write_protect_disk(int, bool)), hRunEmu, SLOT(do_write_protect_disk(int, bool)));
164		- connect(this, SIGNAL(sig_open_disk(int, QString, int)), hRunEmu, SLOT(do_open_disk(int, QString, int)));
165		- connect(this, SIGNAL(sig_close_disk(int)), hRunEmu, SLOT(do_close_disk(int)));
	163	+ connect(this, SIGNAL(sig_write_protect_floppy_disk(int, bool)), hRunEmu, SLOT(do_write_protect_disk(int, bool)));
	164	+ connect(this, SIGNAL(sig_open_floppy_disk(int, QString, int)), hRunEmu, SLOT(do_open_floppy_disk(int, QString, int)));
	165	+ connect(this, SIGNAL(sig_close_floppy_disk(int)), hRunEmu, SLOT(do_close_floppy_disk(int)));
166	166	connect(hRunEmu, SIGNAL(sig_update_recent_disk(int)), this, SLOT(do_update_recent_disk(int)));
167	167	//connect(hRunEmu, SIGNAL(sig_change_osd_fd(int, QString)), this, SLOT(do_change_osd_fd(int, QString)));
168	168	connect(p_osd, SIGNAL(sig_ui_floppy_insert_history(int, QString, quint64)),

		@@ -382,7 +382,7 @@ void Ui_MainWindow::do_create_d88_media(int drv, quint8 media_type, QString name
382	382	if(drv < USE_FLOPPY_DISK) {
383	383	const _TCHAR* path = (const _TCHAR *)(name.toLocal8Bit().data());
384	384	if(emu->create_blank_floppy_disk(path, media_type)) {
385		- emit sig_open_disk(drv, name, 0);
	385	+ emit sig_open_floppy_disk(drv, name, 0);
386	386	}
387	387	}
388	388	#endif

--- a/source/src/qt/common/util_fd2.cpp

+++ b/source/src/qt/common/util_fd2.cpp

		@@ -11,17 +11,15 @@
11	11	//#if defined(USE_FLOPPY_DISK)
12	12
13	13	#ifndef UPDATE_D88_LIST
14		-#define UPDATE_D88_LIST(__d, lst) { \
15		- lst.clear(); \
16		- QString __tmps; \
17		- for(int iii = 0; iii < 64; iii++) { \
18		- __tmps = QString::fromUtf8(""); \
19		- if(iii < hRunEmu->get_d88_file_bank_num(__d)) { \
20		- __tmps = hRunEmu->get_d88_file_disk_name(__d, iii); \
21		- } \
22		- lst << __tmps; \
23		- } \
24		-}
	14	+#define UPDATE_D88_LIST(__d, lst) { \
	15	+ QString __tmps; \
	16	+ int ___bn = hRunEmu->get_d88_file_bank_num(__d); \
	17	+ for(int iii = 0; iii < ((___bn < 64) ? ___bn : 64); iii++) { \
	18	+ __tmps = hRunEmu->get_d88_file_disk_name(__d, iii); \
	19	+ lst << __tmps; \
	20	+ } \
	21	+ }
	22	+
25	23	#endif
26	24
27	25

		@@ -35,8 +33,8 @@ int Ui_MainWindowBase::set_d88_slot(int drive, int num)
35	33	menu_fds[drive]->do_select_inner_media(num);
36	34
37	35	if(hRunEmu->get_d88_file_cur_bank(drive) != num) {
38		- emit sig_close_disk(drive);
39		- emit sig_open_disk(drive, path, num);
	36	+ emit sig_close_floppy_disk(drive);
	37	+ emit sig_open_floppy_disk(drive, path, num & EMU_MEDIA_TYPE::EMU_SLOT_MASK);
40	38	if(hRunEmu->is_floppy_disk_protected(drive)) {
41	39	menu_fds[drive]->do_set_write_protect(true);
42	40	} else {

		@@ -88,7 +86,7 @@ void Ui_MainWindowBase::do_ui_floppy_insert_history(int drv, QString fname, quin
88	86	strncpy(path_shadow, fname.toLocal8Bit().constData(), _MAX_PATH - 1);
89	87	if(!(FILEIO::IsFileExisting(path_shadow))) return;
90	88
91		- if((bank & 0x80) == 0) {
	89	+ if((bank & EMU_MEDIA_TYPE::MULTIPLE_SLOT_DETECT_MASK) == 0) {
92	90	UPDATE_HISTORY(path_shadow, p_config->recent_floppy_disk_path[drv], listFDs[drv]);
93	91	strcpy(p_config->initial_floppy_disk_dir, get_parent_dir((const _TCHAR *)path_shadow));
94	92	// Update List

		@@ -96,13 +94,12 @@ void Ui_MainWindowBase::do_ui_floppy_insert_history(int drv, QString fname, quin
96	94	menu_fds[drv]->do_set_initialize_directory(p_config->initial_floppy_disk_dir);
97	95	}
98	96	do_update_floppy_history(drv, listFDs[drv]);
99		-
	97	+
	98	+ listD88[drv].clear();
100	99	if(check_file_extension(path_shadow, ".d88") \|\| check_file_extension(path_shadow, ".d77")) {
101	100	UPDATE_D88_LIST(drv, listD88[drv]);
102		- menu_fds[drv]->do_update_inner_media(listD88[drv], bank & 0x7f);
103		- } else {
104		- menu_fds[drv]->do_clear_inner_media();
105	101	}
	102	+ menu_fds[drv]->do_update_inner_media(listD88[drv], bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK);
106	103	}
107	104
108	105	void Ui_MainWindowBase::_open_disk(int drv, const QString fname)

		@@ -114,24 +111,23 @@ void Ui_MainWindowBase::_open_disk(int drv, const QString fname)
114	111	if(!(FILEIO::IsFileExisting(fname.toLocal8Bit().constData()))) return; // File not found.
115	112	// drv = drv & 7;
116	113	strncpy(path_shadow, fname.toLocal8Bit().constData(), PATH_MAX - 1);
117		- emit sig_close_disk(drv);
118		- emit sig_open_disk(drv, fname, 0);
	114	+ emit sig_close_floppy_disk(drv);
	115	+ emit sig_open_floppy_disk(drv, fname, 0);
119	116
120	117	if(using_flags->get_max_drive() > (drv + 1)) {
121	118	if(check_file_extension(path_shadow, ".d88") \|\| check_file_extension(path_shadow, ".d77")) {
122	119	if(((drv & 1) == 0) && (drv + 1 < using_flags->get_max_drive()) && (1 < hRunEmu->get_d88_file_bank_num(drv))) {
123	120	int drv2 = drv + 1;
124		- emit sig_close_disk(drv2);
125		- emit sig_open_disk(drv2, fname, 1 + 128);
	121	+ emit sig_close_floppy_disk(drv2);
	122	+ emit sig_open_floppy_disk(drv2, fname, 1 \| EMU_MEDIA_TYPE::MULTIPLE_SLOT_DETECT_MASK);
126	123	}
127	124	}
128	125	}
129	126	}
130	127
131		-
132	128	void Ui_MainWindowBase::do_update_d88_list(int drv, int bank)
133	129	{
134		- UPDATE_D88_LIST(drv, listD88[drv]);
135		- menu_fds[drv]->do_update_inner_media(listD88[drv], bank);
	130	+// UPDATE_D88_LIST(drv, listD88[drv]);
	131	+ menu_fds[drv]->do_update_inner_media(listD88[drv], bank & EMU_MEDIA_TYPE::EMU_SLOT_MASK);
136	132	}
137	133	//#endif

--- a/source/src/qt/gui/emu_thread_tmpl.cpp

+++ b/source/src/qt/gui/emu_thread_tmpl.cpp

		@@ -500,12 +500,17 @@ void EmuThreadClassBase::print_framerate(int frames)
500	500
501	501	int EmuThreadClassBase::get_d88_file_cur_bank(int drive)
502	502	{
503		- if(using_flags.get() == nullptr) return -1;
504		- if(!(using_flags->is_use_fd())) return -1;
	503	+ std::shared_ptr<USING_FLAGS> p = using_flags;
	504	+ if(p.get() == nullptr) return -1;
	505	+ if(!(p->is_use_fd())) return -1;
505	506
506		- if(drive < using_flags->get_max_drive()) {
	507	+ if((drive < p->get_max_drive()) && (p_emu != nullptr)) {
507	508	QMutexLocker _locker(&uiMutex);
508		- return p_emu->d88_file[drive].cur_bank;
	509	+ int bank_num = p_emu->d88_file[drive].bank_num;
	510	+ int cur_bank = p_emu->d88_file[drive].cur_bank;
	511	+ if((bank_num > 0) && (cur_bank < bank_num)) {
	512	+ return cur_bank;
	513	+ }
509	514	}
510	515
511	516	return -1;

		@@ -854,88 +859,6 @@ bool EmuThreadClassBase::now_debugging()
854	859	}
855	860	}
856	861
857		-VirtualFilesList* EmuThreadClassBase::getBinaryFilesList(int drv)
858		-{
859		- QList<VirtualFilesList> p = &vBinaryFilesList;
860		- return getVirtualMediaListPtr(drv, p);
861		-}
862		-
863		-VirtualFilesList* EmuThreadClassBase::getBubbleFilesList(int drv)
864		-{
865		- QList<VirtualFilesList> p = &vBubbleFilesList;
866		- return getVirtualMediaListPtr(drv, p);
867		-}
868		-
869		-VirtualBanksList* EmuThreadClassBase::getB77BanksList(int drv)
870		-{
871		- QList<VirtualBanksList> p = &vB77BanksList;
872		- return getVirtualMediaListPtr(drv, p);
873		-}
874		-
875		-VirtualFilesList* EmuThreadClassBase::getCartFilesList(int drv)
876		-{
877		- QList<VirtualFilesList> p = &vCartFilesList;
878		- return getVirtualMediaListPtr(drv, p);
879		-}
880		-
881		-VirtualFilesList* EmuThreadClassBase::getCompactDiscFilesList(int drv)
882		-{
883		- QList<VirtualFilesList> p = &vCompactDiscFilesList;
884		- return getVirtualMediaListPtr(drv, p);
885		-}
886		-
887		-VirtualFilesList* EmuThreadClassBase::getFloppyDiskFilesList(int drv)
888		-{
889		- QList<VirtualFilesList> p = &vFloppyDiskFilesList;
890		- return getVirtualMediaListPtr(drv, p);
891		-}
892		-
893		-VirtualBanksList* EmuThreadClassBase::getD88BanksList(int drv)
894		-{
895		- QList<VirtualBanksList> p = &vD88BanksList;
896		- return getVirtualMediaListPtr(drv, p);
897		-}
898		-
899		-VirtualFilesList* EmuThreadClassBase::getHardDiskFilesList(int drv)
900		-{
901		- QList<VirtualFilesList> p = &vHardDiskFilesList;
902		- return getVirtualMediaListPtr(drv, p);
903		-}
904		-
905		-VirtualFilesList* EmuThreadClassBase::getLaserDiscFilesList(int drv)
906		-{
907		- QList<VirtualFilesList> p = &vLaserDiscFilesList;
908		- return getVirtualMediaListPtr(drv, p);
909		-}
910		-
911		-VirtualFilesList* EmuThreadClassBase::getQuickDiskFilesList(int drv)
912		-{
913		- QList<VirtualFilesList> p = &vQuickDiskFilesList;
914		- return getVirtualMediaListPtr(drv, p);
915		-}
916		-
917		-VirtualFilesList* EmuThreadClassBase::getTapeFilesList(int drv)
918		-{
919		- QList<VirtualFilesList> p = &vTapeFilesList;
920		- return getVirtualMediaListPtr(drv, p);
921		-}
922		-
923		-void EmuThreadClassBase::appendVirualFilesList(
924		- QList<VirtualFilesList> lst,
925		- const _TCHAR* listptr,
926		- unsigned int pathlen,
927		- unsigned int list_size,
928		- Menu_MetaClass *target)
929		-{
930		- if(lst == nullptr) return;
931		- if(target == nullptr) return;
932		- VirtualFilesList* ptr = new VirtualFilesList((_TCHAR *)listptr, pathlen, list_size, this);
933		- if(ptr == nullptr) return;
934		-
935		- lst->append(ptr);
936		-
937		- connect(ptr, SIGNAL(sig_replace_ui_list(QStringList)), target, SLOT(do_update_histories(QStringList)));
938		-}
939	862
940	863	#if defined(Q_OS_LINUX)
941	864	//#undef _GNU_SOURCE

--- a/source/src/qt/gui/emu_thread_tmpl.h

+++ b/source/src/qt/gui/emu_thread_tmpl.h

		@@ -160,22 +160,6 @@ protected:
160	160	QStringList vMovieQueue;
161	161
162	162	// Standard 8 files.
163		- QList<VirtualFilesList *> vBinaryFilesList;
164		-
165		- QList<VirtualFilesList *> vBubbleFilesList;
166		- QList<VirtualBanksList *> vB77BanksList; // 16
167		-
168		- QList<VirtualFilesList *> vCartFilesList;
169		- QList<VirtualFilesList *> vCompactDiscFilesList;
170		-
171		- QList<VirtualFilesList *> vFloppyDiskFilesList; // 16
172		- QList<VirtualBanksList *> vD88BanksList; // 64
173		-
174		- QList<VirtualFilesList *> vHardDiskFilesList;
175		- QList<VirtualFilesList *> vLaserDiscFilesList;
176		- QList<VirtualFilesList *> vQuickDiskFilesList;
177		- QList<VirtualFilesList *> vTapeFilesList;
178		-
179	163	void calc_volume_from_balance(int num, int balance);
180	164	void calc_volume_from_level(int num, int level);
181	165	int parse_command_queue(QStringList _l, int _begin);

		@@ -268,37 +252,7 @@ public:
268	252	void set_floppy_disk_protected(int drive, bool flag);
269	253	QString get_d88_file_path(int drive);
270	254
271		- VirtualFilesList* getBinaryFilesList(int drv = 0);
272		-
273		- VirtualFilesList* getBubbleFilesList(int drv = 0);
274		- VirtualBanksList* getB77BanksList(int drv = 0);
275		-
276		- VirtualFilesList* getCartFilesList(int drv = 0);
277		- VirtualFilesList* getCompactDiscFilesList(int drv = 0);
278		-
279		- VirtualFilesList* getFloppyDiskFilesList(int drv = 0);
280		- VirtualBanksList* getD88BanksList(int drv = 0);
281		-
282		- VirtualFilesList* getHardDiskFilesList(int drv = 0);
283		- VirtualFilesList* getLaserDiscFilesList(int drv = 0);
284		- VirtualFilesList* getQuickDiskFilesList(int drv = 0);
285		- VirtualFilesList* getTapeFilesList(int drv = 0);
286		-
287		- template <class X>
288		- X* getVirtualMediaListPtr(int drv, QList<X> lst)
289		- {
290		- if(lst == nullptr) return nullptr;
291		- if(lst->isEmpty()) return nullptr;
292		- if(lst->count() <= drv) return nullptr;
293		- return lst->at(drv);
294		- }
295		-
296		- void appendVirualFilesList(
297		- QList<VirtualFilesList> lst,
298		- const _TCHAR* listptr,
299		- unsigned int pathlen,
300		- unsigned int list_size,
301		- Menu_MetaClass *target);
	255	+
302	256	public slots:
303	257	void doExit(void);
304	258

		@@ -330,10 +284,12 @@ public slots:
330	284	void moved_mouse(double x, double y, double globalx, double globaly);
331	285
332	286	void do_write_protect_disk(int drv, bool flag);
333		- void do_close_disk(int);
334		- void do_open_disk(int, QString, int);
	287	+ void do_close_floppy_disk(int);
	288	+ void do_open_floppy_disk(int, QString, int);
	289	+
335	290	void do_close_hard_disk(int);
336	291	void do_open_hard_disk(int, QString);
	292	+
337	293	void do_play_tape(int drv, QString name);
338	294	void do_rec_tape(int drv, QString name);
339	295	void do_close_tape(int drv);

		@@ -343,28 +299,33 @@ public slots:
343	299	void do_cmt_push_fast_rewind(int drv);
344	300	void do_cmt_push_apss_forward(int drv);
345	301	void do_cmt_push_apss_rewind(int drv);
	302	+
346	303	void do_write_protect_quickdisk(int drv, bool flag);
347	304	void do_close_quickdisk(int drv);
348	305	void do_open_quickdisk(int drv, QString path);
	306	+
349	307	void do_close_cart(int drv);
350	308	void do_open_cart(int drv, QString path);
	309	+
351	310	void do_close_laser_disc(int drv);
352	311	void do_open_laser_disc(int drv, QString path);
	312	+
353	313	void do_eject_cdrom(int drv);
354	314	void do_open_cdrom(int drv, QString path);
	315	+
355	316	void do_load_binary(int drv, QString path);
356	317	void do_save_binary(int drv, QString path);
	318	+
357	319	void do_write_protect_bubble_casette(int drv, bool flag);
358	320	void do_close_bubble_casette(int);
359	321	void do_open_bubble_casette(int, QString, int);
	322	+
360	323	void do_start_auto_key(QString text);
361	324	void do_stop_auto_key(void);
362	325	void set_romakana(bool flag);
363	326	void do_close_debugger(void);
364	327
365	328	// Signal from EMU:: -> OSD:: -> EMU_THREAD (-> GUI (menu_foo[bar]))
366		- void done_open_floppy_disk(int drive, QString path);
367		- void done_close_floppy_disk(int drive);
368	329	void done_select_d88(int drive, int slot);
369	330
370	331	void done_open_tape(int drive, QString path);

--- a/source/src/qt/gui/mainwidget_base.h

+++ b/source/src/qt/gui/mainwidget_base.h

		@@ -974,9 +974,9 @@ signals:
974	974	int sig_screen_multiply(double);
975	975	int sig_update_master_volume(int);
976	976
977		- int sig_write_protect_disk(int drv, bool flag);
978		- int sig_open_disk(int, QString, int);
979		- int sig_close_disk(int);
	977	+ int sig_write_protect_floppy_disk(int drv, bool flag);
	978	+ int sig_open_floppy_disk(int, QString, int);
	979	+ int sig_close_floppy_disk(int);
980	980	int sig_open_hard_disk(int, QString);
981	981	int sig_close_hard_disk(int);
982	982	int sig_play_tape(int ,QString);

--- a/source/src/qt/gui/menu_metaclass.cpp

+++ b/source/src/qt/gui/menu_metaclass.cpp

		@@ -44,7 +44,7 @@ Menu_MetaClass::Menu_MetaClass(QMenuBar *root_entry, QString desc, std::shared_p
44	44	setObjectName(object_desc);
45	45
46	46	for(ii = 0; ii < using_flags->get_max_d88_banks(); ii++) {
47		- action_select_media_list[ii] = NULL;
	47	+ action_select_media_list[ii] = nullptr;
48	48	}
49	49	use_write_protect = true;
50	50	use_d88_menus = false;

		@@ -189,7 +189,7 @@ void Menu_MetaClass::do_add_media_extension(QString ext, QString description)
189	189	void Menu_MetaClass::do_select_inner_media(int num)
190	190	{
191	191	if(use_d88_menus && (num < using_flags->get_max_d88_banks())) {
192		- if(action_select_media_list[num] != NULL) {
	192	+ if(action_select_media_list[num] != nullptr) {
193	193	action_select_media_list[num]->setChecked(true);
194	194	}
195	195	}

		@@ -307,7 +307,7 @@ void Menu_MetaClass::do_update_histories(QStringList lst)
307	307	void Menu_MetaClass::do_clear_inner_media(void)
308	308	{
309	309	int ii;
310		- inner_media_list.clear();
	310	+ //inner_media_list.clear();
311	311	if(use_d88_menus) {
312	312	for(ii = 0; ii < using_flags->get_max_d88_banks(); ii++) {
313	313	if(action_select_media_list[ii] != nullptr) {

		@@ -322,8 +322,32 @@ void Menu_MetaClass::do_clear_inner_media(void)
322	322	void Menu_MetaClass::do_update_inner_media(QStringList lst, int num)
323	323	{
324	324	QString tmps;
325		- inner_media_list.clear();
326		- emit sig_update_inner_fd(media_drive, inner_media_list, action_select_media_list, lst , num, use_d88_menus);
	325	+ if(num < 0) return;
	326	+
	327	+ if(use_d88_menus) {
	328	+ //inner_media_list.clear();
	329	+ do_clear_inner_media();
	330	+ int _n = using_flags->get_max_d88_banks();
	331	+ if(_n <= 0) return;
	332	+ int count = 0;
	333	+ for(auto _l = lst.begin(); _l != lst.end(); ++_l) {
	334	+ if(count >= _n) break;
	335	+ //inner_media_list.push_back((*_l));
	336	+ if(action_select_media_list[count] != nullptr) {
	337	+ action_select_media_list[count]->setText((*_l));
	338	+ action_select_media_list[count]->setChecked((count == num) ? true : false);
	339	+ action_select_media_list[count]->setVisible(true);
	340	+ }
	341	+ count++;
	342	+ }
	343	+ if((num >= count) \|\| (num < 0)) {
	344	+ if(action_select_media_list[0] != nullptr) {
	345	+ action_select_media_list[0]->setChecked(true);
	346	+ }
	347	+ }
	348	+ }
	349	+
	350	+ //emit sig_update_inner_fd(media_drive, inner_media_list, action_select_media_list, lst , num, use_d88_menus);
327	351	}
328	352
329	353	void Menu_MetaClass::do_update_inner_media_bubble(QStringList lst, int num)

--- a/source/src/qt/gui/util_fd.cpp

+++ b/source/src/qt/gui/util_fd.cpp

		@@ -24,14 +24,14 @@
24	24	int Ui_MainWindowBase::write_protect_fd(int drv, bool flag)
25	25	{
26	26	if((drv < 0) \|\| (drv >= using_flags->get_max_drive())) return -1;
27		- emit sig_write_protect_disk(drv, flag);
	27	+ emit sig_write_protect_floppy_disk(drv, flag);
28	28	return 0;
29	29	}
30	30
31	31
32	32	void Ui_MainWindowBase::eject_fd(int drv)
33	33	{
34		- emit sig_close_disk(drv);
	34	+ emit sig_close_floppy_disk(drv);
35	35	menu_fds[drv]->do_clear_inner_media();
36	36	}
37	37

--- a/source/src/qt/osd_base.cpp

+++ b/source/src/qt/osd_base.cpp

		@@ -677,8 +677,15 @@ void OSD_BASE::string_message_from_emu(EMU_MEDIA_TYPE::type_t media_type, int dr
677	677	// case EMU_MEDIA_TYPE::BINARY:
678	678	// }
679	679	QString tmps;
680		- uint64_t _type = media_type & (31 << 16);
	680	+ uint64_t _type = media_type & EMU_MEDIA_TYPE::UI_MEDIA_MASK;
681	681	uint64_t _slot = media_type & 255;
	682	+ bool is_ui_message = ((media_type & EMU_MEDIA_TYPE::UI_MESSAGE_MASK) != 0) ? true : false;
	683	+ if(is_ui_message) {
	684	+ // Below are update message to UI.
	685	+ return; // ToDo: Implement
	686	+ }
	687	+
	688	+ // Below are update status to UI.
682	689	switch(_type) {
683	690	case EMU_MEDIA_TYPE::FLOPPY_DISK :
684	691	if(message != nullptr) {

		@@ -695,6 +702,13 @@ void OSD_BASE::string_message_from_emu(EMU_MEDIA_TYPE::type_t media_type, int dr
695	702
696	703	void OSD_BASE::int_message_from_emu(EMU_MEDIA_TYPE::type_t media_type, int drive, EMU_MESSAGE_TYPE::type_t message_type, int64_t data)
697	704	{
	705	+ uint64_t _type = media_type & EMU_MEDIA_TYPE::UI_MEDIA_MASK;
	706	+ uint64_t _slot = media_type & 255;
	707	+ bool is_ui_message = ((media_type & EMU_MEDIA_TYPE::UI_MESSAGE_MASK) != 0) ? true : false;
	708	+ if(is_ui_message) {
	709	+ // Below are update message to UI.
	710	+ return; // ToDo: Implement
	711	+ }
698	712	// switch(media_type) {
699	713	// case EMU_MEDIA_TYPE::BINARY:
700	714	// }

Show on old repository browser