spacecruft
/
celestia
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

[gtk] Replace deprecated API with Gtk3 compatible

pull/949/head
Hleb Valoshka 2018-12-02 00:03:06 +03:00
parent 3de6707b0c
commit b43f2abe24
14 changed files with 227 additions and 243 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

49
src/celestia/gtk/actions.cpp
View File

@ -90,7 +90,8 @@ void actionOpenURL(GtkAction*, AppData* app)
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);
GtkWidget* content_area = gtk_dialog_get_content_area(GTK_DIALOG (dialog));
gtk_box_pack_start(GTK_BOX(content_area), entry, TRUE, TRUE, CELSPACING);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
gtk_widget_show_all(dialog);
@ -225,11 +226,11 @@ void actionCaptureMovie(GtkAction*, AppData* app)
GtkWidget* rlabel = gtk_label_new("Aspect Ratio:");
gtk_box_pack_start(GTK_BOX(hbox), rlabel, TRUE, TRUE, 0);
GtkWidget* aspectmenubox = gtk_combo_box_new_text();
gtk_combo_box_append_text(GTK_COMBO_BOX(aspectmenubox), "1:1");
gtk_combo_box_append_text(GTK_COMBO_BOX(aspectmenubox), "4:3");
gtk_combo_box_append_text(GTK_COMBO_BOX(aspectmenubox), "16:9");
gtk_combo_box_append_text(GTK_COMBO_BOX(aspectmenubox), "Display");
GtkWidget* aspectmenubox = gtk_combo_box_text_new();
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(aspectmenubox), "1:1");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(aspectmenubox), "4:3");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(aspectmenubox), "16:9");
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(aspectmenubox), "Display");
gtk_combo_box_set_active(GTK_COMBO_BOX(aspectmenubox), 0);
gtk_box_pack_start(GTK_BOX(hbox), aspectmenubox, FALSE, FALSE, 0);
@ -315,7 +316,8 @@ void actionSearchObject(GtkAction*, AppData* app)
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* content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_box_pack_start(GTK_BOX(content_area), box, TRUE, TRUE, 0);
GtkWidget* label = gtk_label_new("Object name");
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
@ -449,8 +451,10 @@ void actionViewerSize(GtkAction*, AppData* app)
char res[32];
screenX = gdk_screen_get_width(gdk_screen_get_default());
currentX = app->glArea->allocation.width;
currentY = app->glArea->allocation.height;
GtkAllocation allocation;
gtk_widget_get_allocation(GTK_WIDGET(app->glArea), &allocation);
currentX = allocation.width;
currentY = allocation.height;
dialog = gtk_dialog_new_with_buttons("Set Viewer Size...",
GTK_WINDOW(app->mainWindow),
@ -459,16 +463,12 @@ void actionViewerSize(GtkAction*, AppData* app)
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* content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_box_pack_start(GTK_BOX(content_area), 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);
GtkWidget* menubox = gtk_combo_box_text_new();
gtk_box_pack_start(GTK_BOX(content_area), menubox, TRUE, TRUE, 0);
while (resolutions[i] != -1)
{
@ -485,7 +485,7 @@ void actionViewerSize(GtkAction*, AppData* app)
else
break;
gtk_combo_box_append_text(GTK_COMBO_BOX(menubox), res);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(menubox), res);
}
gtk_combo_box_set_active(GTK_COMBO_BOX(menubox), position);
@ -523,8 +523,10 @@ void actionFullScreen(GtkAction* action, AppData* app)
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));
GtkAllocation allocation;
gtk_widget_get_allocation(GTK_WIDGET(app->glArea), &allocation);
g_object_set_data(G_OBJECT(app->mainWindow), "sizeX", GINT_TO_POINTER(allocation.width));
g_object_set_data(G_OBJECT(app->mainWindow), "sizeY", GINT_TO_POINTER(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));
@ -1096,9 +1098,10 @@ static void textInfoDialog(const char *txt, const char *title, AppData* app)
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
GtkWidget* scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), scrolled_window, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled_window),
GtkWidget* scrolled_window = gtk_scrolled_window_new(NULL, NULL);
GtkWidget* content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_box_pack_start(GTK_BOX(content_area), scrolled_window, TRUE, TRUE, 0);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_widget_show(scrolled_window);

22
src/celestia/gtk/common.cpp
View File

@ -51,19 +51,19 @@ void updateTimeZone(AppData* app, gboolean local)
/* Creates a button. Used in several dialogs. */
gint buttonMake(GtkWidget *hbox, const char *txt, GtkSignalFunc func, gpointer data)
gint buttonMake(GtkWidget *hbox, const char *txt, GCallback func, gpointer data)
{
GtkWidget* button = gtk_button_new_with_label(txt);
gtk_box_pack_start(GTK_BOX (hbox), button, TRUE, TRUE, 0);
g_signal_connect(GTK_OBJECT(button), "pressed", func, data);
g_signal_connect(G_OBJECT(button), "pressed", func, data);
return 0;
}
/* creates a group of radioButtons. Used in several dialogs. */
void makeRadioItems(const char* const *labels, GtkWidget *box, GtkSignalFunc sigFunc, GtkToggleButton **gads, gpointer data)
void makeRadioItems(const char* const *labels, GtkWidget *box, GCallback sigFunc, GtkToggleButton **gads, gpointer data)
{
GSList *group = NULL;
@ -74,12 +74,12 @@ void makeRadioItems(const char* const *labels, GtkWidget *box, GtkSignalFunc sig
if (gads)
gads[i] = GTK_TOGGLE_BUTTON(button);
group = gtk_radio_button_group(GTK_RADIO_BUTTON(button));
group = gtk_radio_button_get_group(GTK_RADIO_BUTTON(button));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), (i == 0)?1:0);
gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
gtk_widget_show (button);
g_signal_connect(GTK_OBJECT(button), "pressed", sigFunc, GINT_TO_POINTER(i));
g_signal_connect(G_OBJECT(button), "pressed", sigFunc, GINT_TO_POINTER(i));
if (data != NULL)
g_object_set_data(G_OBJECT(button), "data", data);
@ -118,8 +118,10 @@ int getWinWidth(AppData* app)
{
if (app->fullScreen)
return GPOINTER_TO_INT(g_object_get_data(G_OBJECT(app->mainWindow), "sizeX"));
else
return app->glArea->allocation.width;
GtkAllocation allocation;
gtk_widget_get_allocation(GTK_WIDGET(app->glArea), &allocation);
return allocation.width;
}
@ -128,8 +130,10 @@ int getWinHeight(AppData* app)
{
if (app->fullScreen)
return GPOINTER_TO_INT(g_object_get_data(G_OBJECT(app->mainWindow), "sizeY"));
else
return app->glArea->allocation.height;
GtkAllocation allocation;
gtk_widget_get_allocation(GTK_WIDGET(app->glArea), &allocation);
return allocation.height;
}

4
src/celestia/gtk/common.h
View File

