mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2024-12-01 06:30:26 +00:00
Code Issues Projects Releases Packages Wiki Activity
subsurface/gtk-gui.c

996 lines
30 KiB
C
Raw Normal View History

Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
/* gtk-gui.c */
/* gtk UI implementation */
/* creates the window and overall layout
* divelist, dive info, equipment and printing are handled in their own source files
*/
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <gconf/gconf-client.h>
#include "dive.h"
#include "divelist.h"
#include "display.h"
#include "display-gtk.h"
#include "libdivecomputer.h"
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
GtkWidget *main_window;
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
GtkWidget *main_vbox;
GtkWidget *error_info_bar;
GtkWidget *error_label;
int error_count;
#define DIVELIST_DEFAULT_FONT "Sans 8"
const char *divelist_font;
GConfClient *gconf;
struct units output_units;
#define GCONF_NAME(x) "/apps/subsurface/" #x
static GtkWidget *dive_profile;
Add preference option to chose if SAC and/or OTU should be in divelist Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 17:16:40 +00:00
visible_cols_t visible_cols = {TRUE, FALSE};
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
void repaint_dive(void)
{
update_dive(current_dive);
Make the dive list start as a plain notebook page I've been wondering how to make 'subsurface' work better on a small screen (I used to travel with a crappy netbook - I may have upgraded my laptop since, but it is still a design goal of mine to make sure it all works fine in that kind of environment). And ever since the dive list was made much wider and moved below the notebook, it's annoyed me how much room it all takes if I want to have both a reasonable plot window and several dives visible at the same time. The solution seems to be to just make the dive list be a notebook page. That makes the default layout very dense. At the same time, when you have the pixels, it's horrible, because you would want to see the dive list and move between dives while at the same time also seeing the dive profile change. But that is solvable by simply making the dive list notebook page be detachable, so if you have a nice big screen, just detach the dive list page and now you have independent windows for the dive list and the dive info. NOTE! I don't have any way to re-attach the dang thing. I think I'd need to learn about drag-and-drop targets etc. So once you've detached the dive list, it stays detached. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 17:38:07 +00:00
if (dive_profile)
gtk_widget_queue_draw(dive_profile);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
}
static char *existing_filename;
Have "make install" act more as expected for a desktop application I'm trying to get subsurface to get closer to becoming a "regular desktop application"; so far this is based on the recommendations and guidelines on OpenSUSE and Fedora. The icon is now named subsurface.svg and make install installs it in the correct location. At runtime subsurface first checks if an icon is installed and if it is it uses that - otherwise it falls back to the old code that tries to read the svg file from the current directory. We also install a subsurface.desktop file Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-11 22:58:38 +00:00
static gboolean need_icon = TRUE;
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
static void on_info_bar_response(GtkWidget *widget, gint response,
gpointer data)
{
if (response == GTK_RESPONSE_OK)
{
gtk_widget_destroy(widget);
error_info_bar = NULL;
}
}
void report_error(GError* error)
{
if (error == NULL)
{
return;
}
if (error_info_bar == NULL)
{
error_count = 1;
error_info_bar = gtk_info_bar_new_with_buttons(GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
g_signal_connect(error_info_bar, "response", G_CALLBACK(on_info_bar_response), NULL);
gtk_info_bar_set_message_type(GTK_INFO_BAR(error_info_bar),
GTK_MESSAGE_ERROR);
error_label = gtk_label_new(error->message);
GtkWidget *container = gtk_info_bar_get_content_area(GTK_INFO_BAR(error_info_bar));
gtk_container_add(GTK_CONTAINER(container), error_label);
gtk_box_pack_start(GTK_BOX(main_vbox), error_info_bar, FALSE, FALSE, 0);
gtk_widget_show_all(main_vbox);
}
else
{
error_count++;
char buffer[256];
snprintf(buffer, sizeof(buffer), "Failed to open %i files.", error_count);
gtk_label_set(GTK_LABEL(error_label), buffer);
}
}
static void file_open(GtkWidget *w, gpointer data)
{
GtkWidget *dialog;
Add a xml file filter to the file open dialog My home directory is a mess. Don't show all the crap, just the stuff that might be relevant. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-26 16:18:23 +00:00
GtkFileFilter *filter;
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
dialog = gtk_file_chooser_dialog_new("Open File",
GTK_WINDOW(main_window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), TRUE);
Add a xml file filter to the file open dialog My home directory is a mess. Don't show all the crap, just the stuff that might be relevant. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-26 16:18:23 +00:00
filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter, "*.xml");
gtk_file_filter_add_pattern(filter, "*.XML");
Remove the ability to 'Import' .SDA files We can instead 'Open' these files as they are just bastardized XML files. This gets us back to a more consistent point where 'Import' gets data directly from the dive computer (and hopefully soon we will add the ability to load a dive directly from a uemis SDA to libdivecomputer), and 'Open' loads a file from the filesystem of the computer we are running on (this last sentence phrased so awkwardly as the uemis Zurich SDA is a computer and presents a file system when connected via USB - it just doesn't have the dive data in an accessible format in that file system). As a bonus we get to throw away quite a bit of code (the uemis specific file handling, mini-XML parser with helper functions, the file open dialog in the importer). Yay! Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-03 15:27:36 +00:00
gtk_file_filter_add_pattern(filter, "*.sda");
gtk_file_filter_add_pattern(filter, "*.SDA");
Add a xml file filter to the file open dialog My home directory is a mess. Don't show all the crap, just the stuff that might be relevant. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-26 16:18:23 +00:00
gtk_file_filter_add_mime_type(filter, "text/xml");
gtk_file_filter_set_name(filter, "XML file");
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
GSList *filenames;
char *filename;
filenames = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(dialog));
GError *error = NULL;
while(filenames != NULL) {
Remove some useless casts from and to void pointers Remove casts from/to void*. They are unneeded in C, can hide problems in the future, and are far too C++ish. Furthermore, they were inconsistent with the rest of the code and even with regards to themselves (at least in terms of whether or not to have space after the cast). In this case, we temporarily lose const specifiers in libdivecomputer.c due to the unneeded cast, so it seems better to avoid the cast at all, so you get warned about a const->non-const cast if you ever change it to do something like this. The casts in gtk-gui.c are just useless semantically, although they might be useful as a hint to the reader that the void pointers are char arrays. Signed-off-by: Julian Andres Klode <jak@jak-linux.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-10-06 19:08:48 +00:00
filename = filenames->data;
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
parse_xml_file(filename, &error);
if (error != NULL)
{
report_error(error);
g_error_free(error);
error = NULL;
}
g_free(filename);
filenames = g_slist_next(filenames);
}
g_slist_free(filenames);
Add XML file import back and treat open and import differently Open (or adding a file name on the command line) means that this is just one of the files that you consider part of your dive history. So dives don't get automagically numbered and the dive_list is not considered "changed" just because another file was opened. Import (or adding a file on the command line after --import) means that you are importing the content of this file to your dive history. So if the imported file has un-numbered dives that are newer than everything else, those get correctly renumbered. And importing marks the dive_list as changed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-05 18:36:15 +00:00
report_dives(FALSE);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
}
gtk_widget_destroy(dialog);
}
static void file_save(GtkWidget *w, gpointer data)
{
GtkWidget *dialog;
dialog = gtk_file_chooser_dialog_new("Save File",
GTK_WINDOW(main_window),
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
if (!existing_filename) {
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), "Untitled document");
} else
gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(dialog), existing_filename);
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
char *filename;
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
save_dives(filename);
g_free(filename);
Show the "save changes" dialog before the main window is destroyed By using the delete-event callback instead of the destroy callback we are able to display our dialog (and the file-save dialog) while the program window is still being displayed. Much nicer this way. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-21 17:31:03 +00:00
mark_divelist_changed(FALSE);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
}
gtk_widget_destroy(dialog);
}
Simplistic first attempt to get changes saved when quitting subsurface Track whether things changed in the global dive_list So far this actually works if changing dive info (but only if dive selected was changed after the dive info was changed). We are not tracking changes to the cylinder information, yet. also remove the duplicate static dive_list Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-21 04:29:09 +00:00
static void ask_save_changes()
{
Check for changes at regular 'quit' events as well Also make the dialog box less offensively ugly Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-21 17:16:33 +00:00
GtkWidget *dialog, *label, *content;
Simplistic first attempt to get changes saved when quitting subsurface Track whether things changed in the global dive_list So far this actually works if changing dive info (but only if dive selected was changed after the dive info was changed). We are not tracking changes to the cylinder information, yet. also remove the duplicate static dive_list Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-21 04:29:09 +00:00
dialog = gtk_dialog_new_with_buttons("Save Changes?",
GTK_WINDOW(main_window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
NULL);
Check for changes at regular 'quit' events as well Also make the dialog box less offensively ugly Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-21 17:16:33 +00:00
content = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
label = gtk_label_new ("You have unsaved changes\nWould you like to save those before exiting the program?");
gtk_container_add (GTK_CONTAINER (content), label);
gtk_widget_show_all (dialog);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
Simplistic first attempt to get changes saved when quitting subsurface Track whether things changed in the global dive_list So far this actually works if changing dive info (but only if dive selected was changed after the dive info was changed). We are not tracking changes to the cylinder information, yet. also remove the duplicate static dive_list Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-21 04:29:09 +00:00
if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
file_save(NULL,NULL);
}
gtk_widget_destroy(dialog);
}
Show the "save changes" dialog before the main window is destroyed By using the delete-event callback instead of the destroy callback we are able to display our dialog (and the file-save dialog) while the program window is still being displayed. Much nicer this way. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-21 17:31:03 +00:00
static gboolean on_delete(GtkWidget* w, gpointer data)
Simplistic first attempt to get changes saved when quitting subsurface Track whether things changed in the global dive_list So far this actually works if changing dive info (but only if dive selected was changed after the dive info was changed). We are not tracking changes to the cylinder information, yet. also remove the duplicate static dive_list Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-21 04:29:09 +00:00
{
Catch changes to the info of the current dive when quitting As the application shuts down we do one more check to see if the dive that is currently being displayed has been modified (we previously just checked as we switch dives) Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-21 14:34:00 +00:00
/* Make sure to flush any modified dive data */
update_dive(NULL);
Simplistic first attempt to get changes saved when quitting subsurface Track whether things changed in the global dive_list So far this actually works if changing dive info (but only if dive selected was changed after the dive info was changed). We are not tracking changes to the cylinder information, yet. also remove the duplicate static dive_list Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-21 04:29:09 +00:00
if (unsaved_changes())
ask_save_changes();
Show the "save changes" dialog before the main window is destroyed By using the delete-event callback instead of the destroy callback we are able to display our dialog (and the file-save dialog) while the program window is still being displayed. Much nicer this way. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-21 17:31:03 +00:00
return FALSE; /* go ahead, kill the program, we're good now */
}
static void on_destroy(GtkWidget* w, gpointer data)
{
Simplistic first attempt to get changes saved when quitting subsurface Track whether things changed in the global dive_list So far this actually works if changing dive info (but only if dive selected was changed after the dive info was changed). We are not tracking changes to the cylinder information, yet. also remove the duplicate static dive_list Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-21 04:29:09 +00:00
gtk_main_quit();
}
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
static void quit(GtkWidget *w, gpointer data)
{
Check for changes at regular 'quit' events as well Also make the dialog box less offensively ugly Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-21 17:16:33 +00:00
/* Make sure to flush any modified dive data */
update_dive(NULL);
if (unsaved_changes())
ask_save_changes();
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
gtk_main_quit();
}
Split up generic code to generate a gtk tree view column We used to do this just for the dive list, but the new cylinder view will want to do a lot of the same boilerplate gtk stuff, so make it a bit more generic and move it to gtk-gui.c. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-10-02 20:05:12 +00:00
GtkTreeViewColumn *tree_view_column(GtkWidget *tree_view, int index, const char *title,
data_func_t data_func, PangoAlignment align, gboolean visible)
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
double xalign = 0.0; /* left as default */
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, title);
gtk_tree_view_column_set_sort_column_id(col, index);
gtk_tree_view_column_set_resizable(col, TRUE);
gtk_tree_view_column_pack_start(col, renderer, TRUE);
if (data_func)
gtk_tree_view_column_set_cell_data_func(col, renderer, data_func, (void *)(long)index, NULL);
else
gtk_tree_view_column_add_attribute(col, renderer, "text", index);
gtk_object_set(GTK_OBJECT(renderer), "alignment", align, NULL);
switch (align) {
case PANGO_ALIGN_LEFT:
xalign = 0.0;
break;
case PANGO_ALIGN_CENTER:
xalign = 0.5;
break;
case PANGO_ALIGN_RIGHT:
xalign = 1.0;
break;
}
gtk_cell_renderer_set_alignment(GTK_CELL_RENDERER(renderer), xalign, 0.5);
gtk_tree_view_column_set_visible(col, visible);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_view), col);
return col;
}
Fix preferences dialog Dirk took some old code when he did the merge of the newly split gui code. Fix it up. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-20 21:05:46 +00:00
static void create_radio(GtkWidget *vbox, const char *name, ...)
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
{
va_list args;
GtkRadioButton *group = NULL;
GtkWidget *box, *label;
box = gtk_hbox_new(TRUE, 10);
Fix preferences dialog Dirk took some old code when he did the merge of the newly split gui code. Fix it up. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-20 21:05:46 +00:00
gtk_box_pack_start(GTK_BOX(vbox), box, FALSE, FALSE, 0);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
label = gtk_label_new(name);
gtk_box_pack_start(GTK_BOX(box), label, TRUE, TRUE, 0);
va_start(args, name);
for (;;) {
int enabled;
const char *name;
GtkWidget *button;
void *callback_fn;
name = va_arg(args, char *);
if (!name)
break;
callback_fn = va_arg(args, void *);
enabled = va_arg(args, int);
button = gtk_radio_button_new_with_label_from_widget(group, name);
group = GTK_RADIO_BUTTON(button);
gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), enabled);
g_signal_connect(button, "toggled", G_CALLBACK(callback_fn), NULL);
}
va_end(args);
}
#define UNITCALLBACK(name, type, value) \
static void name(GtkWidget *w, gpointer data) \
{ \
if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(w))) \
menu_units.type = value; \
}
static struct units menu_units;
UNITCALLBACK(set_meter, length, METERS)
UNITCALLBACK(set_feet, length, FEET)
UNITCALLBACK(set_bar, pressure, BAR)
UNITCALLBACK(set_psi, pressure, PSI)
UNITCALLBACK(set_liter, volume, LITER)
UNITCALLBACK(set_cuft, volume, CUFT)
UNITCALLBACK(set_celsius, temperature, CELSIUS)
UNITCALLBACK(set_fahrenheit, temperature, FAHRENHEIT)
Add preference option to chose if SAC and/or OTU should be in divelist Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 17:16:40 +00:00
#define OPTIONCALLBACK(name, option) \
static void name(GtkWidget *w, gpointer data) \
{ \
option = GTK_TOGGLE_BUTTON(w)->active; \
}
OPTIONCALLBACK(otu_toggle, visible_cols.otu)
OPTIONCALLBACK(sac_toggle, visible_cols.sac)
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
static void preferences_dialog(GtkWidget *w, gpointer data)
{
int result;
Merge branch 'otu-tracking-v2' of git://github.com/dirkhh/subsurface * 'otu-tracking-v2' of git://github.com/dirkhh/subsurface: Store options in gconf Add preference option to chose if SAC and/or OTU should be in divelist Fix up trivial conflicts in gtk-gui.c (cleanup in gtk dialog wrt gtk_dialog_get_content_area() having introduced a new 'vbox' widget)
2011-09-27 18:05:39 +00:00
GtkWidget *dialog, *font, *frame, *box, *vbox, *button;
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
menu_units = output_units;
dialog = gtk_dialog_new_with_buttons("Preferences",
GTK_WINDOW(main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
NULL);
frame = gtk_frame_new("Units");
Use 'gtk_dialog_get_content_area()' instead of accessing dialog directly I'm reading gtk docs, and trying to clean things up a bit. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-24 22:26:37 +00:00
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
box = gtk_vbox_new(FALSE, 6);
gtk_container_add(GTK_CONTAINER(frame), box);
create_radio(box, "Depth:",
"Meter", set_meter, (output_units.length == METERS),
"Feet", set_feet, (output_units.length == FEET),
NULL);
create_radio(box, "Pressure:",
"Bar", set_bar, (output_units.pressure == BAR),
"PSI", set_psi, (output_units.pressure == PSI),
NULL);
create_radio(box, "Volume:",
"Liter", set_liter, (output_units.volume == LITER),
"CuFt", set_cuft, (output_units.volume == CUFT),
NULL);
create_radio(box, "Temperature:",
"Celsius", set_celsius, (output_units.temperature == CELSIUS),
"Fahrenheit", set_fahrenheit, (output_units.temperature == FAHRENHEIT),
NULL);
Add preference option to chose if SAC and/or OTU should be in divelist Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 17:16:40 +00:00
frame = gtk_frame_new("Columns");
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), frame, FALSE, FALSE, 5);
box = gtk_hbox_new(FALSE, 6);
gtk_container_add(GTK_CONTAINER(frame), box);
button = gtk_check_button_new_with_label("Show SAC");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), visible_cols.sac);
gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6);
g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(sac_toggle), NULL);
button = gtk_check_button_new_with_label("Show OTU");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), visible_cols.otu);
gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6);
g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(otu_toggle), NULL);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
font = gtk_font_button_new_with_font(divelist_font);
Use 'gtk_dialog_get_content_area()' instead of accessing dialog directly I'm reading gtk docs, and trying to clean things up a bit. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-24 22:26:37 +00:00
gtk_box_pack_start(GTK_BOX(vbox), font, FALSE, FALSE, 5);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
gtk_widget_show_all(dialog);
result = gtk_dialog_run(GTK_DIALOG(dialog));
if (result == GTK_RESPONSE_ACCEPT) {
/* Make sure to flush any modified old dive data with old units */
update_dive(NULL);
divelist_font = strdup(gtk_font_button_get_font_name(GTK_FONT_BUTTON(font)));
set_divelist_font(divelist_font);
output_units = menu_units;
update_dive_list_units();
repaint_dive();
Add preference option to chose if SAC and/or OTU should be in divelist Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 17:16:40 +00:00
update_dive_list_col_visibility();
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
gconf_client_set_bool(gconf, GCONF_NAME(feet), output_units.length == FEET, NULL);
gconf_client_set_bool(gconf, GCONF_NAME(psi), output_units.pressure == PSI, NULL);
gconf_client_set_bool(gconf, GCONF_NAME(cuft), output_units.volume == CUFT, NULL);
gconf_client_set_bool(gconf, GCONF_NAME(fahrenheit), output_units.temperature == FAHRENHEIT, NULL);
Store options in gconf While it's not the most elegant way to do this I opted to store the options with "inverted polarity" - i.e., the options that are supposed to default to "True" are stored inverted since gconf reports an unset option (first time the user runs the program) as "False". Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 17:46:59 +00:00
gconf_client_set_bool(gconf, GCONF_NAME(SAC), ! visible_cols.sac, NULL); /* inverted to get the correct default */
Add preference option to chose if SAC and/or OTU should be in divelist Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 17:16:40 +00:00
gconf_client_set_bool(gconf, GCONF_NAME(OTU), visible_cols.otu, NULL);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
gconf_client_set_string(gconf, GCONF_NAME(divelist_font), divelist_font, NULL);
}
gtk_widget_destroy(dialog);
}
static void renumber_dialog(GtkWidget *w, gpointer data)
{
int result;
For a manual renumber, default to the existing first dive number If renumbering a list of dives, default the start number to the existing first dive number. That way, if you do need to renumber (overlapping import or whatever), but your at least had your really old dives already numbered, we start off with a sane default. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-10-05 15:37:14 +00:00
struct dive *dive;
Use 'gtk_dialog_get_content_area()' instead of accessing dialog directly I'm reading gtk docs, and trying to clean things up a bit. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-24 22:26:37 +00:00
GtkWidget *dialog, *frame, *button, *vbox;
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
dialog = gtk_dialog_new_with_buttons("Renumber",
GTK_WINDOW(main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
NULL);
Use 'gtk_dialog_get_content_area()' instead of accessing dialog directly I'm reading gtk docs, and trying to clean things up a bit. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-24 22:26:37 +00:00
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
frame = gtk_frame_new("New starting number");
Use 'gtk_dialog_get_content_area()' instead of accessing dialog directly I'm reading gtk docs, and trying to clean things up a bit. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-24 22:26:37 +00:00
gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
button = gtk_spin_button_new_with_range(1, 50000, 1);
gtk_container_add(GTK_CONTAINER(frame), button);
For a manual renumber, default to the existing first dive number If renumbering a list of dives, default the start number to the existing first dive number. That way, if you do need to renumber (overlapping import or whatever), but your at least had your really old dives already numbered, we start off with a sane default. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-10-05 15:37:14 +00:00
/*
* Do we have a number for the first dive already? Use that
* as the default.
*/
dive = get_dive(0);
if (dive && dive->number)
gtk_spin_button_set_value(GTK_SPIN_BUTTON(button), dive->number);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
gtk_widget_show_all(dialog);
result = gtk_dialog_run(GTK_DIALOG(dialog));
if (result == GTK_RESPONSE_ACCEPT) {
int nr = gtk_spin_button_get_value(GTK_SPIN_BUTTON(button));
renumber_dives(nr);
repaint_dive();
}
gtk_widget_destroy(dialog);
}
Add an 'About' dialog It's really just about the logo, but whatever. Dirk tells me I need one of these in order to call it 1.0. And I'm not going to fall into the trap of thinking that 1.0 needs to be something polished, it just needs to be working well enough.. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-24 22:48:13 +00:00
static void about_dialog(GtkWidget *w, gpointer data)
{
const char *logo_property = NULL;
GdkPixbuf *logo = NULL;
Have "make install" act more as expected for a desktop application I'm trying to get subsurface to get closer to becoming a "regular desktop application"; so far this is based on the recommendations and guidelines on OpenSUSE and Fedora. The icon is now named subsurface.svg and make install installs it in the correct location. At runtime subsurface first checks if an icon is installed and if it is it uses that - otherwise it falls back to the old code that tries to read the svg file from the current directory. We also install a subsurface.desktop file Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-11 22:58:38 +00:00
if (need_icon) {
GtkWidget *image = gtk_image_new_from_file("subsurface.svg");
if (image) {
logo = gtk_image_get_pixbuf(GTK_IMAGE(image));
logo_property = "logo";
}
Add an 'About' dialog It's really just about the logo, but whatever. Dirk tells me I need one of these in order to call it 1.0. And I'm not going to fall into the trap of thinking that 1.0 needs to be something polished, it just needs to be working well enough.. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-24 22:48:13 +00:00
}
gtk_show_about_dialog(NULL,
"program-name", "SubSurface",
"comments", "Half-arsed divelog software in C",
"license", "GPLv2",
Add the version to the Makefile Not quite the same format as for the kernel, but I want to do the normal "edit the makefile before making a release" model that I'm used to. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-26 18:04:50 +00:00
"version", VERSION_STRING,
Add an 'About' dialog It's really just about the logo, but whatever. Dirk tells me I need one of these in order to call it 1.0. And I'm not going to fall into the trap of thinking that 1.0 needs to be something polished, it just needs to be working well enough.. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-24 22:48:13 +00:00
"copyright", "Linus Torvalds 2011",
Have "make install" act more as expected for a desktop application I'm trying to get subsurface to get closer to becoming a "regular desktop application"; so far this is based on the recommendations and guidelines on OpenSUSE and Fedora. The icon is now named subsurface.svg and make install installs it in the correct location. At runtime subsurface first checks if an icon is installed and if it is it uses that - otherwise it falls back to the old code that tries to read the svg file from the current directory. We also install a subsurface.desktop file Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-11 22:58:38 +00:00
"logo-icon-name", "subsurface",
Add an 'About' dialog It's really just about the logo, but whatever. Dirk tells me I need one of these in order to call it 1.0. And I'm not going to fall into the trap of thinking that 1.0 needs to be something polished, it just needs to be working well enough.. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-24 22:48:13 +00:00
/* Must be last: */
logo_property, logo,
NULL);
}
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
static GtkActionEntry menu_items[] = {
{ "FileMenuAction", GTK_STOCK_FILE, "File", NULL, NULL, NULL},
{ "LogMenuAction", GTK_STOCK_FILE, "Log", NULL, NULL, NULL},
Add an 'About' dialog It's really just about the logo, but whatever. Dirk tells me I need one of these in order to call it 1.0. And I'm not going to fall into the trap of thinking that 1.0 needs to be something polished, it just needs to be working well enough.. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-24 22:48:13 +00:00
{ "HelpMenuAction", GTK_STOCK_HELP, "Help", NULL, NULL, NULL},
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
{ "OpenFile", GTK_STOCK_OPEN, NULL, "<control>O", NULL, G_CALLBACK(file_open) },
{ "SaveFile", GTK_STOCK_SAVE, NULL, "<control>S", NULL, G_CALLBACK(file_save) },
{ "Print", GTK_STOCK_PRINT, NULL, "<control>P", NULL, G_CALLBACK(do_print) },
{ "Import", NULL, "Import", NULL, NULL, G_CALLBACK(import_dialog) },
{ "Preferences", NULL, "Preferences", NULL, NULL, G_CALLBACK(preferences_dialog) },
{ "Renumber", NULL, "Renumber", NULL, NULL, G_CALLBACK(renumber_dialog) },
{ "Quit", GTK_STOCK_QUIT, NULL, "<control>Q", NULL, G_CALLBACK(quit) },
Add an 'About' dialog It's really just about the logo, but whatever. Dirk tells me I need one of these in order to call it 1.0. And I'm not going to fall into the trap of thinking that 1.0 needs to be something polished, it just needs to be working well enough.. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-24 22:48:13 +00:00
{ "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
};
static gint nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
static const gchar* ui_string = " \
<ui> \
<menubar name=\"MainMenu\"> \
<menu name=\"FileMenu\" action=\"FileMenuAction\"> \
<menuitem name=\"Open\" action=\"OpenFile\" /> \
<menuitem name=\"Save\" action=\"SaveFile\" /> \
<menuitem name=\"Print\" action=\"Print\" /> \
<separator name=\"Separator1\"/> \
<menuitem name=\"Import\" action=\"Import\" /> \
<separator name=\"Separator2\"/> \
<menuitem name=\"Preferences\" action=\"Preferences\" /> \
<separator name=\"Separator3\"/> \
<menuitem name=\"Quit\" action=\"Quit\" /> \
</menu> \
<menu name=\"LogMenu\" action=\"LogMenuAction\"> \
<menuitem name=\"Renumber\" action=\"Renumber\" /> \
</menu> \
Add an 'About' dialog It's really just about the logo, but whatever. Dirk tells me I need one of these in order to call it 1.0. And I'm not going to fall into the trap of thinking that 1.0 needs to be something polished, it just needs to be working well enough.. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-24 22:48:13 +00:00
<menu name=\"Help\" action=\"HelpMenuAction\"> \
<menuitem name=\"About\" action=\"About\" /> \
</menu> \
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
</menubar> \
</ui> \
";
static GtkWidget *get_menubar_menu(GtkWidget *window)
{
GtkActionGroup *action_group = gtk_action_group_new("Menu");
gtk_action_group_add_actions(action_group, menu_items, nmenu_items, 0);
GtkUIManager *ui_manager = gtk_ui_manager_new();
gtk_ui_manager_insert_action_group(ui_manager, action_group, 0);
GError* error = 0;
gtk_ui_manager_add_ui_from_string(GTK_UI_MANAGER(ui_manager), ui_string, -1, &error);
gtk_window_add_accel_group(GTK_WINDOW(window), gtk_ui_manager_get_accel_group(ui_manager));
GtkWidget* menu = gtk_ui_manager_get_widget(ui_manager, "/MainMenu");
return menu;
}
static void switch_page(GtkNotebook *notebook, gint arg1, gpointer user_data)
{
repaint_dive();
}
Linus would like to be less on the bleeding edge of Gtk+ So we go back to the old interfaces to identify the notebook as part of one group - the one that was just recently deprecated Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-28 00:11:08 +00:00
static const char notebook_group[] = "123";
#define GRP_ID ((void *)notebook_group)
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
typedef struct {
char *name;
GtkWidget *widget;
GtkWidget *box;
gulong delete_handler;
gulong destroy_handler;
} notebook_data_t;
static notebook_data_t nbd[2]; /* we rip at most two notebook pages off */
Add drag-n-drop support to be able to re-integrate the dive list This is somewhat hacky, and there is clearly something I still don't understand about gtk selections and drag-n-drop. Dropping it back works, but I get a nasty error when I do it: (subsurface:8512): Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed even though I actually never set any selection at all directly. So there must be some internal gtk rule that I am violating, but I can't see what it is. I probably shouldn't commit it with a known ugly wart like that, but I really have no clue. Maybe somebody else can figure out what is up. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 19:54:53 +00:00
Make the dive list start as a plain notebook page I've been wondering how to make 'subsurface' work better on a small screen (I used to travel with a crappy netbook - I may have upgraded my laptop since, but it is still a design goal of mine to make sure it all works fine in that kind of environment). And ever since the dive list was made much wider and moved below the notebook, it's annoyed me how much room it all takes if I want to have both a reasonable plot window and several dives visible at the same time. The solution seems to be to just make the dive list be a notebook page. That makes the default layout very dense. At the same time, when you have the pixels, it's horrible, because you would want to see the dive list and move between dives while at the same time also seeing the dive profile change. But that is solvable by simply making the dive list notebook page be detachable, so if you have a nice big screen, just detach the dive list page and now you have independent windows for the dive list and the dive info. NOTE! I don't have any way to re-attach the dang thing. I think I'd need to learn about drag-and-drop targets etc. So once you've detached the dive list, it stays detached. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 17:38:07 +00:00
static GtkNotebook *create_new_notebook_window(GtkNotebook *source,
GtkWidget *page,
gint x, gint y, gpointer data)
{
GtkWidget *win, *notebook, *vbox;
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
notebook_data_t *nbdp;
Keep window size for new notebook pages We used to set a fixed size instead of just copying the size that the existing notebook has - which didn't really feel right when resizing and then ripping of a page. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-20 10:04:18 +00:00
GtkAllocation allocation;
Make the dive list start as a plain notebook page I've been wondering how to make 'subsurface' work better on a small screen (I used to travel with a crappy netbook - I may have upgraded my laptop since, but it is still a design goal of mine to make sure it all works fine in that kind of environment). And ever since the dive list was made much wider and moved below the notebook, it's annoyed me how much room it all takes if I want to have both a reasonable plot window and several dives visible at the same time. The solution seems to be to just make the dive list be a notebook page. That makes the default layout very dense. At the same time, when you have the pixels, it's horrible, because you would want to see the dive list and move between dives while at the same time also seeing the dive profile change. But that is solvable by simply making the dive list notebook page be detachable, so if you have a nice big screen, just detach the dive list page and now you have independent windows for the dive list and the dive info. NOTE! I don't have any way to re-attach the dang thing. I think I'd need to learn about drag-and-drop targets etc. So once you've detached the dive list, it stays detached. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 17:38:07 +00:00
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
/* pick the right notebook page data and return if both are detached */
if (nbd[0].widget == NULL)
nbdp = nbd;
else if (nbd[1].widget == NULL)
nbdp = nbd + 1;
else
Make the dive list start as a plain notebook page I've been wondering how to make 'subsurface' work better on a small screen (I used to travel with a crappy netbook - I may have upgraded my laptop since, but it is still a design goal of mine to make sure it all works fine in that kind of environment). And ever since the dive list was made much wider and moved below the notebook, it's annoyed me how much room it all takes if I want to have both a reasonable plot window and several dives visible at the same time. The solution seems to be to just make the dive list be a notebook page. That makes the default layout very dense. At the same time, when you have the pixels, it's horrible, because you would want to see the dive list and move between dives while at the same time also seeing the dive profile change. But that is solvable by simply making the dive list notebook page be detachable, so if you have a nice big screen, just detach the dive list page and now you have independent windows for the dive list and the dive info. NOTE! I don't have any way to re-attach the dang thing. I think I'd need to learn about drag-and-drop targets etc. So once you've detached the dive list, it stays detached. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 17:38:07 +00:00
return NULL;
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
nbdp->name = strdup(gtk_widget_get_name(page));
nbdp->widget = win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(win), nbdp->name);
Make the dive list start as a plain notebook page I've been wondering how to make 'subsurface' work better on a small screen (I used to travel with a crappy netbook - I may have upgraded my laptop since, but it is still a design goal of mine to make sure it all works fine in that kind of environment). And ever since the dive list was made much wider and moved below the notebook, it's annoyed me how much room it all takes if I want to have both a reasonable plot window and several dives visible at the same time. The solution seems to be to just make the dive list be a notebook page. That makes the default layout very dense. At the same time, when you have the pixels, it's horrible, because you would want to see the dive list and move between dives while at the same time also seeing the dive profile change. But that is solvable by simply making the dive list notebook page be detachable, so if you have a nice big screen, just detach the dive list page and now you have independent windows for the dive list and the dive info. NOTE! I don't have any way to re-attach the dang thing. I think I'd need to learn about drag-and-drop targets etc. So once you've detached the dive list, it stays detached. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 17:38:07 +00:00
gtk_window_move(GTK_WINDOW(win), x, y);
/* Destroying the dive list will kill the application */
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
nbdp->delete_handler = g_signal_connect(G_OBJECT(win), "delete-event", G_CALLBACK(on_delete), NULL);
nbdp->destroy_handler = g_signal_connect(G_OBJECT(win), "destroy", G_CALLBACK(on_destroy), NULL);
Make the dive list start as a plain notebook page I've been wondering how to make 'subsurface' work better on a small screen (I used to travel with a crappy netbook - I may have upgraded my laptop since, but it is still a design goal of mine to make sure it all works fine in that kind of environment). And ever since the dive list was made much wider and moved below the notebook, it's annoyed me how much room it all takes if I want to have both a reasonable plot window and several dives visible at the same time. The solution seems to be to just make the dive list be a notebook page. That makes the default layout very dense. At the same time, when you have the pixels, it's horrible, because you would want to see the dive list and move between dives while at the same time also seeing the dive profile change. But that is solvable by simply making the dive list notebook page be detachable, so if you have a nice big screen, just detach the dive list page and now you have independent windows for the dive list and the dive info. NOTE! I don't have any way to re-attach the dang thing. I think I'd need to learn about drag-and-drop targets etc. So once you've detached the dive list, it stays detached. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 17:38:07 +00:00
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
nbdp->box = vbox = gtk_vbox_new(FALSE, 0);
Make the dive list start as a plain notebook page I've been wondering how to make 'subsurface' work better on a small screen (I used to travel with a crappy netbook - I may have upgraded my laptop since, but it is still a design goal of mine to make sure it all works fine in that kind of environment). And ever since the dive list was made much wider and moved below the notebook, it's annoyed me how much room it all takes if I want to have both a reasonable plot window and several dives visible at the same time. The solution seems to be to just make the dive list be a notebook page. That makes the default layout very dense. At the same time, when you have the pixels, it's horrible, because you would want to see the dive list and move between dives while at the same time also seeing the dive profile change. But that is solvable by simply making the dive list notebook page be detachable, so if you have a nice big screen, just detach the dive list page and now you have independent windows for the dive list and the dive info. NOTE! I don't have any way to re-attach the dang thing. I think I'd need to learn about drag-and-drop targets etc. So once you've detached the dive list, it stays detached. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 17:38:07 +00:00
gtk_container_add(GTK_CONTAINER(win), vbox);
notebook = gtk_notebook_new();
Linus would like to be less on the bleeding edge of Gtk+ So we go back to the old interfaces to identify the notebook as part of one group - the one that was just recently deprecated Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-28 00:11:08 +00:00
gtk_notebook_set_group(GTK_NOTEBOOK(notebook), GRP_ID);
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
gtk_widget_set_name(notebook, nbdp->name);
The notebook pages can only be dropped back into the main notebook Disable the secondary notebooks that are created when ripping off a page (dive_list or dive_profile) as drop targets for other pages. Also fix the incorrect arguments for the drag callback function. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-28 02:47:19 +00:00
/* disallow drop events */
gtk_drag_dest_set(notebook, 0, NULL, 0, 0);
Make the dive list start as a plain notebook page I've been wondering how to make 'subsurface' work better on a small screen (I used to travel with a crappy netbook - I may have upgraded my laptop since, but it is still a design goal of mine to make sure it all works fine in that kind of environment). And ever since the dive list was made much wider and moved below the notebook, it's annoyed me how much room it all takes if I want to have both a reasonable plot window and several dives visible at the same time. The solution seems to be to just make the dive list be a notebook page. That makes the default layout very dense. At the same time, when you have the pixels, it's horrible, because you would want to see the dive list and move between dives while at the same time also seeing the dive profile change. But that is solvable by simply making the dive list notebook page be detachable, so if you have a nice big screen, just detach the dive list page and now you have independent windows for the dive list and the dive info. NOTE! I don't have any way to re-attach the dang thing. I think I'd need to learn about drag-and-drop targets etc. So once you've detached the dive list, it stays detached. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 17:38:07 +00:00
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 6);
Keep window size for new notebook pages We used to set a fixed size instead of just copying the size that the existing notebook has - which didn't really feel right when resizing and then ripping of a page. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-20 10:04:18 +00:00
gtk_widget_get_allocation(page, &allocation);
gtk_widget_set_size_request(notebook, allocation.width, allocation.height);
Make the dive list start as a plain notebook page I've been wondering how to make 'subsurface' work better on a small screen (I used to travel with a crappy netbook - I may have upgraded my laptop since, but it is still a design goal of mine to make sure it all works fine in that kind of environment). And ever since the dive list was made much wider and moved below the notebook, it's annoyed me how much room it all takes if I want to have both a reasonable plot window and several dives visible at the same time. The solution seems to be to just make the dive list be a notebook page. That makes the default layout very dense. At the same time, when you have the pixels, it's horrible, because you would want to see the dive list and move between dives while at the same time also seeing the dive profile change. But that is solvable by simply making the dive list notebook page be detachable, so if you have a nice big screen, just detach the dive list page and now you have independent windows for the dive list and the dive info. NOTE! I don't have any way to re-attach the dang thing. I think I'd need to learn about drag-and-drop targets etc. So once you've detached the dive list, it stays detached. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 17:38:07 +00:00
gtk_widget_show_all(win);
return GTK_NOTEBOOK(notebook);
}
Add drag-n-drop support to be able to re-integrate the dive list This is somewhat hacky, and there is clearly something I still don't understand about gtk selections and drag-n-drop. Dropping it back works, but I get a nasty error when I do it: (subsurface:8512): Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed even though I actually never set any selection at all directly. So there must be some internal gtk rule that I am violating, but I can't see what it is. I probably shouldn't commit it with a known ugly wart like that, but I really have no clue. Maybe somebody else can figure out what is up. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 19:54:53 +00:00
static void drag_cb(GtkWidget *widget, GdkDragContext *context,
The notebook pages can only be dropped back into the main notebook Disable the secondary notebooks that are created when ripping off a page (dive_list or dive_profile) as drop targets for other pages. Also fix the incorrect arguments for the drag callback function. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-28 02:47:19 +00:00
gint x, gint y, guint time,
Add drag-n-drop support to be able to re-integrate the dive list This is somewhat hacky, and there is clearly something I still don't understand about gtk selections and drag-n-drop. Dropping it back works, but I get a nasty error when I do it: (subsurface:8512): Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed even though I actually never set any selection at all directly. So there must be some internal gtk rule that I am violating, but I can't see what it is. I probably shouldn't commit it with a known ugly wart like that, but I really have no clue. Maybe somebody else can figure out what is up. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 19:54:53 +00:00
gpointer user_data)
{
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
GtkWidget *source;
notebook_data_t *nbdp;
Add drag-n-drop support to be able to re-integrate the dive list This is somewhat hacky, and there is clearly something I still don't understand about gtk selections and drag-n-drop. Dropping it back works, but I get a nasty error when I do it: (subsurface:8512): Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed even though I actually never set any selection at all directly. So there must be some internal gtk rule that I am violating, but I can't see what it is. I probably shouldn't commit it with a known ugly wart like that, but I really have no clue. Maybe somebody else can figure out what is up. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 19:54:53 +00:00
source = gtk_drag_get_source_widget(context);
Use the correct signal to avoid Gtk-CRITICAL error message We used the wrong signal - "data-drag-received" is intended to check whether the target will accept the drop. What we want is the "drag-drop" signal which tells the widget that something was dropped on it. Also fix an embarrassing lack of NULL pointer checks in my string comparisons... Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-28 00:03:15 +00:00
if (nbd[0].name && ! strcmp(nbd[0].name,gtk_widget_get_name(source)))
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
nbdp = nbd;
Use the correct signal to avoid Gtk-CRITICAL error message We used the wrong signal - "data-drag-received" is intended to check whether the target will accept the drop. What we want is the "drag-drop" signal which tells the widget that something was dropped on it. Also fix an embarrassing lack of NULL pointer checks in my string comparisons... Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-28 00:03:15 +00:00
else if (nbd[1].name && ! strcmp(nbd[1].name,gtk_widget_get_name(source)))
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
nbdp = nbd + 1;
else
/* HU? */
return;
Add drag-n-drop support to be able to re-integrate the dive list This is somewhat hacky, and there is clearly something I still don't understand about gtk selections and drag-n-drop. Dropping it back works, but I get a nasty error when I do it: (subsurface:8512): Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed even though I actually never set any selection at all directly. So there must be some internal gtk rule that I am violating, but I can't see what it is. I probably shouldn't commit it with a known ugly wart like that, but I really have no clue. Maybe somebody else can figure out what is up. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 19:54:53 +00:00
gtk_drag_finish(context, TRUE, TRUE, time);
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
/* we no longer need the widget - but getting rid of this is hard;
* remove the signal handler, remove the notebook from the box
* then destroy the widget (and clear out our data structure) */
g_signal_handler_disconnect(nbdp->widget,nbdp->delete_handler);
g_signal_handler_disconnect(nbdp->widget,nbdp->destroy_handler);
gtk_container_remove(GTK_CONTAINER(nbdp->box), source);
gtk_widget_destroy(nbdp->widget);
nbdp->widget = NULL;
free(nbdp->name);
nbdp->name = NULL;
Add drag-n-drop support to be able to re-integrate the dive list This is somewhat hacky, and there is clearly something I still don't understand about gtk selections and drag-n-drop. Dropping it back works, but I get a nasty error when I do it: (subsurface:8512): Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed even though I actually never set any selection at all directly. So there must be some internal gtk rule that I am violating, but I can't see what it is. I probably shouldn't commit it with a known ugly wart like that, but I really have no clue. Maybe somebody else can figure out what is up. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 19:54:53 +00:00
}
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
void init_ui(int argc, char **argv)
{
GtkWidget *win;
GtkWidget *notebook;
GtkWidget *dive_info;
GtkWidget *dive_list;
GtkWidget *equipment;
GtkWidget *menubar;
GtkWidget *vbox;
Have "make install" act more as expected for a desktop application I'm trying to get subsurface to get closer to becoming a "regular desktop application"; so far this is based on the recommendations and guidelines on OpenSUSE and Fedora. The icon is now named subsurface.svg and make install installs it in the correct location. At runtime subsurface first checks if an icon is installed and if it is it uses that - otherwise it falls back to the old code that tries to read the svg file from the current directory. We also install a subsurface.desktop file Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-11 22:58:38 +00:00
GdkScreen *screen;
GtkIconTheme *icon_theme=NULL;
Shorten the tooltip timeout Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-04 23:06:27 +00:00
GtkSettings *settings;
Add drag-n-drop support to be able to re-integrate the dive list This is somewhat hacky, and there is clearly something I still don't understand about gtk selections and drag-n-drop. Dropping it back works, but I get a nasty error when I do it: (subsurface:8512): Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed even though I actually never set any selection at all directly. So there must be some internal gtk rule that I am violating, but I can't see what it is. I probably shouldn't commit it with a known ugly wart like that, but I really have no clue. Maybe somebody else can figure out what is up. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 19:54:53 +00:00
static const GtkTargetEntry notebook_target = {
"GTK_NOTEBOOK_TAB", GTK_TARGET_SAME_APP, 0
};
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
gtk_init(&argc, &argv);
Shorten the tooltip timeout Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-04 23:06:27 +00:00
settings = gtk_settings_get_default();
gtk_settings_set_long_property(settings, "gtk_tooltip_timeout", 10, "subsurface setting");
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
g_type_init();
gconf = gconf_client_get_default();
if (gconf_client_get_bool(gconf, GCONF_NAME(feet), NULL))
output_units.length = FEET;
if (gconf_client_get_bool(gconf, GCONF_NAME(psi), NULL))
output_units.pressure = PSI;
if (gconf_client_get_bool(gconf, GCONF_NAME(cuft), NULL))
output_units.volume = CUFT;
if (gconf_client_get_bool(gconf, GCONF_NAME(fahrenheit), NULL))
output_units.temperature = FAHRENHEIT;
Store options in gconf While it's not the most elegant way to do this I opted to store the options with "inverted polarity" - i.e., the options that are supposed to default to "True" are stored inverted since gconf reports an unset option (first time the user runs the program) as "False". Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 17:46:59 +00:00
/* an unset key is FALSE - so in order to get the default behavior right we
invert the meaning of the SAC key */
visible_cols.otu = gconf_client_get_bool(gconf, GCONF_NAME(OTU), NULL);
visible_cols.sac = ! gconf_client_get_bool(gconf, GCONF_NAME(SAC), NULL);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
divelist_font = gconf_client_get_string(gconf, GCONF_NAME(divelist_font), NULL);
if (!divelist_font)
divelist_font = DIVELIST_DEFAULT_FONT;
error_info_bar = NULL;
win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
Have "make install" act more as expected for a desktop application I'm trying to get subsurface to get closer to becoming a "regular desktop application"; so far this is based on the recommendations and guidelines on OpenSUSE and Fedora. The icon is now named subsurface.svg and make install installs it in the correct location. At runtime subsurface first checks if an icon is installed and if it is it uses that - otherwise it falls back to the old code that tries to read the svg file from the current directory. We also install a subsurface.desktop file Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-11 22:58:38 +00:00
g_set_application_name ("subsurface");
/* Let's check if the subsurface icon has been installed or if
* we need to try to load it from the current directory */
screen = gdk_screen_get_default();
if (screen)
icon_theme = gtk_icon_theme_get_for_screen(screen);
if (icon_theme) {
if (gtk_icon_theme_has_icon(icon_theme, "subsurface")) {
need_icon = FALSE;
gtk_window_set_default_icon_name ("subsurface");
}
}
if (need_icon)
gtk_window_set_icon_from_file(GTK_WINDOW(win), "subsurface.svg", NULL);
Make the dive list start as a plain notebook page I've been wondering how to make 'subsurface' work better on a small screen (I used to travel with a crappy netbook - I may have upgraded my laptop since, but it is still a design goal of mine to make sure it all works fine in that kind of environment). And ever since the dive list was made much wider and moved below the notebook, it's annoyed me how much room it all takes if I want to have both a reasonable plot window and several dives visible at the same time. The solution seems to be to just make the dive list be a notebook page. That makes the default layout very dense. At the same time, when you have the pixels, it's horrible, because you would want to see the dive list and move between dives while at the same time also seeing the dive profile change. But that is solvable by simply making the dive list notebook page be detachable, so if you have a nice big screen, just detach the dive list page and now you have independent windows for the dive list and the dive info. NOTE! I don't have any way to re-attach the dang thing. I think I'd need to learn about drag-and-drop targets etc. So once you've detached the dive list, it stays detached. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 17:38:07 +00:00
g_signal_connect(G_OBJECT(win), "delete-event", G_CALLBACK(on_delete), NULL);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
g_signal_connect(G_OBJECT(win), "destroy", G_CALLBACK(on_destroy), NULL);
main_window = win;
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(win), vbox);
main_vbox = vbox;
menubar = get_menubar_menu(win);
gtk_box_pack_start(GTK_BOX(vbox), menubar, FALSE, FALSE, 0);
/* Notebook for dive info vs profile vs .. */
notebook = gtk_notebook_new();
Make the dive list start as a plain notebook page I've been wondering how to make 'subsurface' work better on a small screen (I used to travel with a crappy netbook - I may have upgraded my laptop since, but it is still a design goal of mine to make sure it all works fine in that kind of environment). And ever since the dive list was made much wider and moved below the notebook, it's annoyed me how much room it all takes if I want to have both a reasonable plot window and several dives visible at the same time. The solution seems to be to just make the dive list be a notebook page. That makes the default layout very dense. At the same time, when you have the pixels, it's horrible, because you would want to see the dive list and move between dives while at the same time also seeing the dive profile change. But that is solvable by simply making the dive list notebook page be detachable, so if you have a nice big screen, just detach the dive list page and now you have independent windows for the dive list and the dive info. NOTE! I don't have any way to re-attach the dang thing. I think I'd need to learn about drag-and-drop targets etc. So once you've detached the dive list, it stays detached. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 17:38:07 +00:00
gtk_box_pack_start(GTK_BOX(vbox), notebook, TRUE, TRUE, 6);
Linus would like to be less on the bleeding edge of Gtk+ So we go back to the old interfaces to identify the notebook as part of one group - the one that was just recently deprecated Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-28 00:11:08 +00:00
gtk_notebook_set_group(GTK_NOTEBOOK(notebook), GRP_ID);
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
g_signal_connect(notebook, "create-window", G_CALLBACK(create_new_notebook_window), NULL);
Add drag-n-drop support to be able to re-integrate the dive list This is somewhat hacky, and there is clearly something I still don't understand about gtk selections and drag-n-drop. Dropping it back works, but I get a nasty error when I do it: (subsurface:8512): Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed even though I actually never set any selection at all directly. So there must be some internal gtk rule that I am violating, but I can't see what it is. I probably shouldn't commit it with a known ugly wart like that, but I really have no clue. Maybe somebody else can figure out what is up. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 19:54:53 +00:00
gtk_drag_dest_set(notebook, GTK_DEST_DEFAULT_ALL, &notebook_target, 1, GDK_ACTION_MOVE);
Use the correct signal to avoid Gtk-CRITICAL error message We used the wrong signal - "data-drag-received" is intended to check whether the target will accept the drop. What we want is the "drag-drop" signal which tells the widget that something was dropped on it. Also fix an embarrassing lack of NULL pointer checks in my string comparisons... Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-28 00:03:15 +00:00
g_signal_connect(notebook, "drag-drop", G_CALLBACK(drag_cb), notebook);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
g_signal_connect(notebook, "switch-page", G_CALLBACK(switch_page), NULL);
Make the dive list start as a plain notebook page I've been wondering how to make 'subsurface' work better on a small screen (I used to travel with a crappy netbook - I may have upgraded my laptop since, but it is still a design goal of mine to make sure it all works fine in that kind of environment). And ever since the dive list was made much wider and moved below the notebook, it's annoyed me how much room it all takes if I want to have both a reasonable plot window and several dives visible at the same time. The solution seems to be to just make the dive list be a notebook page. That makes the default layout very dense. At the same time, when you have the pixels, it's horrible, because you would want to see the dive list and move between dives while at the same time also seeing the dive profile change. But that is solvable by simply making the dive list notebook page be detachable, so if you have a nice big screen, just detach the dive list page and now you have independent windows for the dive list and the dive info. NOTE! I don't have any way to re-attach the dang thing. I think I'd need to learn about drag-and-drop targets etc. So once you've detached the dive list, it stays detached. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 17:38:07 +00:00
/* Create the actual divelist */
dive_list = dive_list_create();
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
gtk_widget_set_name(dive_list, "Dive List");
Make the dive list start as a plain notebook page I've been wondering how to make 'subsurface' work better on a small screen (I used to travel with a crappy netbook - I may have upgraded my laptop since, but it is still a design goal of mine to make sure it all works fine in that kind of environment). And ever since the dive list was made much wider and moved below the notebook, it's annoyed me how much room it all takes if I want to have both a reasonable plot window and several dives visible at the same time. The solution seems to be to just make the dive list be a notebook page. That makes the default layout very dense. At the same time, when you have the pixels, it's horrible, because you would want to see the dive list and move between dives while at the same time also seeing the dive profile change. But that is solvable by simply making the dive list notebook page be detachable, so if you have a nice big screen, just detach the dive list page and now you have independent windows for the dive list and the dive info. NOTE! I don't have any way to re-attach the dang thing. I think I'd need to learn about drag-and-drop targets etc. So once you've detached the dive list, it stays detached. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 17:38:07 +00:00
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), dive_list, gtk_label_new("Dive List"));
gtk_notebook_set_tab_detachable(GTK_NOTEBOOK(notebook), dive_list, 1);
Add drag-n-drop support to be able to re-integrate the dive list This is somewhat hacky, and there is clearly something I still don't understand about gtk selections and drag-n-drop. Dropping it back works, but I get a nasty error when I do it: (subsurface:8512): Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed even though I actually never set any selection at all directly. So there must be some internal gtk rule that I am violating, but I can't see what it is. I probably shouldn't commit it with a known ugly wart like that, but I really have no clue. Maybe somebody else can figure out what is up. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-27 19:54:53 +00:00
gtk_notebook_set_tab_reorderable(GTK_NOTEBOOK(notebook), dive_list, 1);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
/* Frame for dive profile */
dive_profile = dive_profile_widget();
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
gtk_widget_set_name(dive_profile, "Dive Profile");
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), dive_profile, gtk_label_new("Dive Profile"));
Clean up the drag and drop code and allow ripping off the Dive Profile Linus had used some deprecated interfcase and didn't correctly untangle the new window that he created (hiding it the window... very nifty). I think I'm closer to the real solution with a data structure that keeps track of the components of the new top level window that I need to be able to untangle (and eventually, destroy) at the end. The one error I also can't seem to get rid of is the Clean up the drag and drop code and allow ripping of the Dive Profile Gtk-CRITICAL **: IA__gtk_selection_data_set: assertion `length <= 0' failed Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-27 23:23:59 +00:00
gtk_notebook_set_tab_detachable(GTK_NOTEBOOK(notebook), dive_profile, 1);
gtk_notebook_set_tab_reorderable(GTK_NOTEBOOK(notebook), dive_profile, 1);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
/* Frame for extended dive info */
dive_info = extended_dive_info_widget();
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), dive_info, gtk_label_new("Dive Notes"));
/* Frame for dive equipment */
equipment = equipment_widget();
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), equipment, gtk_label_new("Equipment"));
gtk_widget_set_app_paintable(win, TRUE);
gtk_widget_show_all(win);
return;
}
void run_ui(void)
{
gtk_main();
}
Replace event text with small red triangle and tooltip We draw a little red triangle (of hardcoded size - not sure if this SHOULD scale with the size of the plot... I like it better if it doesn't) to the left of an event. We then maintain an array of rectangles that each circumscribe one of those event triangles and if the mouse pointer enters one of these rectangles then we display (after a short delay) a tooltip with the event text. Manually creating these rectangles, maintaining the coordinate offset, checking if we are inside one of these rectangles and then showing a tooltip... this all seems like there should be gtk functions to do this by default... but if there are then I failed to find them. So instead I manually implemented the necessary logic. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-04 19:27:55 +00:00
typedef struct {
cairo_rectangle_int_t rect;
const char *text;
} tooltip_record_t;
static tooltip_record_t *tooltip_rects;
static int tooltips;
void attach_tooltip(int x, int y, int w, int h, const char *text)
{
cairo_rectangle_int_t *rect;
tooltip_rects = realloc(tooltip_rects, (tooltips + 1) * sizeof(tooltip_record_t));
rect = &tooltip_rects[tooltips].rect;
rect->x = x;
rect->y = y;
rect->width = w;
rect->height = h;
tooltip_rects[tooltips].text = text;
tooltips++;
}
#define INSIDE_RECT(_r,_x,_y) ((_r.x <= _x) && (_r.x + _r.width >= _x) && \
(_r.y <= _y) && (_r.y + _r.height >= _y))
static gboolean profile_tooltip (GtkWidget *widget, gint x, gint y,
gboolean keyboard_mode, GtkTooltip *tooltip, gpointer user_data)
{
int i;
cairo_rectangle_int_t *drawing_area = user_data;
gint tx = x - drawing_area->x; /* get transformed coordinates */
gint ty = y - drawing_area->y;
/* are we over an event marker ? */
for (i = 0; i < tooltips; i++) {
if (INSIDE_RECT(tooltip_rects[i].rect, tx, ty)) {
gtk_tooltip_set_text(tooltip,tooltip_rects[i].text);
return TRUE; /* show tooltip */
}
}
return FALSE; /* don't show tooltip */
}
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
static gboolean expose_event(GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
struct dive *dive = current_dive;
struct graphics_context gc = { .printer = 0 };
Change plot routine to take a drawing_area as argument Previously we passed in width and height and the routine itself decided to keep 5% margin around each edge - oddly doing this with double precision, even though this is all integer coordinates. Instead we are now passing in a drawing_area. We are kind of abusing the cairo_rectangle_int_t data type here - but it seemed silly to redefine a new data type for this. Width and height give the size of the TOTAL drawing area (as before). x and y give the offset from the edges - so the EFFECTIVE drawing area is width-2x and height-2y This is in preparation for adding tooltips - those need to know the coordinate offsets from the edges - so having this hard coded inside the plot function didn't make sense anymore. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-04 19:14:26 +00:00
static cairo_rectangle_int_t drawing_area;
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
Change plot routine to take a drawing_area as argument Previously we passed in width and height and the routine itself decided to keep 5% margin around each edge - oddly doing this with double precision, even though this is all integer coordinates. Instead we are now passing in a drawing_area. We are kind of abusing the cairo_rectangle_int_t data type here - but it seemed silly to redefine a new data type for this. Width and height give the size of the TOTAL drawing area (as before). x and y give the offset from the edges - so the EFFECTIVE drawing area is width-2x and height-2y This is in preparation for adding tooltips - those need to know the coordinate offsets from the edges - so having this hard coded inside the plot function didn't make sense anymore. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-04 19:14:26 +00:00
/* the drawing area gives TOTAL width * height - x,y is used as the topx/topy offset
* so effective drawing area is width-2x * height-2y */
drawing_area.width = widget->allocation.width;
drawing_area.height = widget->allocation.height;
drawing_area.x = drawing_area.width / 20.0;
drawing_area.y = drawing_area.height / 20.0;
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
gc.cr = gdk_cairo_create(widget->window);
Replace event text with small red triangle and tooltip We draw a little red triangle (of hardcoded size - not sure if this SHOULD scale with the size of the plot... I like it better if it doesn't) to the left of an event. We then maintain an array of rectangles that each circumscribe one of those event triangles and if the mouse pointer enters one of these rectangles then we display (after a short delay) a tooltip with the event text. Manually creating these rectangles, maintaining the coordinate offset, checking if we are inside one of these rectangles and then showing a tooltip... this all seems like there should be gtk functions to do this by default... but if there are then I failed to find them. So instead I manually implemented the necessary logic. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-04 19:27:55 +00:00
g_object_set(widget, "has-tooltip", TRUE, NULL);
g_signal_connect(widget, "query-tooltip", G_CALLBACK(profile_tooltip), &drawing_area);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
set_source_rgb(&gc, 0, 0, 0);
cairo_paint(gc.cr);
Replace event text with small red triangle and tooltip We draw a little red triangle (of hardcoded size - not sure if this SHOULD scale with the size of the plot... I like it better if it doesn't) to the left of an event. We then maintain an array of rectangles that each circumscribe one of those event triangles and if the mouse pointer enters one of these rectangles then we display (after a short delay) a tooltip with the event text. Manually creating these rectangles, maintaining the coordinate offset, checking if we are inside one of these rectangles and then showing a tooltip... this all seems like there should be gtk functions to do this by default... but if there are then I failed to find them. So instead I manually implemented the necessary logic. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-04 19:27:55 +00:00
if (dive) {
if (tooltip_rects) {
free(tooltip_rects);
tooltip_rects = NULL;
}
tooltips = 0;
Change plot routine to take a drawing_area as argument Previously we passed in width and height and the routine itself decided to keep 5% margin around each edge - oddly doing this with double precision, even though this is all integer coordinates. Instead we are now passing in a drawing_area. We are kind of abusing the cairo_rectangle_int_t data type here - but it seemed silly to redefine a new data type for this. Width and height give the size of the TOTAL drawing area (as before). x and y give the offset from the edges - so the EFFECTIVE drawing area is width-2x and height-2y This is in preparation for adding tooltips - those need to know the coordinate offsets from the edges - so having this hard coded inside the plot function didn't make sense anymore. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-04 19:14:26 +00:00
plot(&gc, &drawing_area, dive);
Replace event text with small red triangle and tooltip We draw a little red triangle (of hardcoded size - not sure if this SHOULD scale with the size of the plot... I like it better if it doesn't) to the left of an event. We then maintain an array of rectangles that each circumscribe one of those event triangles and if the mouse pointer enters one of these rectangles then we display (after a short delay) a tooltip with the event text. Manually creating these rectangles, maintaining the coordinate offset, checking if we are inside one of these rectangles and then showing a tooltip... this all seems like there should be gtk functions to do this by default... but if there are then I failed to find them. So instead I manually implemented the necessary logic. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-04 19:27:55 +00:00
}
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
cairo_destroy(gc.cr);
return FALSE;
}
GtkWidget *dive_profile_widget(void)
{
GtkWidget *da;
da = gtk_drawing_area_new();
gtk_widget_set_size_request(da, 350, 250);
g_signal_connect(da, "expose_event", G_CALLBACK(expose_event), NULL);
return da;
}
int process_ui_events(void)
{
int ret=0;
while (gtk_events_pending()) {
if (gtk_main_iteration_do(0)) {
ret = 1;
break;
}
}
return(ret);
}
static void fill_computer_list(GtkListStore *store)
{
GtkTreeIter iter;
struct device_list *list = device_list;
for (list = device_list ; list->name ; list++) {
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter,
0, list->name,
1, list->type,
-1);
}
}
Add a "Dive Computer" frame around the dive computer choice in import I'll add a widget to allow the user to select the device too, so let's name things to make them more obvious. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-26 16:19:30 +00:00
static GtkComboBox *dive_computer_selector(GtkWidget *vbox)
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
{
Add a "Dive Computer" frame around the dive computer choice in import I'll add a widget to allow the user to select the device too, so let's name things to make them more obvious. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-26 16:19:30 +00:00
GtkWidget *hbox, *combo_box, *frame;
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
GtkListStore *model;
GtkCellRenderer *renderer;
hbox = gtk_hbox_new(FALSE, 6);
Use 'gtk_dialog_get_content_area()' instead of accessing dialog directly I'm reading gtk docs, and trying to clean things up a bit. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-24 22:26:37 +00:00
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
model = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_INT);
fill_computer_list(model);
Add a "Dive Computer" frame around the dive computer choice in import I'll add a widget to allow the user to select the device too, so let's name things to make them more obvious. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-26 16:19:30 +00:00
frame = gtk_frame_new("Dive computer");
gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, TRUE, 3);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
combo_box = gtk_combo_box_new_with_model(GTK_TREE_MODEL(model));
Add a "Dive Computer" frame around the dive computer choice in import I'll add a widget to allow the user to select the device too, so let's name things to make them more obvious. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-26 16:19:30 +00:00
gtk_container_add(GTK_CONTAINER(frame), combo_box);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
renderer = gtk_cell_renderer_text_new();
gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo_box), renderer, TRUE);
gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo_box), renderer, "text", 0, NULL);
return GTK_COMBO_BOX(combo_box);
}
Add a GtkEntry to allow editing of the device name Ok, so some file chooser widget with a popup dialog would have been more professional, but I'm lazy. Plus I suspect the popup would look horrible when populated with /dev entries, and I don't think there is any sane filter function. So this works, and means that you don't *have* to recompile the whole program just because you have your dive computer on something else than a USB serial line. I suspect I should save the default name as a config variable too. Maybe a setting in the preferences dialog. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-26 16:44:27 +00:00
static GtkEntry *dive_computer_device(GtkWidget *vbox)
{
GtkWidget *hbox, *entry, *frame;
hbox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
frame = gtk_frame_new("Device name");
gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, TRUE, 3);
entry = gtk_entry_new();
gtk_container_add(GTK_CONTAINER(frame), entry);
gtk_entry_set_text(GTK_ENTRY(entry), "/dev/ttyUSB0");
return GTK_ENTRY(entry);
}
Make FileChooserButton end import dialog If we choose a file in the import dialog then this should imply clicking OK in that dialog - no reason for a two step process. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-05 21:12:03 +00:00
/* once a file is selected in the FileChooserButton we want to exit the import dialog */
static void on_file_set(GtkFileChooserButton *widget, gpointer _data)
{
GtkDialog *main_dialog = _data;
gtk_dialog_response(main_dialog, GTK_RESPONSE_ACCEPT);
}
static GtkWidget *xml_file_selector(GtkWidget *vbox, GtkWidget *main_dialog)
Add XML file import back and treat open and import differently Open (or adding a file name on the command line) means that this is just one of the files that you consider part of your dive history. So dives don't get automagically numbered and the dive_list is not considered "changed" just because another file was opened. Import (or adding a file on the command line after --import) means that you are importing the content of this file to your dive history. So if the imported file has un-numbered dives that are newer than everything else, those get correctly renumbered. And importing marks the dive_list as changed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-05 18:36:15 +00:00
{
GtkWidget *hbox, *frame, *chooser, *dialog;
GtkFileFilter *filter;
hbox = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 3);
frame = gtk_frame_new("XML file name");
gtk_box_pack_start(GTK_BOX(hbox), frame, FALSE, TRUE, 3);
dialog = gtk_file_chooser_dialog_new("Open XML File",
GTK_WINDOW(main_window),
GTK_FILE_CHOOSER_ACTION_OPEN,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
NULL);
Mark the FileChooserButton as UNABLE to select multiple files That's a gtk limitation. So you have to import XML files one at a time. If this is too big of a restriction then we need to redesign the import dialog. Sgned-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-05 21:16:51 +00:00
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(dialog), FALSE);
Add XML file import back and treat open and import differently Open (or adding a file name on the command line) means that this is just one of the files that you consider part of your dive history. So dives don't get automagically numbered and the dive_list is not considered "changed" just because another file was opened. Import (or adding a file on the command line after --import) means that you are importing the content of this file to your dive history. So if the imported file has un-numbered dives that are newer than everything else, those get correctly renumbered. And importing marks the dive_list as changed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-05 18:36:15 +00:00
filter = gtk_file_filter_new();
gtk_file_filter_add_pattern(filter, "*.xml");
gtk_file_filter_add_pattern(filter, "*.XML");
gtk_file_filter_add_pattern(filter, "*.sda");
gtk_file_filter_add_pattern(filter, "*.SDA");
gtk_file_filter_add_mime_type(filter, "text/xml");
gtk_file_filter_set_name(filter, "XML file");
gtk_file_chooser_set_filter(GTK_FILE_CHOOSER(dialog), filter);
chooser = gtk_file_chooser_button_new_with_dialog(dialog);
Make FileChooserButton end import dialog If we choose a file in the import dialog then this should imply clicking OK in that dialog - no reason for a two step process. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-05 21:12:03 +00:00
g_signal_connect(G_OBJECT(chooser), "file-set", G_CALLBACK(on_file_set), main_dialog);
Add XML file import back and treat open and import differently Open (or adding a file name on the command line) means that this is just one of the files that you consider part of your dive history. So dives don't get automagically numbered and the dive_list is not considered "changed" just because another file was opened. Import (or adding a file on the command line after --import) means that you are importing the content of this file to your dive history. So if the imported file has un-numbered dives that are newer than everything else, those get correctly renumbered. And importing marks the dive_list as changed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-05 18:36:15 +00:00
gtk_file_chooser_button_set_width_chars(GTK_FILE_CHOOSER_BUTTON(chooser), 30);
gtk_container_add(GTK_CONTAINER(frame), chooser);
return chooser;
}
static void do_import_file(gpointer data, gpointer user_data)
{
GError *error = NULL;
Remove some useless casts from and to void pointers Remove casts from/to void*. They are unneeded in C, can hide problems in the future, and are far too C++ish. Furthermore, they were inconsistent with the rest of the code and even with regards to themselves (at least in terms of whether or not to have space after the cast). In this case, we temporarily lose const specifiers in libdivecomputer.c due to the unneeded cast, so it seems better to avoid the cast at all, so you get warned about a const->non-const cast if you ever change it to do something like this. The casts in gtk-gui.c are just useless semantically, although they might be useful as a hint to the reader that the void pointers are char arrays. Signed-off-by: Julian Andres Klode <jak@jak-linux.org> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-10-06 19:08:48 +00:00
parse_xml_file(data, &error);
Add XML file import back and treat open and import differently Open (or adding a file name on the command line) means that this is just one of the files that you consider part of your dive history. So dives don't get automagically numbered and the dive_list is not considered "changed" just because another file was opened. Import (or adding a file on the command line after --import) means that you are importing the content of this file to your dive history. So if the imported file has un-numbered dives that are newer than everything else, those get correctly renumbered. And importing marks the dive_list as changed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-05 18:36:15 +00:00
if (error != NULL)
{
report_error(error);
g_error_free(error);
error = NULL;
}
}
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
void import_dialog(GtkWidget *w, gpointer data)
{
int result;
Add XML file import back and treat open and import differently Open (or adding a file name on the command line) means that this is just one of the files that you consider part of your dive history. So dives don't get automagically numbered and the dive_list is not considered "changed" just because another file was opened. Import (or adding a file on the command line after --import) means that you are importing the content of this file to your dive history. So if the imported file has un-numbered dives that are newer than everything else, those get correctly renumbered. And importing marks the dive_list as changed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-05 18:36:15 +00:00
GtkWidget *dialog, *hbox, *vbox, *label;
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
GtkComboBox *computer;
Add a GtkEntry to allow editing of the device name Ok, so some file chooser widget with a popup dialog would have been more professional, but I'm lazy. Plus I suspect the popup would look horrible when populated with /dev entries, and I don't think there is any sane filter function. So this works, and means that you don't *have* to recompile the whole program just because you have your dive computer on something else than a USB serial line. I suspect I should save the default name as a config variable too. Maybe a setting in the preferences dialog. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-26 16:44:27 +00:00
GtkEntry *device;
Add XML file import back and treat open and import differently Open (or adding a file name on the command line) means that this is just one of the files that you consider part of your dive history. So dives don't get automagically numbered and the dive_list is not considered "changed" just because another file was opened. Import (or adding a file on the command line after --import) means that you are importing the content of this file to your dive history. So if the imported file has un-numbered dives that are newer than everything else, those get correctly renumbered. And importing marks the dive_list as changed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-05 18:36:15 +00:00
GtkWidget *XMLchooser;
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
device_data_t devicedata = {
Add a GtkEntry to allow editing of the device name Ok, so some file chooser widget with a popup dialog would have been more professional, but I'm lazy. Plus I suspect the popup would look horrible when populated with /dev entries, and I don't think there is any sane filter function. So this works, and means that you don't *have* to recompile the whole program just because you have your dive computer on something else than a USB serial line. I suspect I should save the default name as a config variable too. Maybe a setting in the preferences dialog. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-26 16:44:27 +00:00
.devname = NULL,
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
};
dialog = gtk_dialog_new_with_buttons("Import from dive computer",
GTK_WINDOW(main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
NULL);
Add a "Dive Computer" frame around the dive computer choice in import I'll add a widget to allow the user to select the device too, so let's name things to make them more obvious. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-26 16:19:30 +00:00
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
Add XML file import back and treat open and import differently Open (or adding a file name on the command line) means that this is just one of the files that you consider part of your dive history. So dives don't get automagically numbered and the dive_list is not considered "changed" just because another file was opened. Import (or adding a file on the command line after --import) means that you are importing the content of this file to your dive history. So if the imported file has un-numbered dives that are newer than everything else, those get correctly renumbered. And importing marks the dive_list as changed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-05 18:36:15 +00:00
label = gtk_label_new("Import: \nLoad XML file or import directly from dive computer");
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, TRUE, 3);
Make FileChooserButton end import dialog If we choose a file in the import dialog then this should imply clicking OK in that dialog - no reason for a two step process. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-05 21:12:03 +00:00
XMLchooser = xml_file_selector(vbox, dialog);
Add a "Dive Computer" frame around the dive computer choice in import I'll add a widget to allow the user to select the device too, so let's name things to make them more obvious. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-26 16:19:30 +00:00
computer = dive_computer_selector(vbox);
Add a GtkEntry to allow editing of the device name Ok, so some file chooser widget with a popup dialog would have been more professional, but I'm lazy. Plus I suspect the popup would look horrible when populated with /dev entries, and I don't think there is any sane filter function. So this works, and means that you don't *have* to recompile the whole program just because you have your dive computer on something else than a USB serial line. I suspect I should save the default name as a config variable too. Maybe a setting in the preferences dialog. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-26 16:44:27 +00:00
device = dive_computer_device(vbox);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
hbox = gtk_hbox_new(FALSE, 6);
Use 'gtk_dialog_get_content_area()' instead of accessing dialog directly I'm reading gtk docs, and trying to clean things up a bit. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-24 22:26:37 +00:00
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 3);
Fix progress bar during libdivecomputer imports As reported by Mauro Dreissig, the progress bar doesn't work and causes a SIGSEGV due to a missing allocation. The code broke when Dirk separated out the GUI from the core code, and I hadn't tried divecomputer downloads since. Reported-by: Mauro Dreissig <mukadr@gmail.com> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-09-22 23:38:24 +00:00
devicedata.progress.bar = gtk_progress_bar_new();
gtk_container_add(GTK_CONTAINER(hbox), devicedata.progress.bar);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
gtk_widget_show_all(dialog);
result = gtk_dialog_run(GTK_DIALOG(dialog));
switch (result) {
int type;
GtkTreeIter iter;
GtkTreeModel *model;
const char *comp;
Add XML file import back and treat open and import differently Open (or adding a file name on the command line) means that this is just one of the files that you consider part of your dive history. So dives don't get automagically numbered and the dive_list is not considered "changed" just because another file was opened. Import (or adding a file on the command line after --import) means that you are importing the content of this file to your dive history. So if the imported file has un-numbered dives that are newer than everything else, those get correctly renumbered. And importing marks the dive_list as changed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-05 18:36:15 +00:00
GSList *list;
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
case GTK_RESPONSE_ACCEPT:
Add XML file import back and treat open and import differently Open (or adding a file name on the command line) means that this is just one of the files that you consider part of your dive history. So dives don't get automagically numbered and the dive_list is not considered "changed" just because another file was opened. Import (or adding a file on the command line after --import) means that you are importing the content of this file to your dive history. So if the imported file has un-numbered dives that are newer than everything else, those get correctly renumbered. And importing marks the dive_list as changed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-05 18:36:15 +00:00
/* what happened - did the user pick a file? In that case
* we ignore whether a dive computer model was picked */
list = gtk_file_chooser_get_filenames(GTK_FILE_CHOOSER(XMLchooser));
if (g_slist_length(list) == 0) {
if (!gtk_combo_box_get_active_iter(computer, &iter))
break;
model = gtk_combo_box_get_model(computer);
gtk_tree_model_get(model, &iter,
0, &comp,
1, &type,
-1);
devicedata.type = type;
devicedata.name = comp;
devicedata.devname = gtk_entry_get_text(device);
do_import(&devicedata);
} else {
g_slist_foreach(list,do_import_file,NULL);
g_slist_free(list);
}
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
break;
default:
break;
}
gtk_widget_destroy(dialog);
Add XML file import back and treat open and import differently Open (or adding a file name on the command line) means that this is just one of the files that you consider part of your dive history. So dives don't get automagically numbered and the dive_list is not considered "changed" just because another file was opened. Import (or adding a file on the command line after --import) means that you are importing the content of this file to your dive history. So if the imported file has un-numbered dives that are newer than everything else, those get correctly renumbered. And importing marks the dive_list as changed. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-05 18:36:15 +00:00
report_dives(TRUE);
Separate out the UI from the program logic The following are UI toolkit specific: gtk-gui.c - overall layout, main window of the UI divelist.c - list of dives subsurface maintains equipment.c - equipment / tank information for each dive info.c - detailed dive info print.c - printing The rest is independent of the UI: main.c i - program frame dive.c i - creates and maintaines the internal dive list structure libdivecomputer.c uemis.c parse-xml.c save-xml.c - interface with dive computers and the XML files profile.c - creates the data for the profile and draws it using cairo This commit should contain NO functional changes, just moving code around and a couple of minor abstractions. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-20 19:40:34 +00:00
}
void update_progressbar(progressbar_t *progress, double value)
{
gtk_progress_bar_set_fraction(GTK_PROGRESS_BAR(progress->bar), value);
}
Use the last (or only) filename on command line as default for saving Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-09-21 04:50:26 +00:00
void set_filename(const char *filename)
{
if (filename)
existing_filename = strdup(filename);
return;
}
Reference in a new issue Copy permalink