actions.cpp

来自「celestia源代码」· C++ 代码 · 共 1,258 行 · 第 1/3 页

/*
 *  Celestia GTK+ Front-End
 *  Copyright (C) 2005 Pat Suwalski <[e-mail]>
 *
 *  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 2 of the License, or
 *  (at your option) any later version.
 *
 *  $Id: actions.cpp,v 1.12 2006/01/22 17:59:51 suwalski Exp $
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif /* HAVE_CONFIG_H */

#include <cstring>
#include <fstream>
#include <gtk/gtk.h>

#ifdef GNOME
#include <gconf/gconf-client.h>
#endif /* GNOME */

#include <celengine/body.h>
#include <celengine/gl.h>
#include <celengine/glext.h>
#include <celengine/simulation.h>
#include <celengine/cmdparser.h>
#include <celengine/render.h>
#include <celestia/celestiacore.h>
#include <celestia/imagecapture.h>
#include <celestia/url.h>
#include <celutil/filetype.h>

#include "actions.h"
#include "common.h"
#include "dialog-eclipse.h"
#include "dialog-goto.h"
#include "dialog-options.h"
#include "dialog-solar.h"
#include "dialog-star.h"
#include "dialog-time.h"
#include "dialog-tour.h"

#ifdef GNOME
#include "settings-gconf.h"
#else
#include "settings-file.h"
#endif /* GNOME */


/* Declarations: Action Helpers */
static void openScript(const char* filename, AppData* app);
static void captureImage(const char* filename, AppData* app);
static void textInfoDialog(const char *txt, const char *title, AppData* app);
static void setRenderFlag(AppData* a, int flag, gboolean state);
static void setOrbitMask(AppData* a, int mask, gboolean state);
static void setLabelMode(AppData* a, int mode, gboolean state);


/* File -> Copy URL */
void actionCopyURL(GtkAction*, AppData* app)
{
	GtkClipboard* cb = gtk_clipboard_get(GDK_SELECTION_CLIPBOARD);
	Url url(app->core);
	gtk_clipboard_set_text(cb, url.getAsString().c_str(), -1);
}


/* File -> Open URL */
void actionOpenURL(GtkAction*, AppData* app)
{
	GtkWidget* dialog = gtk_dialog_new_with_buttons("Enter cel:// URL",
	                                                GTK_WINDOW(app->mainWindow),
	                                                GTK_DIALOG_MODAL,
	                                                GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
	                                                GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
	                                                NULL);

	/* Create a new entry box with default text, all selected */
	GtkWidget* entry = gtk_entry_new();
	gtk_entry_set_width_chars(GTK_ENTRY(entry), 80);
	gtk_entry_set_text(GTK_ENTRY(entry), "cel://");
	gtk_editable_select_region(GTK_EDITABLE(entry), 0, -1);

	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), entry, TRUE, TRUE, CELSPACING);
	gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
	gtk_widget_show_all(dialog);

	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
		app->core->goToUrl(gtk_entry_get_text(GTK_ENTRY(entry)));

	gtk_widget_destroy(dialog);
}


/* File -> Open Script... */
void actionOpenScript(GtkAction*, AppData* app)
{
	GtkWidget* fs = gtk_file_chooser_dialog_new("Open Script.",
	                                            GTK_WINDOW(app->mainWindow),
	                                            GTK_FILE_CHOOSER_ACTION_OPEN,
	                                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
	                                            GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
	                                            NULL);

	#if GTK_CHECK_VERSION(2, 7, 0)
	gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(fs), TRUE);
	#endif /* GTK_CHECK_VERSION */

	gtk_dialog_set_default_response(GTK_DIALOG(fs), GTK_RESPONSE_ACCEPT);
	gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fs), g_get_home_dir());

	GtkFileFilter* filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, "Celestia Scripts");
	
	gtk_file_filter_add_pattern(filter, "*.cel");

	#ifdef CELX
	gtk_file_filter_add_pattern(filter, "*.celx");
	gtk_file_filter_add_pattern(filter, "*.clx");
	#endif /* CELX */
	
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fs), filter);
	
	if (gtk_dialog_run(GTK_DIALOG(fs)) == GTK_RESPONSE_ACCEPT)
	{
		char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fs));
		openScript(filename, app);
		g_free(filename);
	}

	gtk_widget_destroy(fs);	
}


