Chloe Stars
576 lines
21 KiB
C
576 lines
21 KiB
C
/*
|
|
PokeMini - Pokémon-Mini Emulator
|
|
Copyright (C) 2009-2015 JustBurn
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
#include <stdarg.h>
|
|
#include <math.h>
|
|
#include <unistd.h>
|
|
|
|
#include "SDL.h"
|
|
#include "PokeMini.h"
|
|
#include "PokeMini_Debug.h"
|
|
#include "Hardware_Debug.h"
|
|
#include "CPUWindow.h"
|
|
|
|
#include "PRCMapWindow.h"
|
|
#include "PokeMini_ColorPal.h"
|
|
|
|
#include <gtk/gtk.h>
|
|
#include "GtkXDialogs.h"
|
|
#include "SGtkXDrawingView.h"
|
|
|
|
static int PRCMapWindow_InConfigs = 0;
|
|
|
|
GtkWindow *PRCMapWindow;
|
|
static int PRCMapWindow_minimized;
|
|
static GtkItemFactory *ItemFactory;
|
|
static GtkAccelGroup *AccelGroup;
|
|
static GtkBox *VBox1;
|
|
static GtkMenuBar *MenuBar;
|
|
static GtkLabel *LabelRunFull;
|
|
static GtkLabel *LabelInfo;
|
|
static SGtkXDrawingView PRCMapView;
|
|
static GtkLabel *MapPosInfo;
|
|
|
|
// Locals
|
|
static int FullRedraw = 1;
|
|
static int ShowGrid = 1;
|
|
static int ShowVisible = 1;
|
|
static int Negative = 0;
|
|
|
|
static uint32_t VisibleBorderCol[4] = {0xFF0000, 0xFFFF00, 0xFF8080, 0xFF0000};
|
|
|
|
// PRC Map render (Mono)
|
|
static void PRCMapRenderMono(SGtkXDrawingView *widg, int zoom, int negative)
|
|
{
|
|
uint32_t *scanptr;
|
|
int x, y, xp, yp, xl, yl;
|
|
uint32_t tileidxaddr, ltileidxaddr = -1;
|
|
uint32_t tiledataddr = 0;
|
|
uint8_t tileidx = 0, data;
|
|
xl = MinxPRC.PRCMapTW * 8;
|
|
yl = MinxPRC.PRCMapTH * 8;
|
|
|
|
for (y=0; y<widg->height; y++) {
|
|
yp = y / zoom;
|
|
if (yp >= yl) break;
|
|
scanptr = &widg->imgptr[y * widg->pitch];
|
|
for (x=0; x<widg->width; x++) {
|
|
xp = x / zoom;
|
|
if (xp >= xl) break;
|
|
|
|
// Index address
|
|
tileidxaddr = 0x1360 + (yp >> 3) * MinxPRC.PRCMapTW + (xp >> 3);
|
|
|
|
// Read tile index
|
|
if (ltileidxaddr != tileidxaddr) {
|
|
ltileidxaddr = tileidxaddr;
|
|
tileidx = MinxPRC_OnRead(0, tileidxaddr);
|
|
tiledataddr = MinxPRC.PRCBGBase + (tileidx << 3);
|
|
}
|
|
|
|
// Read tile data
|
|
data = MinxPRC_OnRead(0, tiledataddr + (xp & 7)) & (1 << (yp & 7));
|
|
if (PMR_PRC_MODE & 0x01) data = !data;
|
|
if (negative) data = !data;
|
|
|
|
// Write result
|
|
scanptr[x] = data ? 0x000000 : 0xFFFFFF;
|
|
}
|
|
}
|
|
}
|
|
|
|
// PRC Map render (Color 8x8)
|
|
static void PRCMapRenderColor8x8(SGtkXDrawingView *widg, int zoom, int negative)
|
|
{
|
|
uint32_t *scanptr;
|
|
int x, y, xp, yp, xl, yl;
|
|
uint32_t tileidxaddr, ltileidxaddr = -1;
|
|
uint32_t tiledataddr = 0;
|
|
uint8_t tileidx = 0, data;
|
|
uint8_t *ColorMap = (uint8_t *)PRCStaticColorMap;
|
|
xl = MinxPRC.PRCMapTW * 8;
|
|
yl = MinxPRC.PRCMapTH * 8;
|
|
|
|
negative = negative ? 1 : 0;
|
|
for (y=0; y<widg->height; y++) {
|
|
yp = y / zoom;
|
|
if (yp >= yl) break;
|
|
scanptr = &widg->imgptr[y * widg->pitch];
|
|
for (x=0; x<widg->width; x++) {
|
|
xp = x / zoom;
|
|
if (xp >= xl) break;
|
|
|
|
// Index address
|
|
tileidxaddr = 0x1360 + (yp >> 3) * MinxPRC.PRCMapTW + (xp >> 3);
|
|
|
|
// Read tile index
|
|
if (ltileidxaddr != tileidxaddr) {
|
|
ltileidxaddr = tileidxaddr;
|
|
tileidx = MinxPRC_OnRead(0, tileidxaddr);
|
|
tiledataddr = MinxPRC.PRCBGBase + (tileidx << 3);
|
|
ColorMap = (uint8_t *)PRCColorMap + (tiledataddr >> 2) - PRCColorOffset;
|
|
if ((ColorMap < PRCColorMap) || (ColorMap >= PRCColorTop)) ColorMap = (uint8_t *)PRCStaticColorMap;
|
|
}
|
|
|
|
// Read tile data
|
|
data = MinxPRC_OnRead(0, tiledataddr + (xp & 7)) & (1 << (yp & 7));
|
|
if (PMR_PRC_MODE & 0x01) data = !data;
|
|
if (negative) data = !data;
|
|
data = data ? ColorMap[1] : ColorMap[0];
|
|
|
|
// Write result
|
|
scanptr[x] = PokeMini_ColorPalBGR32[data];
|
|
}
|
|
}
|
|
}
|
|
|
|
// PRC Map render (Color 4x4)
|
|
static void PRCMapRenderColor4x4(SGtkXDrawingView *widg, int zoom, int negative)
|
|
{
|
|
uint32_t *scanptr;
|
|
int x, y, xp, yp, xl, yl, quad;
|
|
uint32_t tileidxaddr, ltileidxaddr = -1;
|
|
uint32_t tiledataddr = 0;
|
|
uint8_t tileidx = 0, data;
|
|
uint8_t *ColorMap = (uint8_t *)PRCStaticColorMap;
|
|
xl = MinxPRC.PRCMapTW * 8;
|
|
yl = MinxPRC.PRCMapTH * 8;
|
|
|
|
negative = negative ? 1 : 0;
|
|
for (y=0; y<widg->height; y++) {
|
|
yp = y / zoom;
|
|
if (yp >= yl) break;
|
|
scanptr = &widg->imgptr[y * widg->pitch];
|
|
for (x=0; x<widg->width; x++) {
|
|
xp = x / zoom;
|
|
if (xp >= xl) break;
|
|
|
|
// Get quad index
|
|
quad = (yp & 4) + ((xp & 4) >> 1);
|
|
|
|
// Index address
|
|
tileidxaddr = 0x1360 + (yp >> 3) * MinxPRC.PRCMapTW + (xp >> 3);
|
|
|
|
// Read tile index
|
|
if (ltileidxaddr != tileidxaddr) {
|
|
ltileidxaddr = tileidxaddr;
|
|
tileidx = MinxPRC_OnRead(0, tileidxaddr);
|
|
tiledataddr = MinxPRC.PRCBGBase + (tileidx << 3);
|
|
ColorMap = (uint8_t *)PRCColorMap + tiledataddr - PRCColorOffset;
|
|
if ((ColorMap < PRCColorMap) || (ColorMap >= PRCColorTop)) ColorMap = (uint8_t *)PRCStaticColorMap;
|
|
}
|
|
|
|
// Read tile data
|
|
data = MinxPRC_OnRead(0, tiledataddr + (xp & 7)) & (1 << (yp & 7));
|
|
if (PMR_PRC_MODE & 0x01) data = !data;
|
|
if (negative) data = !data;
|
|
data = data ? ColorMap[quad+1] : ColorMap[quad];
|
|
|
|
// Write result
|
|
scanptr[x] = PokeMini_ColorPalBGR32[data];
|
|
}
|
|
}
|
|
}
|
|
|
|
static void PRCMapDrawGrid(SGtkXDrawingView *widg, int zoom)
|
|
{
|
|
int x, y;
|
|
|
|
for (x=0; x<widg->width; x+=(zoom*8)) {
|
|
sgtkx_drawing_view_drawvline(widg, x, 0, widg->height, 0xC0C0C0);
|
|
sgtkx_drawing_view_drawvline(widg, x+1, 0, widg->height, 0x404040);
|
|
}
|
|
for (y=0; y<widg->height; y+=(zoom*8)) {
|
|
sgtkx_drawing_view_drawhline(widg, y, 0, widg->width, 0xC0C0C0);
|
|
sgtkx_drawing_view_drawhline(widg, y+1, 0, widg->width, 0x404040);
|
|
}
|
|
}
|
|
|
|
static void PRCMapDrawVisible(SGtkXDrawingView *widg, int zoom)
|
|
{
|
|
int x, y, w, h;
|
|
x = MinxPRC.PRCMapPX * zoom;
|
|
y = MinxPRC.PRCMapPY * zoom;
|
|
w = 96 * zoom;
|
|
h = 64 * zoom;
|
|
if (zoom >= 4) sgtkx_drawing_view_drawsrect(widg, x-3, y-3, w+6, h+6, VisibleBorderCol[3]);
|
|
if (zoom >= 3) sgtkx_drawing_view_drawsrect(widg, x-2, y-2, w+4, h+4, VisibleBorderCol[2]);
|
|
if (zoom >= 2) sgtkx_drawing_view_drawsrect(widg, x-1, y-1, w+2, h+2, VisibleBorderCol[1]);
|
|
else sgtkx_drawing_view_drawsrect(widg, x-1, y-1, w+2, h+2, VisibleBorderCol[0]);
|
|
if (zoom >= 2) sgtkx_drawing_view_drawsrect(widg, x, y, w, h, VisibleBorderCol[0]);
|
|
}
|
|
|
|
// -------
|
|
// Viewers
|
|
// -------
|
|
|
|
static int PRCMapView_imgresize(SGtkXDrawingView *widg, int width, int height, int pitch)
|
|
{
|
|
AnyView_DrawBackground(widg, width, height, dclc_zoom_prcmap);
|
|
return 1;
|
|
}
|
|
|
|
static int PRCMapView_exposure(SGtkXDrawingView *widg, int width, int height, int pitch)
|
|
{
|
|
char txt[PMTMPV];
|
|
|
|
if (FullRedraw) {
|
|
AnyView_DrawBackground(widg, width, height, dclc_zoom_prcmap);
|
|
FullRedraw = 0;
|
|
} else {
|
|
AnyView_DrawBackground(widg, MinxPRC.PRCMapTW*8+4, MinxPRC.PRCMapTH*8+4, dclc_zoom_prcmap);
|
|
}
|
|
if (PRCColorMap) {
|
|
if (PokeMini_ColorFormat == 1) {
|
|
// Color 4x4 Attributes
|
|
PRCMapRenderColor4x4(widg, dclc_zoom_prcmap, Negative);
|
|
} else {
|
|
// Color 8x8 Attributes
|
|
PRCMapRenderColor8x8(widg, dclc_zoom_prcmap, Negative);
|
|
}
|
|
|
|
} else {
|
|
// Mono
|
|
PRCMapRenderMono(widg, dclc_zoom_prcmap, Negative);
|
|
}
|
|
if (emumode != EMUMODE_RUNFULL) {
|
|
if (ShowGrid) PRCMapDrawGrid(widg, dclc_zoom_prcmap);
|
|
if (ShowVisible) PRCMapDrawVisible(widg, dclc_zoom_prcmap);
|
|
} else {
|
|
AnyView_DrawDisableMask(widg);
|
|
}
|
|
|
|
// Map position label
|
|
sprintf(txt, "Map X=($%02X, %i) -:- Map Y=($%02X, %i)",
|
|
(int)MinxPRC.PRCMapPX, (int)MinxPRC.PRCMapPX,
|
|
(int)MinxPRC.PRCMapPY, (int)MinxPRC.PRCMapPY);
|
|
gtk_label_set_text(MapPosInfo, txt);
|
|
|
|
return 1;
|
|
}
|
|
|
|
static int PRCMapView_motion(SGtkXDrawingView *widg, int x, int y, int _c)
|
|
{
|
|
char txt[PMTMPV];
|
|
int tzoom, tx, ty;
|
|
int mapaddr, mapnum;
|
|
int tileaddr, tilenum;
|
|
|
|
tzoom = 8 * dclc_zoom_prcmap;
|
|
tx = x / tzoom;
|
|
ty = y / tzoom;
|
|
mapnum = ty * MinxPRC.PRCMapTW + tx;
|
|
mapaddr = 0x1360 + mapnum;
|
|
|
|
// Info label
|
|
if ((tx < MinxPRC.PRCMapTW) && (ty < MinxPRC.PRCMapTH)) {
|
|
tilenum = MinxPRC_OnRead(0, mapaddr);
|
|
tileaddr = MinxPRC.PRCBGBase + (tilenum << 3);
|
|
sprintf(txt, "Map=($%04X, %i) @%06X -:- Tile=($%02X, %i) @$%06X",
|
|
mapnum, mapnum, mapaddr, tilenum, tilenum, tileaddr);
|
|
} else {
|
|
strcpy(txt, "-:-");
|
|
}
|
|
gtk_label_set_text(LabelInfo, txt);
|
|
|
|
return 0;
|
|
}
|
|
|
|
// --------------
|
|
// Menu callbacks
|
|
// --------------
|
|
|
|
static void PRCMapW_ShowVisible(GtkWidget *widget, gpointer data)
|
|
{
|
|
if (PRCMapWindow_InConfigs) return;
|
|
GtkWidget *widg = gtk_item_factory_get_item(ItemFactory, "/View/Show Visible");
|
|
ShowVisible = (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widg)) == TRUE);
|
|
FullRedraw = 1;
|
|
PRCMapWindow_Refresh(1);
|
|
}
|
|
|
|
static void PRCMapW_ShowGrid(GtkWidget *widget, gpointer data)
|
|
{
|
|
if (PRCMapWindow_InConfigs) return;
|
|
GtkWidget *widg = gtk_item_factory_get_item(ItemFactory, "/View/Show Grid");
|
|
ShowGrid = (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widg)) == TRUE);
|
|
FullRedraw = 1;
|
|
PRCMapWindow_Refresh(1);
|
|
}
|
|
|
|
static void PRCMapW_Negative(GtkWidget *widget, gpointer data)
|
|
{
|
|
if (PRCMapWindow_InConfigs) return;
|
|
GtkWidget *widg = gtk_item_factory_get_item(ItemFactory, "/View/Show Negative");
|
|
Negative = (gtk_check_menu_item_get_active(GTK_CHECK_MENU_ITEM(widg)) == TRUE);
|
|
PRCMapWindow_Refresh(1);
|
|
}
|
|
|
|
static void PRCMapW_Zoom(GtkWidget *widget, gpointer data)
|
|
{
|
|
if (PRCMapWindow_InConfigs) return;
|
|
dclc_zoom_prcmap = (int)data;
|
|
FullRedraw = 1;
|
|
PRCMapWindow_Refresh(1);
|
|
}
|
|
|
|
static void PRCMapW_RefreshNow(GtkWidget *widget, gpointer data)
|
|
{
|
|
FullRedraw = 1;
|
|
refresh_debug(1);
|
|
}
|
|
|
|
static void PRCMapW_Refresh(GtkWidget *widget, gpointer data)
|
|
{
|
|
int val, index = (int)data;
|
|
static int lastrefrindex = -2;
|
|
|
|
if (lastrefrindex == index) return;
|
|
lastrefrindex = index;
|
|
if (PRCMapWindow_InConfigs) return;
|
|
|
|
if (index >= 0) {
|
|
dclc_prcmapwin_refresh = index;
|
|
} else {
|
|
set_emumode(EMUMODE_STOP, 1);
|
|
if (EnterNumberDialog(PRCMapWindow, "Custom refresh rate", "Frames skip per refresh:", &val, dclc_prcmapwin_refresh, 4, 0, 0, 1000)) {
|
|
dclc_prcmapwin_refresh = val;
|
|
}
|
|
set_emumode(EMUMODE_RESTORE, 1);
|
|
}
|
|
}
|
|
|
|
static gint PRCMapWindow_delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
|
|
{
|
|
gtk_widget_hide(GTK_WIDGET(PRCMapWindow));
|
|
return TRUE;
|
|
}
|
|
|
|
static gboolean PRCMapWindow_state_event(GtkWidget *widget, GdkEventWindowState *event, gpointer user_data)
|
|
{
|
|
if (event->changed_mask & GDK_WINDOW_STATE_ICONIFIED) PRCMapWindow_minimized = event->new_window_state & GDK_WINDOW_STATE_ICONIFIED;
|
|
return TRUE;
|
|
}
|
|
|
|
static GtkItemFactoryEntry PRCMapWindow_MenuItems[] = {
|
|
{ "/_View", NULL, NULL, 0, "<Branch>" },
|
|
{ "/View/Show Visible", NULL, PRCMapW_ShowVisible, 0, "<CheckItem>" },
|
|
{ "/View/Show Grid", NULL, PRCMapW_ShowGrid, 0, "<CheckItem>" },
|
|
{ "/View/Show Negative", NULL, PRCMapW_Negative, 0, "<CheckItem>" },
|
|
{ "/View/Zoom", NULL, NULL, 0, "<Branch>" },
|
|
{ "/View/Zoom/100%", NULL, PRCMapW_Zoom, 1, "<RadioItem>" },
|
|
{ "/View/Zoom/200%", NULL, PRCMapW_Zoom, 2, "/View/Zoom/100%" },
|
|
{ "/View/Zoom/300%", NULL, PRCMapW_Zoom, 3, "/View/Zoom/100%" },
|
|
{ "/View/Zoom/400%", NULL, PRCMapW_Zoom, 4, "/View/Zoom/100%" },
|
|
{ "/View/Zoom/500%", NULL, PRCMapW_Zoom, 5, "/View/Zoom/100%" },
|
|
{ "/View/Zoom/600%", NULL, PRCMapW_Zoom, 6, "/View/Zoom/100%" },
|
|
{ "/View/Zoom/700%", NULL, PRCMapW_Zoom, 7, "/View/Zoom/100%" },
|
|
{ "/View/Zoom/800%", NULL, PRCMapW_Zoom, 8, "/View/Zoom/100%" },
|
|
|
|
{ "/_Debugger", NULL, NULL, 0, "<Branch>" },
|
|
{ "/Debugger/Run full speed", "F5", Menu_Debug_RunFull, 0, "<Item>" },
|
|
{ "/Debugger/Run debug frames (Sound)", "<SHIFT>F5", Menu_Debug_RunDFrameSnd, 0, "<Item>" },
|
|
{ "/Debugger/Run debug frames", "<CTRL>F5", Menu_Debug_RunDFrame, 0, "<Item>" },
|
|
{ "/Debugger/Run debug steps", "<CTRL>F3", Menu_Debug_RunDStep, 0, "<Item>" },
|
|
{ "/Debugger/Single frame", "F4", Menu_Debug_SingleFrame, 0, "<Item>" },
|
|
{ "/Debugger/Single step", "F3", Menu_Debug_SingleStep, 0, "<Item>" },
|
|
{ "/Debugger/Step skip", "<SHIFT>F3", Menu_Debug_StepSkip, 0, "<Item>" },
|
|
{ "/Debugger/Stop", "F2", Menu_Debug_Stop, 0, "<Item>" },
|
|
|
|
{ "/_Refresh", NULL, NULL, 0, "<Branch>" },
|
|
{ "/Refresh/Now!", NULL, PRCMapW_RefreshNow, 0, "<Item>" },
|
|
{ "/Refresh/sep1", NULL, NULL, 0, "<Separator>" },
|
|
{ "/Refresh/100% 72fps", NULL, PRCMapW_Refresh, 0, "<RadioItem>" },
|
|
{ "/Refresh/ 50% 36fps", NULL, PRCMapW_Refresh, 1, "/Refresh/100% 72fps" },
|
|
{ "/Refresh/ 33% 24fps", NULL, PRCMapW_Refresh, 2, "/Refresh/100% 72fps" },
|
|
{ "/Refresh/ 25% 18fps", NULL, PRCMapW_Refresh, 3, "/Refresh/100% 72fps" },
|
|
{ "/Refresh/ 17% 12fps", NULL, PRCMapW_Refresh, 5, "/Refresh/100% 72fps" },
|
|
{ "/Refresh/ 12% 9fps", NULL, PRCMapW_Refresh, 7, "/Refresh/100% 72fps" },
|
|
{ "/Refresh/ 8% 6fps", NULL, PRCMapW_Refresh, 11, "/Refresh/100% 72fps" },
|
|
{ "/Refresh/ 3% 2fps", NULL, PRCMapW_Refresh, 35, "/Refresh/100% 72fps" },
|
|
{ "/Refresh/ 1% 1fps", NULL, PRCMapW_Refresh, 71, "/Refresh/100% 72fps" },
|
|
{ "/Refresh/Custom...", NULL, PRCMapW_Refresh, -1, "/Refresh/100% 72fps" },
|
|
};
|
|
static gint PRCMapWindow_MenuItemsNum = sizeof(PRCMapWindow_MenuItems) / sizeof(*PRCMapWindow_MenuItems);
|
|
|
|
// --------------
|
|
// PRC Map Window
|
|
// --------------
|
|
|
|
int PRCMapWindow_Create(void)
|
|
{
|
|
// Window
|
|
PRCMapWindow = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
|
|
gtk_window_set_title(GTK_WINDOW(PRCMapWindow), "PRC Map View");
|
|
gtk_widget_set_size_request(GTK_WIDGET(PRCMapWindow), 200, 100);
|
|
gtk_window_set_default_size(PRCMapWindow, 420, 200);
|
|
g_signal_connect(PRCMapWindow, "delete_event", G_CALLBACK(PRCMapWindow_delete_event), NULL);
|
|
g_signal_connect(PRCMapWindow, "window-state-event", G_CALLBACK(PRCMapWindow_state_event), NULL);
|
|
VBox1 = GTK_BOX(gtk_vbox_new(FALSE, 0));
|
|
gtk_container_add(GTK_CONTAINER(PRCMapWindow), GTK_WIDGET(VBox1));
|
|
gtk_widget_show(GTK_WIDGET(VBox1));
|
|
|
|
// Menu bar
|
|
AccelGroup = gtk_accel_group_new();
|
|
ItemFactory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", AccelGroup);
|
|
gtk_item_factory_create_items(ItemFactory, PRCMapWindow_MenuItemsNum, PRCMapWindow_MenuItems, NULL);
|
|
gtk_window_add_accel_group(PRCMapWindow, AccelGroup);
|
|
MenuBar = GTK_MENU_BAR(gtk_item_factory_get_widget(ItemFactory, "<main>"));
|
|
gtk_box_pack_start(VBox1, GTK_WIDGET(MenuBar), FALSE, TRUE, 0);
|
|
gtk_widget_show(GTK_WIDGET(MenuBar));
|
|
|
|
// Label that warn when running full speed
|
|
LabelRunFull = GTK_LABEL(gtk_label_new("To view content you must stop emulation or run in debug frames/steps."));
|
|
gtk_box_pack_start(VBox1, GTK_WIDGET(LabelRunFull), FALSE, TRUE, 0);
|
|
|
|
// Info label
|
|
LabelInfo = GTK_LABEL(gtk_label_new("-:-"));
|
|
gtk_box_pack_start(VBox1, GTK_WIDGET(LabelInfo), FALSE, TRUE, 0);
|
|
gtk_widget_show(GTK_WIDGET(LabelInfo));
|
|
|
|
// PRC Map View
|
|
PRCMapView.on_imgresize = SGtkXDVCB(PRCMapView_imgresize);
|
|
PRCMapView.on_exposure = SGtkXDVCB(PRCMapView_exposure);
|
|
PRCMapView.on_motion = SGtkXDVCB(PRCMapView_motion);
|
|
PRCMapView.on_enterleave = SGtkXDVCB(AnyView_enterleave);
|
|
sgtkx_drawing_view_new(&PRCMapView, 0);
|
|
gtk_widget_set_size_request(GTK_WIDGET(PRCMapView.box), 64, 64);
|
|
gtk_box_pack_start(VBox1, GTK_WIDGET(PRCMapView.box), TRUE, TRUE, 0);
|
|
gtk_widget_show(GTK_WIDGET(PRCMapView.box));
|
|
|
|
// Map position label
|
|
MapPosInfo = GTK_LABEL(gtk_label_new("Map X=($00, 0) -:- Map Y=($00, 0)"));
|
|
gtk_box_pack_start(VBox1, GTK_WIDGET(MapPosInfo), FALSE, TRUE, 0);
|
|
gtk_widget_show(GTK_WIDGET(MapPosInfo));
|
|
|
|
return 1;
|
|
}
|
|
|
|
void PRCMapWindow_Destroy(void)
|
|
{
|
|
int x, y, width, height;
|
|
if (gtk_widget_get_realized(GTK_WIDGET(PRCMapWindow))) {
|
|
gtk_widget_show(GTK_WIDGET(PRCMapWindow));
|
|
gtk_window_deiconify(PRCMapWindow);
|
|
gtk_window_get_position(PRCMapWindow, &x, &y);
|
|
gtk_window_get_size(PRCMapWindow, &width, &height);
|
|
dclc_prcmapwin_winx = x;
|
|
dclc_prcmapwin_winy = y;
|
|
dclc_prcmapwin_winw = width;
|
|
dclc_prcmapwin_winh = height;
|
|
}
|
|
}
|
|
|
|
void PRCMapWindow_Activate(void)
|
|
{
|
|
gtk_widget_realize(GTK_WIDGET(PRCMapWindow));
|
|
if ((dclc_prcmapwin_winx > -15) && (dclc_prcmapwin_winy > -16)) {
|
|
gtk_window_move(PRCMapWindow, dclc_prcmapwin_winx, dclc_prcmapwin_winy);
|
|
}
|
|
if ((dclc_prcmapwin_winw > 0) && (dclc_prcmapwin_winh > 0)) {
|
|
gtk_window_resize(PRCMapWindow, dclc_prcmapwin_winw, dclc_prcmapwin_winh);
|
|
}
|
|
gtk_widget_show(GTK_WIDGET(PRCMapWindow));
|
|
gtk_window_present(PRCMapWindow);
|
|
}
|
|
|
|
void PRCMapWindow_UpdateConfigs(void)
|
|
{
|
|
GtkWidget *widg;
|
|
|
|
PRCMapWindow_InConfigs = 1;
|
|
|
|
widg = gtk_item_factory_get_item(ItemFactory, "/View/Show Visible");
|
|
if (ShowVisible) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widg), 1);
|
|
widg = gtk_item_factory_get_item(ItemFactory, "/View/Show Grid");
|
|
if (ShowGrid) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widg), 1);
|
|
widg = gtk_item_factory_get_item(ItemFactory, "/View/Show Negative");
|
|
if (Negative) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widg), 1);
|
|
|
|
widg = gtk_item_factory_get_item(ItemFactory, "/View/Zoom/100%");
|
|
if (dclc_zoom_prcmap == 1) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widg), 1);
|
|
widg = gtk_item_factory_get_item(ItemFactory, "/View/Zoom/200%");
|
|
if (dclc_zoom_prcmap == 2) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widg), 1);
|
|
widg = gtk_item_factory_get_item(ItemFactory, "/View/Zoom/300%");
|
|
if (dclc_zoom_prcmap == 3) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widg), 1);
|
|
widg = gtk_item_factory_get_item(ItemFactory, "/View/Zoom/400%");
|
|
if (dclc_zoom_prcmap == 4) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widg), 1);
|
|
widg = gtk_item_factory_get_item(ItemFactory, "/View/Zoom/500%");
|
|
if (dclc_zoom_prcmap == 5) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widg), 1);
|
|
widg = gtk_item_factory_get_item(ItemFactory, "/View/Zoom/600%");
|
|
if (dclc_zoom_prcmap == 6) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widg), 1);
|
|
widg = gtk_item_factory_get_item(ItemFactory, "/View/Zoom/700%");
|
|
if (dclc_zoom_prcmap == 7) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widg), 1);
|
|
widg = gtk_item_factory_get_item(ItemFactory, "/View/Zoom/800%");
|
|
if (dclc_zoom_prcmap == 8) gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(widg), 1);
|
|
|
|
switch (dclc_prcmapwin_refresh) {
|
|
case 0: gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(ItemFactory, "/Refresh/100% 72fps")), 1);
|
|
break;
|
|
case 1: gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(ItemFactory, "/Refresh/ 50% 36fps")), 1);
|
|
break;
|
|
case 2: gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(ItemFactory, "/Refresh/ 33% 24fps")), 1);
|
|
break;
|
|
case 3: gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(ItemFactory, "/Refresh/ 25% 18fps")), 1);
|
|
break;
|
|
case 5: gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(ItemFactory, "/Refresh/ 17% 12fps")), 1);
|
|
break;
|
|
case 7: gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(ItemFactory, "/Refresh/ 12% 9fps")), 1);
|
|
break;
|
|
case 11: gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(ItemFactory, "/Refresh/ 8% 6fps")), 1);
|
|
break;
|
|
case 19: gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(ItemFactory, "/Refresh/ 6% 3fps")), 1);
|
|
break;
|
|
default: gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(gtk_item_factory_get_item(ItemFactory, "/Refresh/Custom...")), 1);
|
|
break;
|
|
}
|
|
|
|
PRCMapWindow_InConfigs = 0;
|
|
}
|
|
|
|
void PRCMapWindow_Sensitive(int enabled)
|
|
{
|
|
if (enabled) {
|
|
gtk_widget_hide(GTK_WIDGET(LabelRunFull));
|
|
gtk_widget_show(GTK_WIDGET(PRCMapView.box));
|
|
gtk_widget_show(GTK_WIDGET(LabelInfo));
|
|
gtk_widget_show(GTK_WIDGET(MapPosInfo));
|
|
} else {
|
|
gtk_widget_show(GTK_WIDGET(LabelRunFull));
|
|
gtk_widget_hide(GTK_WIDGET(PRCMapView.box));
|
|
gtk_widget_hide(GTK_WIDGET(LabelInfo));
|
|
gtk_widget_hide(GTK_WIDGET(MapPosInfo));
|
|
}
|
|
}
|
|
|
|
void PRCMapWindow_Refresh(int now)
|
|
{
|
|
static int refreshcnt = 0;
|
|
if ((refreshcnt <= 0) || (now)) {
|
|
refreshcnt = dclc_prcmapwin_refresh;
|
|
if (!now) {
|
|
if (!gtk_widget_get_visible(GTK_WIDGET(PRCMapWindow)) || PRCMapWindow_minimized) return;
|
|
}
|
|
sgtkx_drawing_view_refresh(&PRCMapView);
|
|
} else refreshcnt--;
|
|
}
|