@ -74,8 +74,8 @@ struct _AppData {
/* Helper functions used throughout */
gint tzOffsetAtDate(astro::Date date);
void updateTimeZone(AppData* app, gboolean local);
gint buttonMake(GtkWidget *hbox, const char *txt, GtkSignalFunc func, gpointer data);
void makeRadioItems(const char* const *labels, GtkWidget *box, GtkSignalFunc sigFunc, GtkToggleButton **gads, gpointer data);
gint buttonMake(GtkWidget *hbox, const char *txt, GCallback func, gpointer data);
void makeRadioItems(const char* const *labels, GtkWidget *box, GCallback sigFunc, GtkToggleButton **gads, gpointer data);
char* readFromFile(const char *fname);
/* Functions to get window properties regardless of window state */

73
src/celestia/gtk/dialog-eclipse.cpp
View File

@ -30,8 +30,8 @@ static void showCalPopup(GtkToggleButton *button, EclipseData *ed);
static gint eclipseGoto(GtkButton*, EclipseData* ed);
static gint eclipse2Click(GtkWidget*, GdkEventButton* event, EclipseData* ed);
static void eclipseCompute(GtkButton* button, EclipseData* ed);
static void eclipseBodySelect(GtkMenuShell* menu, EclipseData* ed);
static void eclipseTypeSelect(GtkMenuShell* menu, EclipseData* ed);
static void eclipseBodySelect(GtkComboBox* comboBox, EclipseData* ed);
static void eclipseTypeSelect(GtkComboBox* comboBox, EclipseData* ed);
static void listEclipseSelect(GtkTreeSelection* sel, EclipseData* ed);
static void eclipseDestroy(GtkWidget* w, gint, EclipseData* ed);
@ -62,13 +62,12 @@ void dialogEclipseFinder(AppData* app)
NULL));
gtk_window_set_modal(GTK_WINDOW(ed->window), FALSE);
GtkWidget *mainbox = gtk_vbox_new(FALSE, CELSPACING);
GtkWidget *mainbox = gtk_dialog_get_content_area(GTK_DIALOG(ed->window));
gtk_container_set_border_width(GTK_CONTAINER(mainbox), CELSPACING);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(ed->window)->vbox), mainbox, TRUE, TRUE, 0);
GtkWidget *scrolled_win = gtk_scrolled_window_new (NULL, NULL);
GtkWidget *scrolled_win = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled_win),
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(mainbox), scrolled_win, TRUE, TRUE, 0);
@ -101,7 +100,7 @@ void dialogEclipseFinder(AppData* app)
/* Add the columns */
for (int i=0; i<5; i++) {
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes (eclipseTitles[i], renderer, "text", i, NULL);
column = gtk_tree_view_column_new_with_attributes(eclipseTitles[i], renderer, "text", i, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(ed->eclipseList), column);
}
@ -119,13 +118,13 @@ void dialogEclipseFinder(AppData* app)
label = gtk_label_new("Find");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
GtkWidget* menuTypeBox = gtk_option_menu_new();
GtkWidget *menuTypeBox = gtk_combo_box_text_new();
gtk_box_pack_start(GTK_BOX(hbox), menuTypeBox, FALSE, FALSE, 0);
label = gtk_label_new("eclipse on");
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
GtkWidget* menuBodyBox = gtk_option_menu_new();
GtkWidget* menuBodyBox = gtk_combo_box_text_new();
gtk_box_pack_start(GTK_BOX(hbox), menuBodyBox, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(mainbox), hbox, FALSE, FALSE, 0);
@ -166,45 +165,37 @@ void dialogEclipseFinder(AppData* app)
/* Common Buttons */
hbox = gtk_hbox_new(TRUE, CELSPACING);
if (buttonMake(hbox, "Compute", (GtkSignalFunc)eclipseCompute, ed))
if (buttonMake(hbox, "Compute", (GCallback)eclipseCompute, ed))
return;
if (buttonMake(hbox, "Set Date and Go to Planet", (GtkSignalFunc)eclipseGoto, ed))
if (buttonMake(hbox, "Set Date and Go to Planet", (GCallback)eclipseGoto, ed))
return;
gtk_box_pack_start(GTK_BOX(mainbox), hbox, FALSE, FALSE, 0);
/* Set up the drop-down boxes */
GtkWidget *item;
GtkWidget* menuType = gtk_menu_new();
for (int i = 0; eclipseTypeTitles[i] != NULL; i++)
{
item = gtk_menu_item_new_with_label(eclipseTypeTitles[i]);
gtk_menu_append(GTK_MENU(menuType), item);
gtk_widget_show(item);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(menuTypeBox), eclipseTypeTitles[i]);
}
gtk_option_menu_set_menu(GTK_OPTION_MENU(menuTypeBox), menuType);
gtk_combo_box_set_active(GTK_COMBO_BOX(menuTypeBox), 0);
GtkWidget* menuBody = gtk_menu_new();
for (int i = 0; eclipsePlanetTitles[i] != NULL; i++)
{
item = gtk_menu_item_new_with_label(eclipsePlanetTitles[i]);
gtk_menu_append(GTK_MENU(menuBody), item);
gtk_widget_show(item);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(menuBodyBox), eclipsePlanetTitles[i]);
}
gtk_option_menu_set_menu(GTK_OPTION_MENU(menuBodyBox), menuBody);
gtk_combo_box_set_active(GTK_COMBO_BOX(menuBodyBox), 0);
/* Hook up all the signals */
g_signal_connect(GTK_OBJECT(menuType), "selection-done", G_CALLBACK(eclipseTypeSelect), ed);
g_signal_connect(GTK_OBJECT(menuBody), "selection-done", G_CALLBACK(eclipseBodySelect), ed);
g_signal_connect(G_OBJECT(menuTypeBox), "changed", G_CALLBACK(eclipseTypeSelect), ed);
g_signal_connect(G_OBJECT(menuBodyBox), "changed", G_CALLBACK(eclipseBodySelect), ed);
/* Double-click handler */
g_signal_connect(GTK_OBJECT(ed->eclipseList), "button-press-event", G_CALLBACK(eclipse2Click), ed);
g_signal_connect(G_OBJECT(ed->eclipseList), "button-press-event", G_CALLBACK(eclipse2Click), ed);
g_signal_connect(GTK_OBJECT(date1Button), "toggled", G_CALLBACK(showCalPopup), ed);
g_signal_connect(GTK_OBJECT(date2Button), "toggled", G_CALLBACK(showCalPopup), ed);
g_signal_connect(G_OBJECT(date1Button), "toggled", G_CALLBACK(showCalPopup), ed);
g_signal_connect(G_OBJECT(date2Button), "toggled", G_CALLBACK(showCalPopup), ed);
g_signal_connect(ed->window, "response", G_CALLBACK(eclipseDestroy), ed);
gtk_widget_set_usize(GTK_WIDGET(ed->window), 400, 400); /* Absolute Size, urghhh */
gtk_widget_set_size_request(GTK_WIDGET(ed->window), -1, 400); /* Absolute Size, urghhh */
gtk_widget_show_all(GTK_WIDGET(ed->window));
}
@ -261,7 +252,7 @@ static void showCalPopup(GtkToggleButton *button, EclipseData *ed)
gtk_widget_show(calendar);
int x, y, i, j;
gdk_window_get_origin(GDK_WINDOW(GTK_WIDGET(button)->window), &x, &y);
gdk_window_get_origin(gtk_widget_get_window(GTK_WIDGET(button)), &x, &y);
gtk_widget_translate_coordinates(GTK_WIDGET(button), GTK_WIDGET(ed->window), 10, 10, &i, &j);
gtk_window_move(GTK_WINDOW(calwindow), x + i, y + j);
@ -270,7 +261,7 @@ static void showCalPopup(GtkToggleButton *button, EclipseData *ed)
gtk_window_present(GTK_WINDOW(calwindow));
g_object_set_data_full(G_OBJECT (button), "calendar",
g_object_set_data_full(G_OBJECT(button), "calendar",
calwindow, (GDestroyNotify)gtk_widget_destroy);
}
}
@ -280,7 +271,7 @@ static void showCalPopup(GtkToggleButton *button, EclipseData *ed)
if (calwindow)
{
/* Destroys the calendar */
g_object_set_data(G_OBJECT (button), "calendar", NULL);
g_object_set_data(G_OBJECT(button), "calendar", NULL);
calwindow = NULL;
}
}
@ -361,7 +352,7 @@ static void eclipseCompute(GtkButton* button, EclipseData* ed)
GtkTreeIter iter;
/* Set the cursor to a watch and force redraw */
gdk_window_set_cursor(GTK_WIDGET(button)->window, gdk_cursor_new(GDK_WATCH));
gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(button)), gdk_cursor_new(GDK_WATCH));
gtk_main_iteration();
/* Clear the listbox */
@ -427,17 +418,14 @@ static void eclipseCompute(GtkButton* button, EclipseData* ed)
}
/* Set the cursor back */
gdk_window_set_cursor(GTK_WIDGET(button)->window, gdk_cursor_new(GDK_LEFT_PTR));
gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(button)), gdk_cursor_new(GDK_LEFT_PTR));
}
/* CALLBACK: When Eclipse Body is selected */
static void eclipseBodySelect(GtkMenuShell* menu, EclipseData* ed)
static void eclipseBodySelect(GtkComboBox* comboBox, EclipseData* ed)
{
GtkWidget* item = gtk_menu_get_active(GTK_MENU(menu));
GList* list = gtk_container_children(GTK_CONTAINER(menu));
int itemIndex = g_list_index(list, item);
int itemIndex = gtk_combo_box_get_active(comboBox);
/* Set string according to body array */
ed->body = eclipsePlanetTitles[itemIndex];
@ -445,12 +433,9 @@ static void eclipseBodySelect(GtkMenuShell* menu, EclipseData* ed)
/* CALLBACK: When Eclipse Type (Solar:Moon) is selected */
static void eclipseTypeSelect(GtkMenuShell* menu, EclipseData* ed)
static void eclipseTypeSelect(GtkComboBox* comboBox, EclipseData* ed)
{
GtkWidget* item = gtk_menu_get_active(GTK_MENU(menu));
GList* list = gtk_container_children(GTK_CONTAINER(menu));
int itemIndex = g_list_index(list, item);
int itemIndex = gtk_combo_box_get_active(comboBox);
/* Solar eclipse */
if (itemIndex == 0)

5
src/celestia/gtk/dialog-goto.cpp
View File

@ -78,9 +78,8 @@ void dialogGotoObject(AppData* app)
gtk_entry_set_text(GTK_ENTRY(data->nameEntry), (char*) app->simulation->getSelection().body()->getName().c_str());
}
GtkWidget* vbox = gtk_vbox_new(TRUE, CELSPACING);
GtkWidget* vbox = gtk_dialog_get_content_area(GTK_DIALOG(data->dialog));
gtk_container_set_border_width(GTK_CONTAINER(vbox), CELSPACING);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(data->dialog)->vbox), vbox, TRUE, TRUE, 0);
GtkWidget* align = NULL;
GtkWidget* hbox = NULL;
@ -124,7 +123,7 @@ void dialogGotoObject(AppData* app)
/* Distance Options */
data->units = 0;
hbox = gtk_hbox_new(FALSE, CELSPACING);
makeRadioItems(unitLabels, hbox, GTK_SIGNAL_FUNC(changeGotoUnits), NULL, data);
makeRadioItems(unitLabels, hbox, G_CALLBACK(changeGotoUnits), NULL, data);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
g_signal_connect(data->dialog, "response",

43
src/celestia/gtk/dialog-options.cpp
View File

@ -76,22 +76,22 @@ void dialogViewOptions(AppData* app)
GtkWidget* ambientBox = gtk_vbox_new(FALSE, 0);
/* Set border padding on the boxes */
gtk_container_border_width(GTK_CONTAINER(showBox), CELSPACING);
gtk_container_border_width(GTK_CONTAINER(labelBox), CELSPACING);
gtk_container_border_width(GTK_CONTAINER(orbitBox), CELSPACING);
gtk_container_border_width(GTK_CONTAINER(limitBox), CELSPACING);
gtk_container_border_width(GTK_CONTAINER(textureBox), CELSPACING);
gtk_container_border_width(GTK_CONTAINER(ambientBox), CELSPACING);
gtk_container_border_width(GTK_CONTAINER(infoBox), CELSPACING);
gtk_container_set_border_width(GTK_CONTAINER(showBox), CELSPACING);
gtk_container_set_border_width(GTK_CONTAINER(labelBox), CELSPACING);
gtk_container_set_border_width(GTK_CONTAINER(orbitBox), CELSPACING);
gtk_container_set_border_width(GTK_CONTAINER(limitBox), CELSPACING);
gtk_container_set_border_width(GTK_CONTAINER(textureBox), CELSPACING);
gtk_container_set_border_width(GTK_CONTAINER(ambientBox), CELSPACING);
gtk_container_set_border_width(GTK_CONTAINER(infoBox), CELSPACING);
/* Set border padding on the frames */
gtk_container_border_width(GTK_CONTAINER(showFrame), 0);
gtk_container_border_width(GTK_CONTAINER(labelFrame), 0);
gtk_container_border_width(GTK_CONTAINER(orbitFrame), 0);
gtk_container_border_width(GTK_CONTAINER(limitFrame), 0);
gtk_container_border_width(GTK_CONTAINER(textureFrame), 0);
gtk_container_border_width(GTK_CONTAINER(ambientFrame), 0);
gtk_container_border_width(GTK_CONTAINER(infoFrame), 0);
gtk_container_set_border_width(GTK_CONTAINER(showFrame), 0);
gtk_container_set_border_width(GTK_CONTAINER(labelFrame), 0);
gtk_container_set_border_width(GTK_CONTAINER(orbitFrame), 0);
gtk_container_set_border_width(GTK_CONTAINER(limitFrame), 0);
gtk_container_set_border_width(GTK_CONTAINER(textureFrame), 0);
gtk_container_set_border_width(GTK_CONTAINER(ambientFrame), 0);
gtk_container_set_border_width(GTK_CONTAINER(infoFrame), 0);
/* Place the boxes in the frames */
gtk_container_add(GTK_CONTAINER(showFrame), GTK_WIDGET(showBox));
@ -112,8 +112,8 @@ void dialogViewOptions(AppData* app)
gtk_box_pack_start(GTK_BOX(miscBox), infoFrame, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), midBox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), miscBox, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG (app->optionDialog)->vbox), hbox, TRUE,
TRUE, 0);
GtkWidget* content_area = gtk_dialog_get_content_area(GTK_DIALOG(app->optionDialog));
gtk_container_add(GTK_CONTAINER(content_area), hbox);
gtk_container_set_border_width(GTK_CONTAINER(hbox), CELSPACING);
@ -129,7 +129,7 @@ void dialogViewOptions(AppData* app)
gtk_scale_set_draw_value(GTK_SCALE(slider), 0);
gtk_box_pack_start(GTK_BOX(limitBox), slider, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(limitBox), magLabel, TRUE, TRUE, 0);
g_signal_connect(GTK_OBJECT(slider), "value-changed", G_CALLBACK(changeDistanceLimit), app);
g_signal_connect(G_OBJECT(slider), "value-changed", G_CALLBACK(changeDistanceLimit), app);
changeDistanceLimit(GTK_RANGE(GTK_HSCALE(slider)), app);
/* Texture resolution slider */
@ -137,10 +137,9 @@ void dialogViewOptions(AppData* app)
gtk_scale_set_value_pos(GTK_SCALE(textureSlider), GTK_POS_BOTTOM);
gtk_range_set_increments(GTK_RANGE(textureSlider), 1, 1);
gtk_range_set_value(GTK_RANGE(textureSlider), app->renderer->getResolution());
gtk_range_set_update_policy(GTK_RANGE(textureSlider), GTK_UPDATE_DISCONTINUOUS);
gtk_box_pack_start(GTK_BOX(textureBox), textureSlider, TRUE, TRUE, 0);
g_signal_connect(GTK_OBJECT(textureSlider), "value-changed", G_CALLBACK(changeTextureResolution), app);
g_signal_connect(GTK_OBJECT(textureSlider), "format-value", G_CALLBACK(formatTextureSlider), NULL);
g_signal_connect(G_OBJECT(textureSlider), "value-changed", G_CALLBACK(changeTextureResolution), app);
g_signal_connect(G_OBJECT(textureSlider), "format-value", G_CALLBACK(formatTextureSlider), NULL);
checkButtonsFromAG(actionsRenderFlags, G_N_ELEMENTS(actionsRenderFlags), app->agRender, showBox);
checkButtonsFromAG(actionsOrbitFlags, G_N_ELEMENTS(actionsOrbitFlags), app->agOrbit, orbitBox);
@ -213,7 +212,7 @@ static void checkButtonsFromAG(const GtkToggleActionEntry actions[], int size, G
* is not set with action proxy. */
GtkWidget* w = gtk_check_button_new_with_mnemonic(actions[i].label);
gtk_action_connect_proxy(action, w);
gtk_activatable_set_related_action(GTK_ACTIVATABLE(w), action);
gtk_box_pack_start(GTK_BOX(box), w, TRUE, TRUE, 0);
}
}
@ -230,7 +229,7 @@ static void toggleButtonsFromAG(const GtkRadioActionEntry actions[], int size, G
* is not set with action proxy. */
GtkWidget* w = gtk_toggle_button_new_with_mnemonic(actions[i].label);
gtk_action_connect_proxy(action, w);
gtk_activatable_set_related_action(GTK_ACTIVATABLE(w), action);
gtk_box_pack_start(GTK_BOX(box), w, TRUE, TRUE, 0);
}
}

