mifr/subsurface
1
0
Fork 0
mirror of https://github.com/subsurface/subsurface.git synced 2024-11-30 22:20:21 +00:00
Code Issues Projects Releases Packages Wiki Activity
subsurface/gtk-gui.c

1045 lines
31 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 "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;
Add shorthand actions for showing just one of the panes Currently just tied to F1-F4 (for divelist, profile, info, and "all three" respectively), which is just crazy. But using "ctrl-P" for "Profile" isn't sane either, that's the standard printer keyboard shortcut. So what would be good keyboard shortcuts for these things? I also wonder how I can get gtk to shut up about the fact that a pane becomes too small for the contents of that pane? We very much want to do that, and it's very intentional. Gtk does the right thing apart from the whining (and apart from the visually ugly part of a widget that doesn't fit, but making it pretty doesn't really seem possible). Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-12-06 21:00:01 +00:00
GtkWidget *vpane, *hpane;
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
int error_count;
const char *divelist_font;
Don't use gconf on Windows So far this just removes the gconf code - so no preferences for Windows. It also removes the unsused gconf references in main.c Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-28 05:10:35 +00:00
struct units output_units;
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 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,
More intuitive label for "not saving" when exiting Right now the options are "Save" and "Cancel". I wrote that code and it always bugged me - "Cancel" could mean that I want to cancel the the whole operation, i.e. that I don't want to quit after all. Showing "Save" and "No" seems much more logical. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-12-13 22:34:42 +00:00
GTK_STOCK_NO, GTK_RESPONSE_NO,
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
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,
Make the cylinder table columns unsortable They were never intended to be sortable, but using common code with the dive list picked up that "sort by index" thing by mistake. If we really want to be able to sort cylinders by O2 percentage (which really doesn't seem to make much sense, considering that you usually have just one or two cylinders) we will need to also handle the case of editing the (differently sorted) cylinder table. Which we don't do now. Reported-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-12-11 19:40:17 +00:00
data_func_t data_func, unsigned int flags)
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
{
GtkCellRenderer *renderer;
GtkTreeViewColumn *col;
double xalign = 0.0; /* left as default */
Make the cylinder table columns unsortable They were never intended to be sortable, but using common code with the dive list picked up that "sort by index" thing by mistake. If we really want to be able to sort cylinders by O2 percentage (which really doesn't seem to make much sense, considering that you usually have just one or two cylinders) we will need to also handle the case of editing the (differently sorted) cylinder table. Which we don't do now. Reported-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-12-11 19:40:17 +00:00
PangoAlignment align;
gboolean visible;
align = (flags & ALIGN_LEFT) ? PANGO_ALIGN_LEFT :
(flags & ALIGN_RIGHT) ? PANGO_ALIGN_RIGHT :
PANGO_ALIGN_CENTER;
visible = !(flags & INVISIBLE);
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
renderer = gtk_cell_renderer_text_new();
col = gtk_tree_view_column_new();
gtk_tree_view_column_set_title(col, title);
Make the cylinder table columns unsortable They were never intended to be sortable, but using common code with the dive list picked up that "sort by index" thing by mistake. If we really want to be able to sort cylinders by O2 percentage (which really doesn't seem to make much sense, considering that you usually have just one or two cylinders) we will need to also handle the case of editing the (differently sorted) cylinder table. Which we don't do now. Reported-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-12-11 19:40:17 +00:00
if (!(flags & UNSORTABLE))
gtk_tree_view_column_set_sort_column_id(col, index);
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
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)
Make columns for temperature, cylinder, and nitrox optional Just like SAC and OTU these can now be turned on and off through the preferences. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-23 20:36:37 +00:00
OPTIONCALLBACK(nitrox_toggle, visible_cols.nitrox)
OPTIONCALLBACK(temperature_toggle, visible_cols.temperature)
OPTIONCALLBACK(cylinder_toggle, visible_cols.cylinder)
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
Add menu item and dialog to select which events to display Right now they are displayed in one hbox which doesn't work if you have many events - but the code itself works and correctly toggles the events on and off. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 09:51:16 +00:00
static void event_toggle(GtkWidget *w, gpointer _data)
{
gboolean *plot_ev = _data;
*plot_ev = GTK_TOGGLE_BUTTON(w)->active;
}
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);
Make columns for temperature, cylinder, and nitrox optional Just like SAC and OTU these can now be turned on and off through the preferences. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-23 20:36:37 +00:00
button = gtk_check_button_new_with_label("Show Temp");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), visible_cols.temperature);
gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6);
g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(temperature_toggle), NULL);
button = gtk_check_button_new_with_label("Show Cyl");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), visible_cols.cylinder);
gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6);
g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(cylinder_toggle), NULL);
button = gtk_check_button_new_with_label("Show O" UTF8_SUBSCRIPT_2 "%");
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), visible_cols.nitrox);
gtk_box_pack_start(GTK_BOX(box), button, FALSE, FALSE, 6);
g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(nitrox_toggle), 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
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();
Use Registry on Windows to store preferences No change at all to non-Windows builds. Everything seems to work with preferences - but only tested on Win7 Remaining issue: displaying an icon (or the logo in the About dialog) Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-29 01:46:53 +00:00
Split reading/writing preferences into OS specific files This adds tested code for Linux and Mac OS, implementing the api that Linus suggested. The Windows code was moved into its own file, but hasn't even been compile tested, yet. In order to have just one interface to set or get a preference value we encode TRUE as (void *) 1 and FALSE as NULL. This works consistently on all platforms and regardless of whether we have 32 or 64 bit. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-11-24 06:56:57 +00:00
subsurface_set_conf("feet", PREF_BOOL, BOOL_TO_PTR(output_units.length == FEET));
subsurface_set_conf("psi", PREF_BOOL, BOOL_TO_PTR(output_units.pressure == PSI));
subsurface_set_conf("cuft", PREF_BOOL, BOOL_TO_PTR(output_units.volume == CUFT));
subsurface_set_conf("fahrenheit", PREF_BOOL, BOOL_TO_PTR(output_units.temperature == FAHRENHEIT));
subsurface_set_conf("TEMPERATURE", PREF_BOOL, BOOL_TO_PTR(visible_cols.temperature));
subsurface_set_conf("CYLINDER", PREF_BOOL, BOOL_TO_PTR(visible_cols.cylinder));
subsurface_set_conf("NITROX", PREF_BOOL, BOOL_TO_PTR(visible_cols.nitrox));
subsurface_set_conf("SAC", PREF_BOOL, BOOL_TO_PTR(visible_cols.sac));
subsurface_set_conf("OTU", PREF_BOOL, BOOL_TO_PTR(visible_cols.otu));
subsurface_set_conf("divelist_font", PREF_STRING, divelist_font);
subsurface_close_conf();
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);
}
Add menu item and dialog to select which events to display Right now they are displayed in one hbox which doesn't work if you have many events - but the code itself works and correctly toggles the events on and off. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 09:51:16 +00:00
static void create_toggle(const char* label, int *on, void *_data)
{
Rearrange the event filter dialog Create a table with four rows of toggle events and resize it as needed. This may not create the most beautiful layout, but it works. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 11:18:31 +00:00
GtkWidget *button, *table = _data;
int rows, cols, x, y;
static int count;
if (table == NULL) {
/* magic way to reset the number of toggle buttons
* that we have already added - call this before you
* create the dialog */
count = 0;
return;
}
g_object_get(G_OBJECT(table), "n-columns", &cols, "n-rows", &rows, NULL);
if (count > rows * cols) {
gtk_table_resize(GTK_TABLE(table),rows+1,cols);
rows++;
}
x = count % cols;
y = count / cols;
Add menu item and dialog to select which events to display Right now they are displayed in one hbox which doesn't work if you have many events - but the code itself works and correctly toggles the events on and off. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 09:51:16 +00:00
button = gtk_check_button_new_with_label(label);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), *on);
Rearrange the event filter dialog Create a table with four rows of toggle events and resize it as needed. This may not create the most beautiful layout, but it works. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 11:18:31 +00:00
gtk_table_attach_defaults(GTK_TABLE(table), button, x, x+1, y, y+1);
Add menu item and dialog to select which events to display Right now they are displayed in one hbox which doesn't work if you have many events - but the code itself works and correctly toggles the events on and off. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 09:51:16 +00:00
g_signal_connect(G_OBJECT(button), "toggled", G_CALLBACK(event_toggle), on);
Rearrange the event filter dialog Create a table with four rows of toggle events and resize it as needed. This may not create the most beautiful layout, but it works. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 11:18:31 +00:00
count++;
Add menu item and dialog to select which events to display Right now they are displayed in one hbox which doesn't work if you have many events - but the code itself works and correctly toggles the events on and off. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 09:51:16 +00:00
}
static void selectevents_dialog(GtkWidget *w, gpointer data)
{
int result;
Rearrange the event filter dialog Create a table with four rows of toggle events and resize it as needed. This may not create the most beautiful layout, but it works. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 11:18:31 +00:00
GtkWidget *dialog, *frame, *vbox, *table;
Add menu item and dialog to select which events to display Right now they are displayed in one hbox which doesn't work if you have many events - but the code itself works and correctly toggles the events on and off. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 09:51:16 +00:00
dialog = gtk_dialog_new_with_buttons("SelectEvents",
GTK_WINDOW(main_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,
GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT,
NULL);
Rearrange the event filter dialog Create a table with four rows of toggle events and resize it as needed. This may not create the most beautiful layout, but it works. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 11:18:31 +00:00
/* initialize the function that fills the table */
create_toggle(NULL, NULL, NULL);
Add menu item and dialog to select which events to display Right now they are displayed in one hbox which doesn't work if you have many events - but the code itself works and correctly toggles the events on and off. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 09:51:16 +00:00
frame = gtk_frame_new("Enable / Disable Events");
vbox = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_box_pack_start(GTK_BOX(vbox), frame, FALSE, FALSE, 5);
Rearrange the event filter dialog Create a table with four rows of toggle events and resize it as needed. This may not create the most beautiful layout, but it works. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 11:18:31 +00:00
table = gtk_table_new(1, 4, TRUE);
gtk_container_add(GTK_CONTAINER(frame), table);
Add menu item and dialog to select which events to display Right now they are displayed in one hbox which doesn't work if you have many events - but the code itself works and correctly toggles the events on and off. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 09:51:16 +00:00
Rearrange the event filter dialog Create a table with four rows of toggle events and resize it as needed. This may not create the most beautiful layout, but it works. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 11:18:31 +00:00
evn_foreach(&create_toggle, table);
Add menu item and dialog to select which events to display Right now they are displayed in one hbox which doesn't work if you have many events - but the code itself works and correctly toggles the events on and off. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 09:51:16 +00:00
gtk_widget_show_all(dialog);
result = gtk_dialog_run(GTK_DIALOG(dialog));
if (result == GTK_RESPONSE_ACCEPT) {
repaint_dive();
}
gtk_widget_destroy(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 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) {
Make icon file name OS helper function This way we can load the correct icon on the Mac without ugly hacks in the OS independent code. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-12-28 23:57:36 +00:00
GtkWidget *image = gtk_image_new_from_file(subsurface_icon_name());
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 (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);
}
Add shorthand actions for showing just one of the panes Currently just tied to F1-F4 (for divelist, profile, info, and "all three" respectively), which is just crazy. But using "ctrl-P" for "Profile" isn't sane either, that's the standard printer keyboard shortcut. So what would be good keyboard shortcuts for these things? I also wonder how I can get gtk to shut up about the fact that a pane becomes too small for the contents of that pane? We very much want to do that, and it's very intentional. Gtk does the right thing apart from the whining (and apart from the visually ugly part of a widget that doesn't fit, but making it pretty doesn't really seem possible). Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-12-06 21:00:01 +00:00
static void view_list(GtkWidget *w, gpointer data)
{
gtk_paned_set_position(GTK_PANED(vpane), 0);
}
static void view_profile(GtkWidget *w, gpointer data)
{
gtk_paned_set_position(GTK_PANED(hpane), 0);
gtk_paned_set_position(GTK_PANED(vpane), 65535);
}
static void view_info(GtkWidget *w, gpointer data)
{
gtk_paned_set_position(GTK_PANED(vpane), 65535);
gtk_paned_set_position(GTK_PANED(hpane), 65535);
}
/* Ooh. I don't know how to get the half-way size. So I'm just using random numbers */
static void view_three(GtkWidget *w, gpointer data)
{
gtk_paned_set_position(GTK_PANED(hpane), 400);
gtk_paned_set_position(GTK_PANED(vpane), 200);
}
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 shorthand actions for showing just one of the panes Currently just tied to F1-F4 (for divelist, profile, info, and "all three" respectively), which is just crazy. But using "ctrl-P" for "Profile" isn't sane either, that's the standard printer keyboard shortcut. So what would be good keyboard shortcuts for these things? I also wonder how I can get gtk to shut up about the fact that a pane becomes too small for the contents of that pane? We very much want to do that, and it's very intentional. Gtk does the right thing apart from the whining (and apart from the visually ugly part of a widget that doesn't fit, but making it pretty doesn't really seem possible). Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-12-06 21:00:01 +00:00
{ "ViewMenuAction", GTK_STOCK_FILE, "View", NULL, NULL, NULL},
Add menu item and dialog to select which events to display Right now they are displayed in one hbox which doesn't work if you have many events - but the code itself works and correctly toggles the events on and off. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 09:51:16 +00:00
{ "FilterMenuAction", GTK_STOCK_FILE, "Filter", 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) },
Add menu item and dialog to select which events to display Right now they are displayed in one hbox which doesn't work if you have many events - but the code itself works and correctly toggles the events on and off. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 09:51:16 +00:00
{ "SelectEvents", NULL, "SelectEvents", NULL, NULL, G_CALLBACK(selectevents_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
{ "Quit", GTK_STOCK_QUIT, NULL, "<control>Q", NULL, G_CALLBACK(quit) },
Add menu item and dialog to select which events to display Right now they are displayed in one hbox which doesn't work if you have many events - but the code itself works and correctly toggles the events on and off. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 09:51:16 +00:00
{ "About", GTK_STOCK_ABOUT, NULL, NULL, NULL, G_CALLBACK(about_dialog) },
Make view action shortcuts be ctrl-[1-4] instead of Fn keys Suggested by Henrik Aronsen, and seems much more natural. Especially with lots of keyboards having function keys oddly mapped. Suggested-by: Henrik Brautaset Aronsen <subsurface@henrik.synth.no> Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-12-07 16:08:29 +00:00
{ "ViewList", NULL, "List", "<control>1", NULL, G_CALLBACK(view_list) },
{ "ViewProfile", NULL, "Profile", "<control>2", NULL, G_CALLBACK(view_profile) },
{ "ViewInfo", NULL, "Info", "<control>3", NULL, G_CALLBACK(view_info) },
{ "ViewThree", NULL, "Three", "<control>4", NULL, G_CALLBACK(view_three) },
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\" /> \
Add shorthand actions for showing just one of the panes Currently just tied to F1-F4 (for divelist, profile, info, and "all three" respectively), which is just crazy. But using "ctrl-P" for "Profile" isn't sane either, that's the standard printer keyboard shortcut. So what would be good keyboard shortcuts for these things? I also wonder how I can get gtk to shut up about the fact that a pane becomes too small for the contents of that pane? We very much want to do that, and it's very intentional. Gtk does the right thing apart from the whining (and apart from the visually ugly part of a widget that doesn't fit, but making it pretty doesn't really seem possible). Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-12-06 21:00:01 +00:00
<menu name=\"View\" action=\"ViewMenuAction\"> \
<menuitem name=\"List\" action=\"ViewList\" /> \
<menuitem name=\"Profile\" action=\"ViewProfile\" /> \
<menuitem name=\"Info\" action=\"ViewInfo\" /> \
<menuitem name=\"Paned\" action=\"ViewThree\" /> \
</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
</menu> \
Add menu item and dialog to select which events to display Right now they are displayed in one hbox which doesn't work if you have many events - but the code itself works and correctly toggles the events on and off. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-25 09:51:16 +00:00
<menu name=\"FilterMenu\" action=\"FilterMenuAction\"> \
<menuitem name=\"SelectEvents\" action=\"SelectEvents\" /> \
</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();
}
Fix 'init_ui()' so that it can change argc/argv That's what gtk_init() does with gtk-specific arguments. IOW, if you do things like subsurface --g-fatal-warnings dives.xml to get a real abort on gtk warnings, gtk_init needs to be able to actually change argc/argv. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-11-02 00:09:15 +00:00
void init_ui(int *argcp, char ***argvp)
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 *win;
GtkWidget *notebook;
GtkWidget *dive_info;
GtkWidget *dive_list;
GtkWidget *equipment;
Add Info & Stats page to the notebook This provides the relevant information for the currently selected dive plus a bunch of statistics over all dives in the dive_table. The visual design has lots of room for improvement - right now the different fields change size - it might be nice to have a more modern look for the entries - the O2/He field is odd - for most divers the He value will always be 0, so maybe we should only show He if there's at least one dive that uses He? Also, we simply do a comma separated list of gases for all the tanks used Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-11-02 16:10:57 +00:00
GtkWidget *stats;
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 *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;
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
Fix 'init_ui()' so that it can change argc/argv That's what gtk_init() does with gtk-specific arguments. IOW, if you do things like subsurface --g-fatal-warnings dives.xml to get a real abort on gtk warnings, gtk_init needs to be able to actually change argc/argv. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-11-02 00:09:15 +00:00
gtk_init(argcp, argvp);
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();
Don't use gconf on Windows So far this just removes the gconf code - so no preferences for Windows. It also removes the unsused gconf references in main.c Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-28 05:10:35 +00:00
Split reading/writing preferences into OS specific files This adds tested code for Linux and Mac OS, implementing the api that Linus suggested. The Windows code was moved into its own file, but hasn't even been compile tested, yet. In order to have just one interface to set or get a preference value we encode TRUE as (void *) 1 and FALSE as NULL. This works consistently on all platforms and regardless of whether we have 32 or 64 bit. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-11-24 06:56:57 +00:00
subsurface_open_conf();
if (subsurface_get_conf("feet", PREF_BOOL))
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
output_units.length = FEET;
Split reading/writing preferences into OS specific files This adds tested code for Linux and Mac OS, implementing the api that Linus suggested. The Windows code was moved into its own file, but hasn't even been compile tested, yet. In order to have just one interface to set or get a preference value we encode TRUE as (void *) 1 and FALSE as NULL. This works consistently on all platforms and regardless of whether we have 32 or 64 bit. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-11-24 06:56:57 +00:00
if (subsurface_get_conf("psi", PREF_BOOL))
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
output_units.pressure = PSI;
Split reading/writing preferences into OS specific files This adds tested code for Linux and Mac OS, implementing the api that Linus suggested. The Windows code was moved into its own file, but hasn't even been compile tested, yet. In order to have just one interface to set or get a preference value we encode TRUE as (void *) 1 and FALSE as NULL. This works consistently on all platforms and regardless of whether we have 32 or 64 bit. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-11-24 06:56:57 +00:00
if (subsurface_get_conf("cuft", PREF_BOOL))
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
output_units.volume = CUFT;
Split reading/writing preferences into OS specific files This adds tested code for Linux and Mac OS, implementing the api that Linus suggested. The Windows code was moved into its own file, but hasn't even been compile tested, yet. In order to have just one interface to set or get a preference value we encode TRUE as (void *) 1 and FALSE as NULL. This works consistently on all platforms and regardless of whether we have 32 or 64 bit. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-11-24 06:56:57 +00:00
if (subsurface_get_conf("fahrenheit", PREF_BOOL))
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
output_units.temperature = FAHRENHEIT;
Make columns for temperature, cylinder, and nitrox optional Just like SAC and OTU these can now be turned on and off through the preferences. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-23 20:36:37 +00:00
/* an unset key is FALSE - all these are hidden by default */
Split reading/writing preferences into OS specific files This adds tested code for Linux and Mac OS, implementing the api that Linus suggested. The Windows code was moved into its own file, but hasn't even been compile tested, yet. In order to have just one interface to set or get a preference value we encode TRUE as (void *) 1 and FALSE as NULL. This works consistently on all platforms and regardless of whether we have 32 or 64 bit. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-11-24 06:56:57 +00:00
visible_cols.cylinder = PTR_TO_BOOL(subsurface_get_conf("CYLINDER", PREF_BOOL));
visible_cols.temperature = PTR_TO_BOOL(subsurface_get_conf("TEMPERATURE", PREF_BOOL));
visible_cols.nitrox = PTR_TO_BOOL(subsurface_get_conf("NITROX", PREF_BOOL));
visible_cols.otu = PTR_TO_BOOL(subsurface_get_conf("OTU", PREF_BOOL));
visible_cols.sac = PTR_TO_BOOL(subsurface_get_conf("SAC", PREF_BOOL));
divelist_font = subsurface_get_conf("divelist_font", PREF_STRING);
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
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)
Make icon file name OS helper function This way we can load the correct icon on the Mac without ugly hacks in the OS independent code. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-12-28 23:57:36 +00:00
gtk_window_set_icon_from_file(GTK_WINDOW(win), subsurface_icon_name(), 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);
Turn subsurface into a real Mac application To do this a few things needed to move into the os specific files, but the overall change is fairly small and the difference on the Mac is amazing. Subsurface now becomes a Mac app with Mac toolbar and useful default fonts. Changed the CFBundleIdentifier to be the reverse DNS of the subsurface site (sadly, 'torvalds' is not yet a TLD). Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2012-01-01 21:41:47 +00:00
subsurface_ui_setup(settings, menubar, 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
Experimental hard-coded three-pane layout I'm not happy with it, but it looks good and works better than the alternatives I've looked at so far. So why not happy? It's not configurable, and gtk really doesn't do a great job with the case of notebook widgets that are shrunk to be smaller than the contents (the cut-off gets ugly, and is outside the notebook page!) But committing as a way to keep track of this, and let Dirk use it. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-11-19 20:54:58 +00:00
vpane = gtk_vpaned_new();
gtk_box_pack_start(GTK_BOX(vbox), vpane, TRUE, TRUE, 3);
hpane = gtk_hpaned_new();
gtk_paned_add1(GTK_PANED(vpane), hpane);
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
/* Notebook for dive info vs profile vs .. */
notebook = gtk_notebook_new();
Experimental hard-coded three-pane layout I'm not happy with it, but it looks good and works better than the alternatives I've looked at so far. So why not happy? It's not configurable, and gtk really doesn't do a great job with the case of notebook widgets that are shrunk to be smaller than the contents (the cut-off gets ugly, and is outside the notebook page!) But committing as a way to keep track of this, and let Dirk use it. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-11-19 20:54:58 +00:00
gtk_paned_add1(GTK_PANED(hpane), 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");
Experimental hard-coded three-pane layout I'm not happy with it, but it looks good and works better than the alternatives I've looked at so far. So why not happy? It's not configurable, and gtk really doesn't do a great job with the case of notebook widgets that are shrunk to be smaller than the contents (the cut-off gets ugly, and is outside the notebook page!) But committing as a way to keep track of this, and let Dirk use it. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-11-19 20:54:58 +00:00
gtk_paned_add2(GTK_PANED(vpane), dive_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
/* 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");
Experimental hard-coded three-pane layout I'm not happy with it, but it looks good and works better than the alternatives I've looked at so far. So why not happy? It's not configurable, and gtk really doesn't do a great job with the case of notebook widgets that are shrunk to be smaller than the contents (the cut-off gets ugly, and is outside the notebook page!) But committing as a way to keep track of this, and let Dirk use it. Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2011-11-19 20:54:58 +00:00
gtk_paned_add2(GTK_PANED(hpane), 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
/* 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"));
Add Info & Stats page to the notebook This provides the relevant information for the currently selected dive plus a bunch of statistics over all dives in the dive_table. The visual design has lots of room for improvement - right now the different fields change size - it might be nice to have a more modern look for the entries - the O2/He field is odd - for most divers the He value will always be 0, so maybe we should only show He if there's at least one dive that uses He? Also, we simply do a comma separated list of gases for all the tanks used Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-11-02 16:10:57 +00:00
/* Frame for dive statistics */
stats = stats_widget();
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), stats, gtk_label_new("Info & Stats"));
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_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);
Define all colors in one place The profile colors were defined all over the place, so I put them all in one spot. I'm unsure if this is the best solution to that problem, but I guess it's a step in the right direction. Signed-Off-By: Henrik Brautaset Aronsen <subsurface@henrik.synth.no>
2011-11-28 17:17:33 +00:00
init_profile_background(&gc);
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_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 is not a function Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-12-15 04:49:40 +00:00
return ret;
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 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);
Add reasonable default device names for divecomputer import So far we hard coded /dev/ttyUSB0 - which is a good starting point in Linux but not so useful on Windows or MacOS. This was now moved into one of our OS helper functions with (somewhat) reasonable defaults. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-12-14 04:34:56 +00:00
gtk_entry_set_text(GTK_ENTRY(entry), subsurface_USB_name());
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
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)
{
Make the first filename on the command line the default filename From a usecase point of view - if we call with multiple file names then most likely it's subsurface MyDives.xml new_dive1.xml new_dive2.xml and therefore the existing "database" is the first filename, not the last one (as the current implementation assumes). Frankly, this is a bit arbitrary - but this one seems to make more sense. Signed-off-by: Dirk Hohndel <dirk@hohndel.org>
2011-10-21 13:12:04 +00:00
if (!existing_filename && filename)
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
existing_filename = strdup(filename);
return;
}
Reference in a new issue Copy permalink