Celestia: src/celestia/gtk/dialog-solar.cpp Source File

00001 /*
00002  *  Celestia GTK+ Front-End
00003  *  Copyright (C) 2005 Pat Suwalski <pat@suwalski.net>
00004  *
00005  *  This program is free software; you can redistribute it and/or modify
00006  *  it under the terms of the GNU General Public License as published by
00007  *  the Free Software Foundation; either version 2 of the License, or
00008  *  (at your option) any later version.
00009  *
00010  *  $Id: dialog-solar.cpp,v 1.2 2005/12/13 06:19:57 suwalski Exp $
00011  */
00012 
00013 #include <gtk/gtk.h>
00014 
00015 #include <celengine/body.h>
00016 #include <celengine/selection.h>
00017 #include <celengine/simulation.h>
00018 #include <celengine/solarsys.h>
00019 #include <celengine/star.h>
00020 #include <celengine/stardb.h>
00021 
00022 #include "dialog-solar.h"
00023 #include "actions.h"
00024 #include "common.h"
00025 
00026 
00027 /* Declarations: Callbacks */
00028 static void treeSolarSelect(GtkTreeSelection* sel, AppData* app);
00029 
00030 /* Declarations: Helpers */
00031 static void addPlanetarySystemToTree(const PlanetarySystem* sys,
00032                                      GtkTreeStore* solarTreeStore,
00033                                      GtkTreeIter* parent);
00034 static void loadNearestStarSystem(AppData* data, GtkWidget* solarTree,
00035                                   GtkTreeStore* solarTreeStore);
00036 
00037 
00038 /* ENTRY: Navigation -> Solar System Browser... */
00039 void dialogSolarBrowser(AppData* app)
00040 {
00041         GtkWidget *solarTree = NULL;
00042         GtkTreeStore *solarTreeStore = NULL;
00043         
00044         GtkWidget *browser = gtk_dialog_new_with_buttons("Solar System Browser",
00045                                                          GTK_WINDOW(app->mainWindow),
00046                                                          GTK_DIALOG_DESTROY_WITH_PARENT,
00047                                                          GTK_STOCK_CLOSE,
00048                                                          GTK_RESPONSE_CLOSE,
00049                                                          NULL);
00050         app->simulation->setSelection(Selection((Star *) NULL));
00051  
00052         /* Solar System Browser */
00053         GtkWidget *mainbox = gtk_vbox_new(FALSE, CELSPACING);
00054         gtk_container_set_border_width(GTK_CONTAINER(mainbox), CELSPACING);
00055         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(browser)->vbox), mainbox, TRUE, TRUE, 0);
00056         
00057         GtkWidget *scrolled_win = gtk_scrolled_window_new (NULL, NULL);
00058 
00059         gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
00060                                         GTK_POLICY_AUTOMATIC,
00061                                         GTK_POLICY_ALWAYS);
00062         gtk_box_pack_start(GTK_BOX(mainbox), scrolled_win, TRUE, TRUE, 0);
00063 
00064         /* Set the tree store to have 2 visible cols, two hidden. The hidden ones
00065          * store pointer to the row's object and its Selection::Type. */
00066         solarTreeStore = gtk_tree_store_new(4, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_INT);
00067         solarTree = gtk_tree_view_new_with_model(GTK_TREE_MODEL(solarTreeStore));
00068 
00069         gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(solarTree), TRUE);
00070         gtk_container_add(GTK_CONTAINER(scrolled_win), solarTree);
00071 
00072         GtkCellRenderer *renderer;
00073         GtkTreeViewColumn *column;
00074 
00075         for (int i = 0; i < 2; i++) {
00076                 renderer = gtk_cell_renderer_text_new();
00077                 column = gtk_tree_view_column_new_with_attributes (ssTitles[i], renderer, "text", i, NULL);
00078                 gtk_tree_view_append_column(GTK_TREE_VIEW(solarTree), column);
00079                 gtk_tree_view_column_set_min_width(column, 200);
00080         }
00081                                                                                                                                                                                          
00082         loadNearestStarSystem(app, solarTree, solarTreeStore);
00083 
00084         GtkTreeSelection *selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(solarTree));
00085         g_signal_connect(selection, "changed", G_CALLBACK(treeSolarSelect), app);
00086 
00087         /* Common Buttons */
00088         GtkWidget *hbox = gtk_hbox_new(TRUE, CELSPACING);
00089         if (buttonMake(hbox, "Center", (GtkSignalFunc)actionCenterSelection, app))
00090                 return;
00091         if (buttonMake(hbox, "Go To", (GtkSignalFunc)actionGotoSelection, app))
00092                 return;
00093         gtk_box_pack_start(GTK_BOX(mainbox), hbox, FALSE, FALSE, 0);
00094         
00095         g_signal_connect(browser, "response", G_CALLBACK(gtk_widget_destroy), browser);
00096 
00097         gtk_widget_set_usize(browser, 500, 400); /* Absolute Size, urghhh */
00098         gtk_widget_show_all(browser);
00099 }
00100 
00101 
00102 /* CALLBACK: When Object is selected in Solar System Browser */
00103 static void treeSolarSelect(GtkTreeSelection* sel, AppData* app)
00104 {
00105         gpointer item;
00106         gint type;
00107         
00108         GValue value = { 0, 0 }; /* Initialize empty GValue */
00109         GtkTreeIter iter;
00110         GtkTreeModel* model;
00111         
00112         gtk_tree_selection_get_selected(sel, &model, &iter);
00113 
00114         /* Retrieve the item (Body/Star) */
00115         gtk_tree_model_get_value(model, &iter, 2, &value);
00116         item = g_value_get_pointer(&value);
00117         g_value_unset(&value);
00118         
00119         /* Retrieve if isStar */
00120         gtk_tree_model_get_value(model, &iter, 3, &value);
00121         type = g_value_get_int(&value);
00122         g_value_unset(&value);
00123         
00124         if (type == Selection::Type_Star)
00125                 app->simulation->setSelection(Selection((Star *)item));
00126         else if (type == Selection::Type_Body)
00127                 app->simulation->setSelection(Selection((Body *)item));
00128         else
00129                 g_warning("Unexpected selection type selected.");
00130 }
00131 
00132 
00133 /* HELPER: Recursively populate GtkTreeView with objects in PlanetarySystem */
00134 static void addPlanetarySystemToTree(const PlanetarySystem* sys, GtkTreeStore* solarTreeStore, GtkTreeIter* parent)
00135 {
00136         const char *name;
00137         const char *type;
00138         
00139         Body* world;
00140         const PlanetarySystem* satellites;
00141         GtkTreeIter child;
00142         
00143         for (int i = 0; i < sys->getSystemSize(); i++)
00144         {
00145                 world = sys->getBody(i);
00146                 name = g_strdup(world->getName().c_str());
00147                 
00148                 switch(world->getClassification())
00149                 {
00150                         case Body::Planet:
00151                                 type = "Planet";
00152                                 break;
00153                         case Body::Moon:
00154                                 type = "Moon";
00155                                 break;
00156                         case Body::Asteroid:
00157                                 type = "Asteroid";
00158                                 break;
00159                         case Body::Comet:
00160                                 type = "Comet";
00161                                 break;
00162                         case Body::Spacecraft:
00163                                 type = "Spacecraft";
00164                                 break;
00165                         case Body::Unknown:
00166                         default:
00167                                 type = "-";
00168                                 break;
00169                 }
00170 
00171                 satellites = world->getSatellites();
00172 
00173                 /* Add child */
00174                 gtk_tree_store_append(solarTreeStore, &child, parent);
00175                 gtk_tree_store_set(solarTreeStore, &child,
00176                                    0, name,
00177                                    1, type,
00178                                    2, (gpointer)world,
00179                                    3, Selection::Type_Body, /* not Star */
00180                                    -1);
00181 
00182                 /* Recurse */
00183                 if (satellites != NULL)
00184                         addPlanetarySystemToTree(satellites, solarTreeStore, &child);
00185         }
00186 }
00187 
00188 
00189 /* HELPER: Retrieves closest system and calls addPlanetarySystemToTree to
00190  *         populate. */
00191 static void loadNearestStarSystem(AppData* app, GtkWidget* solarTree, GtkTreeStore* solarTreeStore)
00192 {
00193         const char* name;
00194         char type[30];
00195         
00196         const Star* nearestStar;
00197         
00198         const SolarSystem* solarSys = app->simulation->getNearestSolarSystem();
00199         StarDatabase *stardb = app->simulation->getUniverse()->getStarCatalog();
00200         g_assert(stardb);
00201 
00202         GtkTreeIter top;
00203         gtk_tree_store_clear(solarTreeStore);
00204         gtk_tree_store_append(solarTreeStore, &top, NULL);
00205 
00206         if (solarSys != NULL)
00207         {
00208                 nearestStar = solarSys->getStar();
00209 
00210                 name = g_strdup(stardb->getStarName(*nearestStar).c_str());
00211 
00212                 sprintf(type, "%s Star", nearestStar->getSpectralType());
00213         
00214                 /* Set up the top-level node. */
00215                 gtk_tree_store_set(solarTreeStore, &top,
00216                                    0, name,
00217                                    1, &type,
00218                                    2, (gpointer)nearestStar,
00219                                    3, Selection::Type_Star, /* Is Star */
00220                                    -1);
00221 
00222                 const PlanetarySystem* planets = solarSys->getPlanets();
00223                 if (planets != NULL)
00224                         addPlanetarySystemToTree(planets, solarTreeStore, &top);
00225 
00226                 /* Open up the top node */
00227                 GtkTreePath* path = gtk_tree_model_get_path(GTK_TREE_MODEL(solarTreeStore), &top);
00228                 gtk_tree_view_expand_row(GTK_TREE_VIEW(solarTree), path, FALSE);
00229         }
00230         else
00231                 gtk_tree_store_set(solarTreeStore, &top, 0, "No Planetary Bodies", -1);
00232 }