19
src/celestia/gtk/dialog-solar.cpp
View File

@ -50,15 +50,14 @@ void dialogSolarBrowser(AppData* app)
app->simulation->setSelection(Selection((Star *) NULL));
/* Solar System Browser */
GtkWidget *mainbox = gtk_vbox_new(FALSE, CELSPACING);
GtkWidget *mainbox = gtk_dialog_get_content_area(GTK_DIALOG(browser));
gtk_container_set_border_width(GTK_CONTAINER(mainbox), CELSPACING);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(browser)->vbox), mainbox, TRUE, TRUE, 0);
GtkWidget *scrolled_win = gtk_scrolled_window_new (NULL, NULL);
GtkWidget *scrolled_win = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_ALWAYS);
gtk_box_pack_start(GTK_BOX(mainbox), scrolled_win, TRUE, TRUE, 0);
/* Set the tree store to have 2 visible cols, two hidden. The hidden ones
@ -74,7 +73,7 @@ void dialogSolarBrowser(AppData* app)
for (int i = 0; i < 2; i++) {
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes (ssTitles[i], renderer, "text", i, NULL);
column = gtk_tree_view_column_new_with_attributes(ssTitles[i], renderer, "text", i, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(solarTree), column);
gtk_tree_view_column_set_min_width(column, 200);
}
@ -86,15 +85,15 @@ void dialogSolarBrowser(AppData* app)
/* Common Buttons */
GtkWidget *hbox = gtk_hbox_new(TRUE, CELSPACING);
if (buttonMake(hbox, "Center", (GtkSignalFunc)actionCenterSelection, app))
if (buttonMake(hbox, "Center", (GCallback)actionCenterSelection, app))
return;
if (buttonMake(hbox, "Go To", (GtkSignalFunc)actionGotoSelection, app))
if (buttonMake(hbox, "Go To", (GCallback)actionGotoSelection, app))
return;
gtk_box_pack_start(GTK_BOX(mainbox), hbox, FALSE, FALSE, 0);
g_signal_connect(browser, "response", G_CALLBACK(gtk_widget_destroy), browser);
gtk_widget_set_usize(browser, 500, 400); /* Absolute Size, urghhh */
gtk_widget_set_size_request(browser, -1, 400); /* Absolute Size, urghhh */
gtk_widget_show_all(browser);
}