/* File -> Capture Image... */
void actionCaptureImage(GtkAction*, AppData* app)
{
	GtkWidget* fs = gtk_file_chooser_dialog_new("Save Image to File",
	                                            GTK_WINDOW(app->mainWindow),
	                                            GTK_FILE_CHOOSER_ACTION_SAVE,
	                                            GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
	                                            GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
	                                            NULL);

	GtkFileFilter* filter = gtk_file_filter_new();
	gtk_file_filter_set_name(filter, "PNG and JPEG Images");
	gtk_file_filter_add_pattern(filter, "*.jpeg");
	gtk_file_filter_add_pattern(filter, "*.jpg");
	gtk_file_filter_add_pattern(filter, "*.png");
	gtk_file_chooser_add_filter(GTK_FILE_CHOOSER(fs), filter);

	#if GTK_CHECK_VERSION(2, 7, 0)
	gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(fs), TRUE);
	#endif /* GTK_CHECK_VERSION */
	
	gtk_dialog_set_default_response(GTK_DIALOG(fs), GTK_RESPONSE_ACCEPT);
	gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fs), g_get_home_dir());

	if (gtk_dialog_run(GTK_DIALOG(fs)) == GTK_RESPONSE_ACCEPT)
	{
		char* filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(fs));
		captureImage(filename, app);
		g_free(filename);
	}

	gtk_widget_destroy(fs);
}


void actionQuit(GtkAction*, AppData* app)
{
	#ifdef GNOME
	saveSettingsGConf(app);
	#else
	saveSettingsFile(app);
	#endif /* GNOME */

	gtk_main_quit();
}


void actionSelectSol(GtkAction*, AppData* app)
{
	app->core->charEntered('H');
}


void actionTourGuide(GtkAction*, AppData* app)
{
	dialogTourGuide(app);
}


void actionSearchObject(GtkAction*, AppData* app)
{
	GtkWidget* dialog = gtk_dialog_new_with_buttons("Select Object",
	                                                GTK_WINDOW(app->mainWindow),
	                                                GTK_DIALOG_DESTROY_WITH_PARENT,
	                                                GTK_STOCK_OK, GTK_RESPONSE_OK,
	                                                GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
	                                                NULL);

	GtkWidget* box = gtk_hbox_new(FALSE, CELSPACING);
	gtk_container_set_border_width(GTK_CONTAINER(box), CELSPACING);
	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), box, TRUE, TRUE, 0);

	GtkWidget* label = gtk_label_new("Object name");
	gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);

	GtkWidget* entry = gtk_entry_new();
	gtk_box_pack_start(GTK_BOX(box), entry, TRUE, TRUE, 0);

	gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
	gtk_widget_show_all(GTK_WIDGET(dialog));

	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
	{
		const gchar* name = gtk_entry_get_text(GTK_ENTRY(entry));
		if (name != NULL)
		{
			Selection sel = app->simulation->findObject(name);
			if (!sel.empty())
				app->simulation->setSelection(sel);
		}
	}

	gtk_widget_destroy(GTK_WIDGET(dialog));
}


void actionGotoObject(GtkAction*, AppData* app)
{
	dialogGotoObject(app);
}


void actionCenterSelection(GtkAction*, AppData* app)
{
	app->core->charEntered('c');
}


void actionGotoSelection(GtkAction*, AppData* app)
{
	app->core->charEntered('G');
}


void actionFollowSelection(GtkAction*, AppData* app)
{
	app->core->charEntered('F');
}


void actionSyncSelection(GtkAction*, AppData* app)
{
	app->core->charEntered('Y');
}


void actionTrackSelection(GtkAction*, AppData* app)
{
	app->core->charEntered('T');
}


void actionSystemBrowser(GtkAction*, AppData* app)
{
	dialogSolarBrowser(app);
}


void actionStarBrowser(GtkAction*, AppData* app)
{
	dialogStarBrowser(app);
}


void actionEclipseFinder(GtkAction*, AppData* app)
{
	dialogEclipseFinder(app);
}


void actionTimeFaster(GtkAction*, AppData* app)
{
	app->core->charEntered('L');
}


void actionTimeSlower(GtkAction*, AppData* app)
{
	app->core->charEntered('K');
}


void actionTimeFreeze(GtkAction*, AppData* app)
{
	app->core->charEntered(' ');
}


void actionTimeReal(GtkAction*, AppData* app)
{
	app->core->charEntered('\\');
}


void actionTimeReverse(GtkAction*, AppData* app)
{
	app->core->charEntered('J');
}


void actionTimeSet(GtkAction*, AppData* app)
{
	dialogSetTime(app);
}


void actionTimeLocal(GtkAction* action, AppData* app)
{
	app->showLocalTime = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action));
	updateTimeZone(app, app->showLocalTime);

	#ifdef GNOME
	gconf_client_set_bool(app->client, "/apps/celestia/showLocalTime", app->showLocalTime, NULL);
	#endif /* GNOME */
}


void actionViewerSize(GtkAction*, AppData* app)
{
	GtkWidget* dialog;
	int newX, currentX, currentY, winX, winY, screenX, i = 1, position = -1;
	char res[32];
	
	screenX = gdk_screen_get_width(gdk_screen_get_default());
	currentX = app->glArea->allocation.width;
	currentY = app->glArea->allocation.height;

	dialog = gtk_dialog_new_with_buttons("Set Viewer Size...",
	                                     GTK_WINDOW(app->mainWindow),
	                                     GTK_DIALOG_DESTROY_WITH_PARENT,
	                                     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
	                                     GTK_STOCK_OK, GTK_RESPONSE_OK,
	                                     NULL);

	GtkWidget* vbox = gtk_vbox_new(FALSE, CELSPACING); 
	gtk_container_set_border_width(GTK_CONTAINER(vbox), CELSPACING);

	GtkWidget* label = gtk_label_new("Dimensions for Main Window:");
	gtk_box_pack_start(GTK_BOX(vbox), label, TRUE, TRUE, 0);

	GtkWidget* menubox = gtk_combo_box_new_text();
	gtk_box_pack_start(GTK_BOX(vbox), menubox, FALSE, FALSE, 0);

	gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), vbox, TRUE, TRUE, 0);

	while (resolutions[i] != -1)
	{
		if (position == -1 && resolutions[i-1] < currentX && resolutions[i] >= currentX)
		{
			sprintf(res, "%d x %d (current)", currentX, currentY);
			position = i - 1;
		}
		else if (resolutions[i] < screenX)
		{
			sprintf(res, "%d x %d", resolutions[i], int(0.75 * resolutions[i]));
			i++;
		}
		else
			break;
		
		gtk_combo_box_append_text(GTK_COMBO_BOX(menubox), res);
	}

	gtk_combo_box_set_active(GTK_COMBO_BOX(menubox), position);

	gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
	gtk_widget_show_all(dialog);

	if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_OK)
	{
		int active = gtk_combo_box_get_active(GTK_COMBO_BOX(menubox));

		if (active > -1 && active != position)
		{
			/* Adjust for default entry */
			if (active > position) active--;

			newX = resolutions[active + 1];
			gtk_window_get_size(GTK_WINDOW(app->mainWindow), &winX, &winY);
			
			/* Resizing takes into account border, titlebar, and menubar
			   sizes. Without them only an allocation can be requested */
			gtk_window_resize(GTK_WINDOW(app->mainWindow), newX + winX - currentX, int(0.75 * newX) + winY - currentY);
		}
	}
	
	gtk_widget_destroy(GTK_WIDGET(dialog));
}


void actionFullScreen(GtkAction* action, AppData* app)
{
	int positionX, positionY;
	app->fullScreen = gtk_toggle_action_get_active(GTK_TOGGLE_ACTION(action));
	
	if (app->fullScreen)
	{
		/* Save size/position, so original numbers are available for prefs */
		g_object_set_data(G_OBJECT(app->mainWindow), "sizeX", GINT_TO_POINTER(app->glArea->allocation.width));
		g_object_set_data(G_OBJECT(app->mainWindow), "sizeY", GINT_TO_POINTER(app->glArea->allocation.height));
		gtk_window_get_position(GTK_WINDOW(app->mainWindow), &positionX, &positionY);
		g_object_set_data(G_OBJECT(app->mainWindow), "positionX", GINT_TO_POINTER(positionX));
		g_object_set_data(G_OBJECT(app->mainWindow), "positionY", GINT_TO_POINTER(positionY));