17
src/celestia/gtk/dialog-star.cpp
View File

@ -54,9 +54,8 @@ void dialogStarBrowser(AppData* app)
app->simulation->setSelection(Selection((Star *) NULL));
/* Star System Browser */
GtkWidget *mainbox = gtk_vbox_new(FALSE, CELSPACING);
GtkWidget *mainbox = gtk_dialog_get_content_area(GTK_DIALOG(browser));
gtk_container_set_border_width(GTK_CONTAINER(mainbox), CELSPACING);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(browser)->vbox), mainbox, TRUE, TRUE, 0);
GtkWidget *scrolled_win = gtk_scrolled_window_new (NULL, NULL);
@ -113,13 +112,13 @@ void dialogStarBrowser(AppData* app)
GtkWidget *hbox2 = gtk_hbox_new(FALSE, CELSPACING);
GtkWidget *label = gtk_label_new("Maximum Stars Displayed in List");
gtk_box_pack_start(GTK_BOX(hbox2), label, TRUE, FALSE, 0);
sb->entry = gtk_entry_new_with_max_length(3);
sb->entry = gtk_entry_new();
gtk_entry_set_max_length(GTK_ENTRY(sb->entry), 3);
gtk_entry_set_width_chars(GTK_ENTRY(sb->entry), 5);
gtk_box_pack_start(GTK_BOX(hbox2), sb->entry, TRUE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, TRUE, FALSE, 0);
sb->scale = gtk_hscale_new_with_range(MINLISTSTARS, MAXLISTSTARS, 1);
gtk_scale_set_draw_value(GTK_SCALE(sb->scale), FALSE);
gtk_range_set_update_policy(GTK_RANGE(sb->scale), GTK_UPDATE_DISCONTINUOUS);
g_signal_connect(sb->scale, "value-changed", G_CALLBACK(listStarSliderChange), sb);
g_signal_connect(sb->entry, "focus-out-event", G_CALLBACK(listStarEntryChange), sb);
gtk_box_pack_start(GTK_BOX(vbox), sb->scale, TRUE, FALSE, 0);
@ -136,22 +135,22 @@ void dialogStarBrowser(AppData* app)
/* Radio Buttons */
vbox = gtk_vbox_new(TRUE, 0);
makeRadioItems(sbRadioLabels, vbox, GTK_SIGNAL_FUNC(radioClicked), NULL, sb);
makeRadioItems(sbRadioLabels, vbox, G_CALLBACK(radioClicked), NULL, sb);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
/* Common Buttons */
hbox = gtk_hbox_new(TRUE, CELSPACING);
if (buttonMake(hbox, "Center", (GtkSignalFunc)actionCenterSelection, app))
if (buttonMake(hbox, "Center", (GCallback)actionCenterSelection, app))
return;
if (buttonMake(hbox, "Go To", (GtkSignalFunc)actionGotoSelection, app))
if (buttonMake(hbox, "Go To", (GCallback)actionGotoSelection, app))
return;
if (buttonMake(hbox, "Refresh", (GtkSignalFunc)refreshBrowser, sb))
if (buttonMake(hbox, "Refresh", (GCallback)refreshBrowser, sb))
return;
gtk_box_pack_start(GTK_BOX(mainbox), hbox, FALSE, FALSE, 0);
g_signal_connect(browser, "response", G_CALLBACK(starDestroy), browser);
gtk_widget_set_usize(browser, 500, 400); /* Absolute Size, urghhh */
gtk_widget_set_size_request(browser, -1, 400); /* Absolute Size, urghhh */
gtk_widget_show_all(browser);
}

24
src/celestia/gtk/dialog-time.cpp
View File

@ -19,7 +19,6 @@
#include "dialog-time.h"
#include "common.h"
/* Declarations: Callbacks */
static gboolean intAdjChanged(GtkAdjustment* adj, int *val);
static gboolean zoneChosen(GtkComboBox *menu, int* timezone);
@ -27,7 +26,7 @@ static gboolean monthChosen(GtkComboBox *menu, int* month);
/* Declarations: Helpers */
static void chooseOption(GtkWidget *hbox, const char *str, char *choices[],
int *val, GtkSignalFunc chosen);
int *val, GCallback chosen);
static void intSpin(GtkWidget *hbox, const char *str, int min, int max,
int *val, const char *sep);
@ -63,7 +62,8 @@ void dialogSetTime(AppData* app)
gtk_container_add(GTK_CONTAINER(align),GTK_WIDGET(hbox));
gtk_container_add(GTK_CONTAINER(frame),GTK_WIDGET(align));
gtk_container_set_border_width (GTK_CONTAINER (frame), 7);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(stimedialog)->vbox), frame, FALSE, FALSE, 0);
GtkWidget* content_area = gtk_dialog_get_content_area(GTK_DIALOG(stimedialog));
gtk_box_pack_start(GTK_BOX(content_area), frame, TRUE, TRUE, 0);
int seconds = (int)date.seconds;
intSpin(hbox, "Hour", 0, 23, &date.hour, ":");
@ -74,7 +74,7 @@ void dialogSetTime(AppData* app)
"Timezone",
(char **)timeOptions,
&timezone,
GTK_SIGNAL_FUNC(zoneChosen));
G_CALLBACK(zoneChosen));
gtk_widget_show_all(hbox);
hbox = gtk_hbox_new(FALSE, 6);
@ -86,13 +86,13 @@ void dialogSetTime(AppData* app)
"Month",
(char **)monthOptions,
&date.month,
GTK_SIGNAL_FUNC(monthChosen));
G_CALLBACK(monthChosen));
/* (Hopefully, noone will need to go beyond these years :-) */
intSpin(hbox, "Day", 1, 31, &date.day, ",");
intSpin(hbox, "Year", -9999, 9999, &date.year, " ");
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(stimedialog)->vbox), frame, FALSE, FALSE, 0);
gtk_container_add (GTK_CONTAINER (content_area), frame);
gtk_container_add(GTK_CONTAINER(align),GTK_WIDGET(hbox));
gtk_container_add(GTK_CONTAINER(frame),GTK_WIDGET(align));
gtk_widget_show(align);
@ -121,7 +121,7 @@ static gboolean intAdjChanged(GtkAdjustment* adj, int *val)
{
if (val)
{
*val = (int)adj->value;
*val = (int)gtk_adjustment_get_value(adj);
return TRUE;
}
return FALSE;
@ -146,16 +146,16 @@ static gboolean monthChosen(GtkComboBox *menu, int* month)
/* HELPER: creates one of the several drop-down boxes */
static void chooseOption(GtkWidget *hbox, const char *str, char *choices[], int *val, GtkSignalFunc chosen)
static void chooseOption(GtkWidget *hbox, const char *str, char *choices[], int *val, GCallback chosen)
{
GtkWidget *vbox = gtk_vbox_new(FALSE, 0);
GtkWidget *label = gtk_label_new(str);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
GtkWidget* combo = gtk_combo_box_new_text();
GtkWidget* combo = gtk_combo_box_text_new();
for(unsigned int i = 0; choices[i]; i++)
{
gtk_combo_box_append_text(GTK_COMBO_BOX(combo), choices[i]);
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(combo), choices[i]);
}
gtk_box_pack_start (GTK_BOX (vbox), label, FALSE, TRUE, 0);
@ -164,7 +164,7 @@ static void chooseOption(GtkWidget *hbox, const char *str, char *choices[], int
gtk_combo_box_set_active(GTK_COMBO_BOX(combo), (*val - 1));
g_signal_connect(GTK_OBJECT(combo), "changed", G_CALLBACK(chosen), (gpointer)val);
g_signal_connect(G_OBJECT(combo), "changed", G_CALLBACK(chosen), (gpointer)val);
}
@ -202,6 +202,6 @@ static void intSpin(GtkWidget *hbox, const char *str, int min, int max, int *val
gtk_box_pack_start (GTK_BOX (vbox), spinner, TRUE, TRUE, 7);
}
g_signal_connect(GTK_OBJECT(adj), "value-changed",
g_signal_connect(G_OBJECT(adj), "value-changed",
G_CALLBACK(intAdjChanged), val);
}

46
src/celestia/gtk/dialog-tour.cpp
View File

@ -23,7 +23,7 @@ using namespace Eigen;
/* Declarations: Callbacks */
static gint TourGuideSelect(GtkWidget* w, TourData* td);
static gint TourGuideSelect(GtkComboBox* comboBox, TourData* td);
static gint TourGuideGoto(GtkWidget*, TourData* td);
static void TourGuideDestroy(GtkWidget* w, gint, TourData* td);
@ -45,25 +45,26 @@ void dialogTourGuide(AppData* app)
gtk_container_set_border_width(GTK_CONTAINER(hbox), CELSPACING);
GtkWidget* label = gtk_label_new("Select your destination:");
gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 0);
GtkWidget* menubox = gtk_option_menu_new();
gtk_box_pack_start(GTK_BOX(hbox), menubox, TRUE, TRUE, 0);
GtkWidget* comboBox = gtk_combo_box_text_new();
gtk_box_pack_start(GTK_BOX(hbox), comboBox, FALSE, FALSE, 0);
GtkWidget* gotoButton = gtk_button_new_with_label("Go To");
gtk_box_pack_start(GTK_BOX(hbox), gotoButton, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(hbox), gotoButton, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, FALSE, TRUE, 0);
GtkWidget* content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_box_pack_start(GTK_BOX(content_area), hbox, FALSE, FALSE, 0);
gtk_widget_show(hbox);
td->descLabel = gtk_label_new("");
gtk_label_set_line_wrap(GTK_LABEL(td->descLabel), TRUE);
gtk_label_set_justify(GTK_LABEL(td->descLabel), GTK_JUSTIFY_FILL);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), td->descLabel, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content_area), td->descLabel, FALSE, FALSE, 0);
GtkWidget* menu = gtk_menu_new();
const DestinationList* destinations = app->core->getDestinations();
int index = -1;
if (destinations != NULL)
{
for (DestinationList::const_iterator iter = destinations->begin();
@ -72,18 +73,17 @@ void dialogTourGuide(AppData* app)
Destination* dest = *iter;
if (dest != NULL)
{
GtkWidget* item = gtk_menu_item_new_with_label(dest->name.c_str());
gtk_menu_append(GTK_MENU(menu), item);
gtk_widget_show(item);
index = 0;
gtk_combo_box_text_append_text(GTK_COMBO_BOX_TEXT(comboBox), dest->name.c_str());
}
}
}
g_signal_connect(GTK_OBJECT(menu),
"selection-done",
g_signal_connect(G_OBJECT(comboBox),
"changed",
G_CALLBACK(TourGuideSelect),
td);
g_signal_connect(GTK_OBJECT(gotoButton),
g_signal_connect(G_OBJECT(gotoButton),
"pressed",
G_CALLBACK(TourGuideGoto),
td);
@ -92,28 +92,18 @@ void dialogTourGuide(AppData* app)
G_CALLBACK(TourGuideDestroy),
td);
gtk_option_menu_set_menu(GTK_OPTION_MENU(menubox), menu);
gtk_widget_set_usize(dialog, 440, 300);
gtk_widget_set_size_request(dialog, -1, 300);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gtk_combo_box_set_active(GTK_COMBO_BOX(comboBox), index);
gtk_widget_show_all(dialog);
}
/* CALLBACK: tour list object selected */
static gint TourGuideSelect(GtkWidget* w, TourData* td)
static gint TourGuideSelect(GtkComboBox* comboBox, TourData* td)
{
GtkMenu* menu = GTK_MENU(w);
if (menu == NULL)
return FALSE;
GtkWidget* item = gtk_menu_get_active(GTK_MENU(menu));
if (item == NULL)
return FALSE;
GList* list = gtk_container_children(GTK_CONTAINER(menu));
int itemIndex = g_list_index(list, item);
int itemIndex = gtk_combo_box_get_active(comboBox);
const DestinationList* destinations = td->app->core->getDestinations();
if (destinations != NULL &&

115
src/celestia/gtk/glwidget.cpp
View File

@ -40,21 +40,21 @@ static bool handleSpecialKey(int key, int state, bool down, AppData* app);
/* ENTRY: Initialize/Bind all glArea Callbacks */
void initGLCallbacks(AppData* app)
{
g_signal_connect(GTK_OBJECT(app->glArea), "expose_event",
g_signal_connect(G_OBJECT(app->glArea), "expose_event",
G_CALLBACK(glarea_expose), app);
g_signal_connect(GTK_OBJECT(app->glArea), "configure_event",
g_signal_connect(G_OBJECT(app->glArea), "configure_event",
G_CALLBACK(glarea_configure), app);
g_signal_connect(GTK_OBJECT(app->glArea), "button_press_event",
g_signal_connect(G_OBJECT(app->glArea), "button_press_event",
G_CALLBACK(glarea_button_press), app);
g_signal_connect(GTK_OBJECT(app->glArea), "button_release_event",
g_signal_connect(G_OBJECT(app->glArea), "button_release_event",
G_CALLBACK(glarea_button_release), app);
g_signal_connect(GTK_OBJECT(app->glArea), "scroll_event",
g_signal_connect(G_OBJECT(app->glArea), "scroll_event",
G_CALLBACK(glarea_mouse_scroll), app);
g_signal_connect(GTK_OBJECT(app->glArea), "motion_notify_event",
g_signal_connect(G_OBJECT(app->glArea), "motion_notify_event",
G_CALLBACK(glarea_motion_notify), app);
g_signal_connect(GTK_OBJECT(app->glArea), "key_press_event",
g_signal_connect(G_OBJECT(app->glArea), "key_press_event",
G_CALLBACK(glarea_key_press), app);
g_signal_connect(GTK_OBJECT(app->glArea), "key_release_event",
g_signal_connect(G_OBJECT(app->glArea), "key_release_event",
G_CALLBACK(glarea_key_release), app);
/* Main call to execute redraw during GTK main loop */
@ -80,7 +80,9 @@ static gint glarea_configure(GtkWidget* widget, GdkEventConfigure*, AppData* app
if (!gdk_gl_drawable_gl_begin (gldrawable, glcontext))
return FALSE;
app->core->resize(widget->allocation.width, widget->allocation.height);
GtkAllocation allocation;
gtk_widget_get_allocation(GTK_WIDGET(widget), &allocation);
app->core->resize(allocation.width, allocation.height);
/* GConf changes only saved upon exit, since caused a lot of CPU activity
* while saving intermediate steps. */
@ -178,30 +180,28 @@ static gint glarea_button_release(GtkWidget*, GdkEventButton* event, AppData* ap
/* CALLBACK: GL Function for event "key_press_event" */
static gint glarea_key_press(GtkWidget* widget, GdkEventKey* event, AppData* app)
{
gtk_signal_emit_stop_by_name(GTK_OBJECT(widget),"key_press_event");
switch (event->keyval)
{
case GDK_Escape:
case GDK_KEY_Escape:
app->core->charEntered('\033');
break;
case GDK_BackSpace:
case GDK_KEY_BackSpace:
app->core->charEntered('\b');
break;
case GDK_Tab:
case GDK_KEY_Tab:
/* Tab has to be handled specially because keyDown and keyUp
* do not trigger auto-completion. */
app->core->charEntered(event->keyval);
break;
case GDK_ISO_Left_Tab:
case GDK_KEY_ISO_Left_Tab:
/* This is what Celestia calls BackTab */
app->core->charEntered(CelestiaCore::Key_BackTab);
break;
/* Temporary until galaxy brightness added as GtkAction */
case GDK_bracketleft:
case GDK_KEY_bracketleft:
app->core->charEntered('(');
break;
case GDK_bracketright:
case GDK_KEY_bracketright:
app->core->charEntered(')');
break;
default:
@ -233,7 +233,6 @@ static gint glarea_key_press(GtkWidget* widget, GdkEventKey* event, AppData* app
/* CALLBACK: GL Function for event "key_release_event" */
static gint glarea_key_release(GtkWidget* widget, GdkEventKey* event, AppData* app)
{
gtk_signal_emit_stop_by_name(GTK_OBJECT(widget),"key_release_event");
return handleSpecialKey(event->keyval, event->state, false, app);
}
@ -267,100 +266,100 @@ static bool handleSpecialKey(int key, int state, bool down, AppData* app)
switch (key)
{
case GDK_Up:
case GDK_KEY_Up:
k = CelestiaCore::Key_Up;
break;
case GDK_Down:
case GDK_KEY_Down:
k = CelestiaCore::Key_Down;
break;
case GDK_Left:
case GDK_KEY_Left:
k = CelestiaCore::Key_Left;
break;
case GDK_Right:
case GDK_KEY_Right:
k = CelestiaCore::Key_Right;
break;
case GDK_Home:
case GDK_KEY_Home:
k = CelestiaCore::Key_Home;
break;
case GDK_End:
case GDK_KEY_End:
k = CelestiaCore::Key_End;
break;
case GDK_F1:
case GDK_KEY_F1:
k = CelestiaCore::Key_F1;
break;
case GDK_F2:
case GDK_KEY_F2:
k = CelestiaCore::Key_F2;
break;
case GDK_F3:
case GDK_KEY_F3:
k = CelestiaCore::Key_F3;
break;
case GDK_F4:
case GDK_KEY_F4:
k = CelestiaCore::Key_F4;
break;
case GDK_F5:
case GDK_KEY_F5:
k = CelestiaCore::Key_F5;
break;
case GDK_F6:
case GDK_KEY_F6:
k = CelestiaCore::Key_F6;
break;
case GDK_F7:
case GDK_KEY_F7:
k = CelestiaCore::Key_F7;
break;
case GDK_F10:
case GDK_KEY_F10:
if (down) actionCaptureImage(NULL, app);
break;
case GDK_F11:
case GDK_KEY_F11:
k = CelestiaCore::Key_F11;
break;
case GDK_F12:
case GDK_KEY_F12:
k = CelestiaCore::Key_F12;
break;
case GDK_KP_Insert:
case GDK_KP_0:
case GDK_KEY_KP_Insert:
case GDK_KEY_KP_0:
k = CelestiaCore::Key_NumPad0;
break;
case GDK_KP_End:
case GDK_KP_1:
case GDK_KEY_KP_End:
case GDK_KEY_KP_1:
k = CelestiaCore::Key_NumPad1;
break;
case GDK_KP_Down:
case GDK_KP_2:
case GDK_KEY_KP_Down:
case GDK_KEY_KP_2:
k = CelestiaCore::Key_NumPad2;
break;
case GDK_KP_Next:
case GDK_KP_3:
case GDK_KEY_KP_Next:
case GDK_KEY_KP_3:
k = CelestiaCore::Key_NumPad3;
break;
case GDK_KP_Left:
case GDK_KP_4:
case GDK_KEY_KP_Left:
case GDK_KEY_KP_4:
k = CelestiaCore::Key_NumPad4;
break;
case GDK_KP_Begin:
case GDK_KP_5:
case GDK_KEY_KP_Begin:
case GDK_KEY_KP_5:
k = CelestiaCore::Key_NumPad5;
break;
case GDK_KP_Right:
case GDK_KP_6:
case GDK_KEY_KP_Right:
case GDK_KEY_KP_6:
k = CelestiaCore::Key_NumPad6;
break;
case GDK_KP_Home:
case GDK_KP_7:
case GDK_KEY_KP_Home:
case GDK_KEY_KP_7:
k = CelestiaCore::Key_NumPad7;
break;
case GDK_KP_Up:
case GDK_KP_8:
case GDK_KEY_KP_Up:
case GDK_KEY_KP_8:
k = CelestiaCore::Key_NumPad8;
break;
case GDK_KP_Prior:
case GDK_KP_9:
case GDK_KEY_KP_Prior:
case GDK_KEY_KP_9:
k = CelestiaCore::Key_NumPad9;
break;
case GDK_A:
case GDK_a:
case GDK_KEY_A:
case GDK_KEY_a:
k = 'A';
break;
case GDK_Z:
case GDK_z:
case GDK_KEY_Z:
case GDK_KEY_z:
k = 'Z';
break;
}

8
src/celestia/gtk/main.cpp
View File

@ -296,7 +296,7 @@ static void initRealize(GtkWidget* widget, AppData* app)
app->core->setTimeZoneName("UTC");
/* Set the cursor to a crosshair */
gdk_window_set_cursor(widget->window, gdk_cursor_new(GDK_CROSSHAIR));
gdk_window_set_cursor(gtk_widget_get_window(widget), gdk_cursor_new(GDK_CROSSHAIR));
}
@ -426,7 +426,7 @@ int main(int argc, char* argv[])
GtkWidget* mainBox = GTK_WIDGET(gtk_vbox_new(FALSE, 0));
gtk_container_set_border_width(GTK_CONTAINER(mainBox), 0);
g_signal_connect(GTK_OBJECT(app->mainWindow), "destroy",
g_signal_connect(G_OBJECT(app->mainWindow), "destroy",
G_CALLBACK(actionQuit), app);
/* Initialize the OpenGL widget */
@ -491,7 +491,7 @@ int main(int argc, char* argv[])
initGLCallbacks(app);
/* Handler than completes initialization when the glArea is realized */
g_signal_connect(GTK_OBJECT(app->glArea), "realize",
g_signal_connect(G_OBJECT(app->glArea), "realize",
G_CALLBACK(initRealize), app);
/* Create the main menu bar */
@ -517,7 +517,7 @@ int main(int argc, char* argv[])
gtk_window_set_default_icon_from_file("celestia-logo.png", NULL);
/* Set focus to glArea widget */
GTK_WIDGET_SET_FLAGS(app->glArea, GTK_CAN_FOCUS);
gtk_widget_set_can_focus(GTK_WIDGET(app->glArea), true);
gtk_widget_grab_focus(GTK_WIDGET(app->glArea));
/* Initialize the Watcher */

16
src/celestia/gtk/menu-context.cpp
View File

@ -33,7 +33,7 @@ static void handleContextPlanet(gpointer data);
static void handleContextSurface(gpointer data);
/* Definitions: Helpers */
static GtkMenuItem* AppendMenu(GtkWidget* parent, GtkSignalFunc callback, const gchar* name, gpointer extra);
static GtkMenuItem* AppendMenu(GtkWidget* parent, GCallback callback, const gchar* name, gpointer extra);
static GtkMenu* CreatePlanetarySystemMenu(string parentName, const PlanetarySystem* psys);
static GtkMenu* CreateAlternateSurfaceMenu(const vector<string>& surfaces);
@ -73,7 +73,7 @@ void GTKContextMenuHandler::requestContextMenu(float, float, Selection sel)
* AppendMenu(popup, NULL, "_Info", 0); */
if (Helper::hasPrimary(sel.body()))
{
AppendMenu(popup, GTK_SIGNAL_FUNC(handleContextPrimary), "Select Primary Body", NULL);
AppendMenu(popup, G_CALLBACK(handleContextPrimary), "Select Primary Body", NULL);
}
const PlanetarySystem* satellites = sel.body()->getSatellites();
@ -248,7 +248,7 @@ static void handleContextSurface(gpointer data)
/* HELPER: Append a menu item and return pointer. Used for context menu. */
static GtkMenuItem* AppendMenu(GtkWidget* parent, GtkSignalFunc callback, const gchar* name, gpointer extra)
static GtkMenuItem* AppendMenu(GtkWidget* parent, GCallback callback, const gchar* name, gpointer extra)
{
GtkWidget* menuitem;
gpointer data;
@ -400,7 +400,7 @@ static GtkMenu* CreatePlanetarySystemMenu(string parentName, const PlanetarySyst
if (obj->size() == 1)
{
it=obj->begin();
AppendMenu(menu, GTK_SIGNAL_FUNC(handleContextPlanet), it->second.c_str(), GINT_TO_POINTER(it->first));
AppendMenu(menu, G_CALLBACK(handleContextPlanet), it->second.c_str(), GINT_TO_POINTER(it->first));
}
else
{
@ -415,7 +415,7 @@ static GtkMenu* CreatePlanetarySystemMenu(string parentName, const PlanetarySyst
subMenu = gtk_menu_new();
for(it=obj->begin(); it != obj->end(); it++)
AppendMenu(subMenu, GTK_SIGNAL_FUNC(handleContextPlanet), it->second.c_str(), GINT_TO_POINTER(it->first));
AppendMenu(subMenu, G_CALLBACK(handleContextPlanet), it->second.c_str(), GINT_TO_POINTER(it->first));
gtk_menu_item_set_submenu(AppendMenu(menu, NULL, menuName->c_str(), 0), GTK_WIDGET(subMenu));
}
@ -423,7 +423,7 @@ static GtkMenu* CreatePlanetarySystemMenu(string parentName, const PlanetarySyst
{
/* Just add items to the popup */
for(it=obj->begin(); it != obj->end(); it++)
AppendMenu(menu, GTK_SIGNAL_FUNC(handleContextPlanet), it->second.c_str(), GINT_TO_POINTER(it->first));
AppendMenu(menu, G_CALLBACK(handleContextPlanet), it->second.c_str(), GINT_TO_POINTER(it->first));
}
}
}
@ -439,10 +439,10 @@ static GtkMenu* CreateAlternateSurfaceMenu(const vector<string>& surfaces)
{
GtkWidget* menu = gtk_menu_new();
AppendMenu(menu, GTK_SIGNAL_FUNC(handleContextSurface), "Normal", 0);
AppendMenu(menu, G_CALLBACK(handleContextSurface), "Normal", 0);
for (guint i = 0; i < surfaces.size(); i++)
{
AppendMenu(menu, GTK_SIGNAL_FUNC(handleContextSurface), surfaces[i].c_str(), GINT_TO_POINTER(i+1));
AppendMenu(menu, G_CALLBACK(handleContextSurface), surfaces[i].c_str(), GINT_TO_POINTER(i+1));
}
return GTK_MENU(menu);

29
src/celestia/gtk/splash.cpp
View File

@ -81,19 +81,21 @@ SplashData* splashStart(AppData* app, gboolean showSplash)
ss->label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(ss->label), 1, 1);
gtk_label_set_justify(GTK_LABEL(ss->label), GTK_JUSTIFY_RIGHT);
gtk_widget_modify_fg(ss->label, GTK_STATE_NORMAL, &ss->label->style->white);
gtk_widget_modify_fg(ss->label, GTK_STATE_NORMAL, &gtk_widget_get_style(ss->label)->white);
gtk_widget_show_all(ss->splash);
/* Size allocations available after showing splash. */
gtk_widget_set_size_request(ss->label, i->allocation.width - 80,
i->allocation.height / 2);
gtk_fixed_put(GTK_FIXED(gf), ss->label, 40, i->allocation.height / 2 - 40);
GtkAllocation allocation;
gtk_widget_get_allocation(GTK_WIDGET(i), &allocation);
gtk_widget_set_size_request(ss->label, allocation.width - 80,
allocation.height / 2);
gtk_fixed_put(GTK_FIXED(gf), ss->label, 40, allocation.height / 2 - 40);
gtk_widget_show(ss->label);
g_signal_connect (ss->splash, "expose_event",
G_CALLBACK (splashExpose),
ss);
G_CALLBACK (splashExpose),
ss);
while (gtk_events_pending()) gtk_main_iteration();
@ -139,11 +141,13 @@ static gboolean splashExpose(GtkWidget* win, GdkEventExpose *event, SplashData*
* operation is quite expensive. */
if (ss->redraw != TRUE) return FALSE;
GdkWindow *ww = gtk_widget_get_window(win);
if (ss->hasARGB)
{
#ifdef CAIRO
/* Use cairo for true transparent windows */
cairo_t *cr = gdk_cairo_create(win->window);
cairo_t *cr = gdk_cairo_create(ww);
cairo_rectangle(cr, event->area.x,
event->area.y,
@ -167,14 +171,17 @@ static gboolean splashExpose(GtkWidget* win, GdkEventExpose *event, SplashData*
GdkPixbuf* bg;
int x, y, w, h;
gdk_window_get_root_origin(win->window, &x, &y);
gdk_drawable_get_size(win->window, &w, &h);
gdk_window_get_root_origin(ww, &x, &y);
w = gdk_window_get_width(ww);
h = gdk_window_get_height(ww);
bg = gdk_pixbuf_get_from_drawable(NULL,
gtk_widget_get_root_window(win),
NULL, x, y, 0, 0, w, h);
gdk_draw_pixbuf(win->window, NULL, bg, 0, 0, 0, 0, w, h,
GDK_RGB_DITHER_NONE, 0, 0);
cairo_t *cr = gdk_cairo_create(ww);
gdk_cairo_set_source_pixbuf(cr, bg, x, y);
cairo_paint(cr);
cairo_destroy(cr);
g_object_unref(bg);
}