2017-01-31 19:42:41 +01:00
|
|
|
#include "mainwindow.h"
|
2017-02-01 18:20:48 +01:00
|
|
|
#include "mdiary.h"
|
2017-01-31 19:42:41 +01:00
|
|
|
|
2017-02-05 16:28:26 +01:00
|
|
|
enum {
|
|
|
|
WSCOL_LABEL = 0,
|
|
|
|
WSCOL_PATH,
|
|
|
|
WSCOL_COUNT
|
|
|
|
};
|
|
|
|
|
|
|
|
static gboolean mainWindow_workspace_entry_visible(GtkTreeModel *model,
|
|
|
|
GtkTreeIter *iter,
|
|
|
|
struct mainWindow *mainWindow)
|
|
|
|
{
|
|
|
|
GRegex *regex;
|
|
|
|
GMatchInfo *match_info;
|
|
|
|
gchar *searchString;
|
|
|
|
gchar *temp;
|
|
|
|
gboolean ret = FALSE;
|
|
|
|
|
|
|
|
searchString = gtk_entry_get_text(GTK_ENTRY(mainWindow->workspaceSearch));
|
|
|
|
|
|
|
|
if (g_strcmp0(searchString, "")) {
|
|
|
|
regex = g_regex_new(searchString, G_REGEX_CASELESS, 0, NULL);
|
|
|
|
gtk_tree_model_get(model, iter, WSCOL_PATH, &temp, -1);
|
|
|
|
if (g_regex_match(regex, temp, 0, &match_info) && g_match_info_matches(match_info))
|
|
|
|
ret = TRUE;
|
|
|
|
g_free(temp);
|
|
|
|
} else {
|
|
|
|
ret = TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
void mainWindow_workspace_search_changed(GtkWidget *widget, gpointer user_data)
|
|
|
|
{
|
|
|
|
struct mainWindow *mainWindow = (struct mainWindow *)user_data;
|
|
|
|
|
|
|
|
gtk_tree_model_filter_refilter(mainWindow->workspaceListFiltered);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2017-02-03 20:38:44 +01:00
|
|
|
/**
|
|
|
|
* @brief mainWindow_list_entry_visible checks whether the entry should be displayed.
|
|
|
|
* @param model N/A
|
|
|
|
* @param iter N/A
|
|
|
|
* @param mainWindow struct mainWindow *
|
|
|
|
* @return True when it should displayed, else false.
|
|
|
|
*/
|
2017-02-05 16:28:26 +01:00
|
|
|
static gboolean mainWindow_list_entry_visible(GtkTreeModel *model,
|
|
|
|
GtkTreeIter *iter,
|
|
|
|
struct mainWindow *mainWindow)
|
2017-02-02 17:16:49 +01:00
|
|
|
{
|
2017-02-03 20:57:14 +01:00
|
|
|
GRegex *regex;
|
|
|
|
GMatchInfo *match_info;
|
|
|
|
gchar *searchString;
|
|
|
|
gchar *temp;
|
|
|
|
|
|
|
|
gboolean search_matched = 0;
|
|
|
|
|
2017-02-02 20:20:22 +01:00
|
|
|
GDateTime *datetime;
|
|
|
|
guint time;
|
|
|
|
|
2017-02-03 20:57:14 +01:00
|
|
|
/* Check text search */
|
|
|
|
searchString = (gchar *)gtk_entry_get_text(GTK_ENTRY(mainWindow->searchEntry));
|
2017-02-04 12:17:41 +01:00
|
|
|
if (searchString[0] != 0 && (
|
|
|
|
mainWindow->filterSettings.search_title ||
|
|
|
|
mainWindow->filterSettings.search_tags ||
|
|
|
|
mainWindow->filterSettings.search_text)) {
|
2017-02-03 20:57:14 +01:00
|
|
|
regex = g_regex_new(searchString, G_REGEX_CASELESS, 0, NULL);
|
|
|
|
|
2017-02-03 22:56:31 +01:00
|
|
|
gtk_tree_model_get(model, iter, COL_TITLE, &temp, -1);
|
2017-02-04 12:17:41 +01:00
|
|
|
if (mainWindow->filterSettings.search_title &&
|
|
|
|
g_regex_match(regex, temp, 0, &match_info) && g_match_info_matches(match_info))
|
2017-02-03 20:57:14 +01:00
|
|
|
search_matched = 1;
|
|
|
|
g_free(temp);
|
|
|
|
|
2017-02-04 12:17:41 +01:00
|
|
|
gtk_tree_model_get(model, iter, COL_TAGS_TEXT, &temp, -1);
|
|
|
|
if (!search_matched &&
|
|
|
|
mainWindow->filterSettings.search_tags &&
|
|
|
|
g_regex_match(regex, temp, 0, &match_info) && g_match_info_matches(match_info))
|
2017-02-03 20:57:14 +01:00
|
|
|
search_matched = 1;
|
|
|
|
g_free(temp);
|
|
|
|
|
2017-02-04 18:40:51 +01:00
|
|
|
gtk_tree_model_get(model, iter, COL_SUMMARY, &temp, -1);
|
|
|
|
if (!search_matched &&
|
|
|
|
mainWindow->filterSettings.search_summary &&
|
|
|
|
g_regex_match(regex, temp, 0, &match_info) && g_match_info_matches(match_info))
|
|
|
|
search_matched = 1;
|
|
|
|
g_free(temp);
|
|
|
|
|
2017-02-04 12:17:41 +01:00
|
|
|
gtk_tree_model_get(model, iter, COL_TEXT, &temp, -1);
|
|
|
|
if (!search_matched &&
|
|
|
|
mainWindow->filterSettings.search_text &&
|
|
|
|
g_regex_match(regex, temp, 0, &match_info) && g_match_info_matches(match_info))
|
2017-02-03 20:57:14 +01:00
|
|
|
search_matched = 1;
|
|
|
|
g_free(temp);
|
|
|
|
|
|
|
|
if (!search_matched)
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Check time span */
|
2017-02-02 21:36:49 +01:00
|
|
|
gtk_tree_model_get(model, iter, COL_TIMESTAMP, &datetime, -1);
|
2017-02-02 20:20:22 +01:00
|
|
|
if (datetime) {
|
|
|
|
time = g_date_time_to_unix(datetime);
|
2017-02-05 13:25:40 +01:00
|
|
|
/* The addition in braces allows for the whole day instead of just its first second. */
|
|
|
|
return time >= (mainWindow->filterSettings.time_start) &&
|
2017-02-04 20:11:31 +01:00
|
|
|
time <= mainWindow->filterSettings.time_end + (60 * 60 * 23 + 60 * 59 + 59);
|
2017-02-02 21:36:49 +01:00
|
|
|
} else {
|
2017-02-02 20:20:22 +01:00
|
|
|
return 0;
|
|
|
|
}
|
2017-02-02 17:16:49 +01:00
|
|
|
}
|
|
|
|
|
2017-02-03 20:38:44 +01:00
|
|
|
/**
|
|
|
|
* @brief mainWindow_sort_date_compare_func Compares the two GDateTimes from the main store.
|
|
|
|
* @param model N/A
|
|
|
|
* @param a N/A
|
|
|
|
* @param b N/A
|
|
|
|
* @param userdata N/A
|
|
|
|
* @return N/A
|
|
|
|
*/
|
2017-02-02 19:09:59 +01:00
|
|
|
static gint mainWindow_sort_date_compare_func(GtkTreeModel *model,
|
|
|
|
GtkTreeIter *a,
|
|
|
|
GtkTreeIter *b,
|
|
|
|
gpointer userdata)
|
|
|
|
{
|
|
|
|
GDateTime *datetime1;
|
|
|
|
GDateTime *datetime2;
|
|
|
|
guint time1;
|
|
|
|
guint time2;
|
|
|
|
|
|
|
|
gtk_tree_model_get(model, a, COL_TIMESTAMP, &datetime1, -1);
|
|
|
|
gtk_tree_model_get(model, b, COL_TIMESTAMP, &datetime2, -1);
|
|
|
|
time1 = g_date_time_to_unix(datetime1);
|
|
|
|
time2 = g_date_time_to_unix(datetime2);
|
|
|
|
|
|
|
|
if (time1 == time2)
|
|
|
|
return 0;
|
|
|
|
else if (time1 > time2)
|
|
|
|
return 1;
|
|
|
|
else
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
2017-02-05 16:28:26 +01:00
|
|
|
static void mainWindow_add_recent_workspace(struct mainWindow *mainWindow, gchar *path)
|
|
|
|
{
|
|
|
|
GtkTreeIter iter;
|
|
|
|
GRegex *regex;
|
|
|
|
GMatchInfo *match_info;
|
|
|
|
gchar *temp;
|
|
|
|
|
|
|
|
regex = g_regex_new("(.*)\\/(.*)", G_REGEX_RAW, 0, NULL);
|
|
|
|
if (g_regex_match(regex, path, 0, &match_info) &&
|
|
|
|
g_regex_get_capture_count(regex) > 1 &&
|
|
|
|
g_match_info_matches(match_info)) {
|
|
|
|
g_match_info_fetch(match_info, 1);
|
|
|
|
|
|
|
|
temp = g_strdup_printf("<b>%s</b>\n<span weight=\"ultralight\">%s</span>",
|
|
|
|
g_match_info_fetch(match_info, 2),
|
|
|
|
g_match_info_fetch(match_info, 1));
|
|
|
|
gtk_list_store_append(mainWindow->workspaceListStore, &iter);
|
|
|
|
gtk_list_store_set(mainWindow->workspaceListStore, &iter,
|
|
|
|
WSCOL_LABEL, temp,
|
|
|
|
WSCOL_PATH, path,
|
|
|
|
-1);
|
|
|
|
g_free(temp);
|
|
|
|
}
|
|
|
|
|
|
|
|
g_regex_unref(regex);
|
|
|
|
}
|
|
|
|
|
2017-02-05 15:31:04 +01:00
|
|
|
/**
|
|
|
|
* @brief mainWindow_wschooser_configure_treeView configures the GtkTreeView for workspace selection
|
|
|
|
* @param mainWindow
|
|
|
|
*/
|
|
|
|
static void mainWindow_configure_workspaceTreeView(struct mainWindow *mainWindow)
|
|
|
|
{
|
|
|
|
GtkCellRenderer *renderer;
|
|
|
|
GtkTreeViewColumn *col;
|
|
|
|
|
2017-02-05 16:28:26 +01:00
|
|
|
mainWindow->workspaceListStore = gtk_list_store_new(WSCOL_COUNT,
|
|
|
|
G_TYPE_STRING,
|
|
|
|
G_TYPE_STRING);
|
2017-02-05 15:31:04 +01:00
|
|
|
|
2017-02-05 16:28:26 +01:00
|
|
|
mainWindow->workspaceListFiltered = GTK_TREE_MODEL_FILTER(
|
|
|
|
gtk_tree_model_filter_new(
|
|
|
|
GTK_TREE_MODEL(mainWindow->workspaceListStore),
|
|
|
|
NULL));
|
2017-02-05 15:31:04 +01:00
|
|
|
|
2017-02-05 16:28:26 +01:00
|
|
|
gtk_tree_model_filter_set_visible_func(mainWindow->workspaceListFiltered,
|
|
|
|
(GtkTreeModelFilterVisibleFunc) mainWindow_workspace_entry_visible,
|
|
|
|
mainWindow, NULL);
|
|
|
|
|
|
|
|
gtk_tree_view_set_model(mainWindow->workspaceListView, GTK_TREE_MODEL(mainWindow->workspaceListFiltered));
|
2017-02-05 15:31:04 +01:00
|
|
|
|
|
|
|
renderer = gtk_cell_renderer_text_new();
|
|
|
|
gtk_tree_view_insert_column_with_attributes(mainWindow->workspaceListView, -1, "", renderer,
|
2017-02-05 16:28:26 +01:00
|
|
|
"markup", WSCOL_LABEL, NULL);
|
2017-02-05 15:31:04 +01:00
|
|
|
|
2017-02-05 16:28:26 +01:00
|
|
|
/* Test only */
|
|
|
|
mainWindow_add_recent_workspace(mainWindow, "/home/user/Document/diary");
|
|
|
|
mainWindow_add_recent_workspace(mainWindow, "/home/user/Document/workfoo");
|
2017-02-05 15:31:04 +01:00
|
|
|
}
|
|
|
|
|
2017-02-03 20:38:44 +01:00
|
|
|
/**
|
|
|
|
* @brief mainWindow_configure_treeView configures GtkTreeView
|
|
|
|
* @param mainWindow struct mainWindow *
|
|
|
|
*/
|
2017-01-31 21:56:37 +01:00
|
|
|
static void mainWindow_configure_treeView(struct mainWindow *mainWindow)
|
2017-01-31 21:31:31 +01:00
|
|
|
{
|
|
|
|
GtkCellRenderer *renderer;
|
|
|
|
GtkTreeSortable *sortable;
|
|
|
|
GtkTreeViewColumn *col;
|
2017-02-02 17:16:49 +01:00
|
|
|
GtkTreeModelSort *sorted;
|
2017-02-02 20:04:35 +01:00
|
|
|
GtkTreeModel *model;
|
2017-02-02 17:16:49 +01:00
|
|
|
|
|
|
|
mainWindow->entryListStore = gtk_list_store_new(COL_COUNT,
|
|
|
|
G_TYPE_STRING,
|
|
|
|
G_TYPE_STRING,
|
|
|
|
G_TYPE_STRING,
|
2017-02-02 19:09:59 +01:00
|
|
|
G_TYPE_POINTER,
|
|
|
|
G_TYPE_POINTER,
|
2017-02-04 17:01:09 +01:00
|
|
|
G_TYPE_STRING,
|
2017-02-02 19:09:59 +01:00
|
|
|
G_TYPE_STRING);
|
2017-02-02 21:36:49 +01:00
|
|
|
mainWindow->entryListFiltered = GTK_TREE_MODEL_FILTER(gtk_tree_model_filter_new(
|
|
|
|
GTK_TREE_MODEL(mainWindow->entryListStore),
|
|
|
|
NULL));
|
2017-02-02 19:13:30 +01:00
|
|
|
sorted = GTK_TREE_MODEL_SORT(gtk_tree_model_sort_new_with_model(
|
2017-02-02 21:36:49 +01:00
|
|
|
GTK_TREE_MODEL(mainWindow->entryListFiltered)));
|
2017-02-02 19:13:30 +01:00
|
|
|
|
2017-02-02 21:36:49 +01:00
|
|
|
gtk_tree_model_filter_set_visible_func(mainWindow->entryListFiltered,
|
2017-02-02 19:13:30 +01:00
|
|
|
(GtkTreeModelFilterVisibleFunc) mainWindow_list_entry_visible,
|
|
|
|
mainWindow, NULL);
|
|
|
|
model = GTK_TREE_MODEL(sorted);
|
2017-02-02 17:16:49 +01:00
|
|
|
gtk_tree_view_set_model(mainWindow->entryListView, model);
|
|
|
|
|
|
|
|
/* TODO: Unref mainWindow->entryListStore and filtered, sorted and model? */
|
2017-01-31 21:31:31 +01:00
|
|
|
|
2017-02-02 19:09:59 +01:00
|
|
|
sortable = GTK_TREE_SORTABLE(sorted);
|
|
|
|
|
2017-01-31 21:31:31 +01:00
|
|
|
renderer = gtk_cell_renderer_text_new();
|
|
|
|
gtk_tree_view_insert_column_with_attributes(mainWindow->entryListView, -1, "Title", renderer,
|
|
|
|
"text", COL_TITLE, NULL);
|
|
|
|
col = gtk_tree_view_get_column(mainWindow->entryListView, COL_TITLE);
|
|
|
|
gtk_tree_view_column_set_resizable(col, 1);
|
|
|
|
gtk_tree_view_column_set_sort_column_id(col, COL_TITLE);
|
|
|
|
|
|
|
|
renderer = gtk_cell_renderer_text_new();
|
|
|
|
gtk_tree_view_insert_column_with_attributes(mainWindow->entryListView, -1, "Date", renderer,
|
2017-02-02 19:09:59 +01:00
|
|
|
"text", COL_DATE_TEXT, NULL);
|
|
|
|
col = gtk_tree_view_get_column(mainWindow->entryListView, COL_DATE_TEXT);
|
2017-01-31 21:31:31 +01:00
|
|
|
gtk_tree_view_column_set_resizable(col, 1);
|
2017-02-04 17:46:21 +01:00
|
|
|
gtk_tree_sortable_set_sort_func(sortable, COL_DATE_TEXT, mainWindow_sort_date_compare_func,
|
|
|
|
GINT_TO_POINTER(COL_DATE_TEXT), NULL);
|
2017-02-02 19:09:59 +01:00
|
|
|
gtk_tree_view_column_set_sort_column_id(col, COL_DATE_TEXT);
|
2017-01-31 21:31:31 +01:00
|
|
|
|
|
|
|
renderer = gtk_cell_renderer_text_new();
|
|
|
|
gtk_tree_view_insert_column_with_attributes(mainWindow->entryListView, -1, "Tags", renderer,
|
2017-02-02 19:09:59 +01:00
|
|
|
"text", COL_TAGS_TEXT, NULL);
|
|
|
|
col = gtk_tree_view_get_column(mainWindow->entryListView, COL_TAGS_TEXT);
|
2017-01-31 21:31:31 +01:00
|
|
|
gtk_tree_view_column_set_resizable(col, 1);
|
2017-02-02 19:09:59 +01:00
|
|
|
gtk_tree_view_column_set_sort_column_id(col, COL_TAGS_TEXT);
|
2017-01-31 21:31:31 +01:00
|
|
|
|
2017-02-02 19:09:59 +01:00
|
|
|
gtk_tree_sortable_set_sort_column_id(sortable, COL_DATE_TEXT, GTK_SORT_DESCENDING);
|
2017-02-01 17:37:31 +01:00
|
|
|
}
|
2017-02-01 17:33:01 +01:00
|
|
|
|
2017-02-03 20:38:44 +01:00
|
|
|
/**
|
|
|
|
* @brief mainWindow_connect_signals connects are g signals
|
|
|
|
* @param mainWindow struct mainWindow *
|
|
|
|
*/
|
2017-02-01 17:37:31 +01:00
|
|
|
static void mainWindow_connect_signals(struct mainWindow *mainWindow)
|
|
|
|
{
|
2017-02-01 17:33:01 +01:00
|
|
|
g_signal_connect(mainWindow->dateStart,
|
|
|
|
"focus-in-event",
|
2017-02-02 19:10:51 +01:00
|
|
|
(GCallback) mainWindow_showPopover,
|
2017-02-01 17:33:01 +01:00
|
|
|
mainWindow);
|
|
|
|
g_signal_connect(mainWindow->dateEnd,
|
|
|
|
"focus-in-event",
|
2017-02-02 19:10:51 +01:00
|
|
|
(GCallback) mainWindow_showPopover,
|
2017-02-01 17:33:01 +01:00
|
|
|
mainWindow);
|
|
|
|
g_signal_connect(mainWindow->calendarRange,
|
|
|
|
"day-selected",
|
2017-02-02 19:10:51 +01:00
|
|
|
(GCallback) mainWindow_calendarSelected,
|
2017-02-01 17:33:01 +01:00
|
|
|
mainWindow);
|
2017-02-03 17:27:12 +01:00
|
|
|
g_signal_connect_swapped(mainWindow->calendarRange,
|
|
|
|
"day-selected-double-click",
|
|
|
|
(GCallback) gtk_popover_popdown,
|
|
|
|
mainWindow->popoverDate);
|
2017-02-02 20:02:33 +01:00
|
|
|
|
|
|
|
g_signal_connect(mainWindow->entryListSelection,
|
|
|
|
"changed",
|
|
|
|
(GCallback) mainWindow_entrySelected,
|
|
|
|
mainWindow);
|
2017-02-02 21:36:49 +01:00
|
|
|
|
|
|
|
g_signal_connect(mainWindow->dateStart,
|
|
|
|
"changed",
|
2017-02-03 20:25:34 +01:00
|
|
|
(GCallback) mainWindow_filterChanged,
|
2017-02-02 21:36:49 +01:00
|
|
|
mainWindow);
|
|
|
|
g_signal_connect(mainWindow->dateEnd,
|
|
|
|
"changed",
|
2017-02-03 20:25:34 +01:00
|
|
|
(GCallback) mainWindow_filterChanged,
|
2017-02-02 21:36:49 +01:00
|
|
|
mainWindow);
|
2017-02-03 19:37:31 +01:00
|
|
|
|
|
|
|
g_signal_connect(mainWindow->dateStart,
|
|
|
|
"focus-out-event",
|
|
|
|
(GCallback) mainWindow_checkDate,
|
|
|
|
mainWindow);
|
|
|
|
g_signal_connect(mainWindow->dateEnd,
|
|
|
|
"focus-out-event",
|
|
|
|
(GCallback) mainWindow_checkDate,
|
|
|
|
mainWindow);
|
2017-02-03 20:25:34 +01:00
|
|
|
|
|
|
|
g_signal_connect(mainWindow->searchEntry,
|
|
|
|
"changed",
|
|
|
|
(GCallback) mainWindow_filterChanged,
|
|
|
|
mainWindow);
|
2017-02-04 12:17:41 +01:00
|
|
|
|
|
|
|
g_signal_connect(mainWindow->checkSearchTitle,
|
|
|
|
"toggled",
|
|
|
|
(GCallback) mainWindow_filterChanged,
|
|
|
|
mainWindow);
|
|
|
|
g_signal_connect(mainWindow->checkSearchTags,
|
|
|
|
"toggled",
|
|
|
|
(GCallback) mainWindow_filterChanged,
|
|
|
|
mainWindow);
|
|
|
|
g_signal_connect(mainWindow->checkSearchText,
|
|
|
|
"toggled",
|
|
|
|
(GCallback) mainWindow_filterChanged,
|
|
|
|
mainWindow);
|
2017-02-04 18:40:51 +01:00
|
|
|
g_signal_connect(mainWindow->checkSearchSummary,
|
|
|
|
"toggled",
|
|
|
|
(GCallback) mainWindow_filterChanged,
|
|
|
|
mainWindow);
|
2017-02-04 18:52:31 +01:00
|
|
|
|
|
|
|
g_signal_connect(mainWindow->buttonClearSearch,
|
|
|
|
"clicked",
|
|
|
|
(GCallback) mainWindow_clearSearch,
|
|
|
|
mainWindow);
|
2017-02-04 20:38:29 +01:00
|
|
|
|
|
|
|
g_signal_connect(mainWindow->dateStart,
|
|
|
|
"icon-press",
|
|
|
|
(GCallback) mainWindow_dateIconPress,
|
|
|
|
mainWindow);
|
|
|
|
g_signal_connect(mainWindow->dateEnd,
|
|
|
|
"icon-press",
|
|
|
|
(GCallback) mainWindow_dateIconPress,
|
|
|
|
mainWindow);
|
2017-02-05 14:31:17 +01:00
|
|
|
|
|
|
|
g_signal_connect(mainWindow->buttonOtherWorkspace,
|
|
|
|
"clicked",
|
|
|
|
(GCallback) mainWindow_otherWorkspaceClicked,
|
|
|
|
mainWindow);
|
2017-02-05 15:31:04 +01:00
|
|
|
g_signal_connect(mainWindow->workspaceListView,
|
|
|
|
"row-activated",
|
|
|
|
(GCallback) mainWindow_workspaceListClicked,
|
|
|
|
mainWindow);
|
2017-02-05 16:28:26 +01:00
|
|
|
g_signal_connect(mainWindow->workspaceSearch,
|
|
|
|
"changed",
|
|
|
|
(GCallback) mainWindow_workspace_search_changed,
|
|
|
|
mainWindow);
|
2017-02-04 18:52:31 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief mainWindow_init_to_default initializes all non-date related UI elements to sensible values.
|
|
|
|
* @param mainWindow
|
|
|
|
*/
|
|
|
|
static void mainWindow_init_to_default(struct mainWindow *mainWindow)
|
|
|
|
{
|
|
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mainWindow->checkSearchTitle), 1);
|
|
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mainWindow->checkSearchSummary), 1);
|
|
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mainWindow->checkSearchTags), 1);
|
|
|
|
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(mainWindow->checkSearchText), 0);
|
2017-01-31 21:31:31 +01:00
|
|
|
}
|
|
|
|
|
2017-02-03 20:38:44 +01:00
|
|
|
/**
|
|
|
|
* @brief mainWindow_new creates a new mainWindow.
|
|
|
|
* @return Returns struct mainWindow *
|
|
|
|
*/
|
2017-01-31 19:42:41 +01:00
|
|
|
struct mainWindow *mainWindow_new()
|
|
|
|
{
|
|
|
|
GtkBuilder *builder;
|
|
|
|
struct mainWindow *mainWindow;
|
|
|
|
|
|
|
|
builder = gtk_builder_new_from_file("glade/mainWindow.glade");
|
|
|
|
|
|
|
|
mainWindow = malloc(sizeof(struct mainWindow));
|
|
|
|
mainWindow->mainWindow = GTK_WIDGET(gtk_builder_get_object(builder, "mainWindow"));
|
|
|
|
mainWindow->searchEntry = GTK_WIDGET(gtk_builder_get_object(builder, "searchEntry"));
|
|
|
|
mainWindow->dateStart = GTK_WIDGET(gtk_builder_get_object(builder, "dateStart"));
|
|
|
|
mainWindow->dateEnd = GTK_WIDGET(gtk_builder_get_object(builder, "dateEnd"));
|
|
|
|
mainWindow->entryText = GTK_WIDGET(gtk_builder_get_object(builder, "entryText"));
|
2017-02-01 17:33:01 +01:00
|
|
|
mainWindow->popoverDate = GTK_WIDGET(gtk_builder_get_object(builder, "popoverDate"));
|
|
|
|
mainWindow->calendarRange = GTK_WIDGET(gtk_builder_get_object(builder, "calendarRange"));
|
2017-02-04 12:17:41 +01:00
|
|
|
mainWindow->checkSearchTitle = GTK_WIDGET(gtk_builder_get_object(builder, "checkSearchTitle"));
|
2017-02-04 18:40:51 +01:00
|
|
|
mainWindow->checkSearchSummary = GTK_WIDGET(gtk_builder_get_object(builder, "checkSearchSummary"));
|
2017-02-04 12:17:41 +01:00
|
|
|
mainWindow->checkSearchTags = GTK_WIDGET(gtk_builder_get_object(builder, "checkSearchTags"));
|
|
|
|
mainWindow->checkSearchText = GTK_WIDGET(gtk_builder_get_object(builder, "checkSearchText"));
|
2017-02-04 18:31:05 +01:00
|
|
|
mainWindow->labelSummary = GTK_WIDGET(gtk_builder_get_object(builder, "labelSummary"));
|
2017-02-04 18:52:31 +01:00
|
|
|
mainWindow->buttonClearSearch = GTK_WIDGET(gtk_builder_get_object(builder, "buttonClearSearch"));
|
2017-01-31 21:31:31 +01:00
|
|
|
mainWindow->entryListView = GTK_TREE_VIEW(gtk_builder_get_object(builder, "entryListView"));
|
2017-02-02 20:02:33 +01:00
|
|
|
mainWindow->entryListSelection = GTK_TREE_SELECTION(gtk_builder_get_object(builder, "entryListSelection"));
|
2017-02-03 20:05:49 +01:00
|
|
|
mainWindow->textBuffer = GTK_TEXT_BUFFER(gtk_builder_get_object(builder, "entryTextBuffer"));
|
2017-01-31 19:42:41 +01:00
|
|
|
|
2017-02-05 15:31:04 +01:00
|
|
|
mainWindow->buttonOtherWorkspace = GTK_WIDGET(gtk_builder_get_object(builder, "buttonOtherWorkspace"));
|
2017-02-05 16:28:26 +01:00
|
|
|
mainWindow->workspaceSearch = GTK_WIDGET(gtk_builder_get_object(builder, "searchWorkspace"));
|
2017-02-05 15:31:04 +01:00
|
|
|
mainWindow->popoverWorkspace = GTK_WIDGET(gtk_builder_get_object(builder, "popoverWorkspace"));
|
|
|
|
mainWindow->workspaceListView = GTK_TREE_VIEW(gtk_builder_get_object(builder, "treeWorkspace"));
|
|
|
|
mainWindow->workspaceListSelection = GTK_TREE_SELECTION(gtk_builder_get_object(builder,
|
|
|
|
"treeWorkspaceSelection"));
|
|
|
|
|
2017-02-02 20:20:22 +01:00
|
|
|
mainWindow->filterSettings.time_start = 0;
|
|
|
|
mainWindow->filterSettings.time_end = -1;
|
2017-02-04 19:55:08 +01:00
|
|
|
mainWindow->time_earliest = 0;
|
|
|
|
mainWindow->time_latest = 0;
|
2017-02-02 20:20:22 +01:00
|
|
|
|
2017-01-31 19:42:41 +01:00
|
|
|
gtk_builder_connect_signals(builder, NULL);
|
|
|
|
|
|
|
|
g_object_unref(G_OBJECT(builder));
|
|
|
|
|
2017-01-31 21:56:37 +01:00
|
|
|
mainWindow_configure_treeView(mainWindow);
|
2017-02-01 17:37:31 +01:00
|
|
|
mainWindow_connect_signals(mainWindow);
|
2017-02-05 15:31:04 +01:00
|
|
|
mainWindow_configure_workspaceTreeView(mainWindow);
|
2017-02-04 18:52:31 +01:00
|
|
|
mainWindow_init_to_default(mainWindow);
|
|
|
|
mainWindow_clearSearch(NULL, mainWindow);
|
2017-02-03 19:14:42 +01:00
|
|
|
|
2017-01-31 19:42:41 +01:00
|
|
|
return mainWindow;
|
|
|
|
}
|
2017-02-01 17:33:01 +01:00
|
|
|
|
2017-02-04 19:55:08 +01:00
|
|
|
/**
|
|
|
|
* @brief mainWindow_set_meta_information sets some meta info for a nice GUI. It also resets the search.
|
|
|
|
* @param mainWindow
|
|
|
|
* @param time_earliest is the reset value for the filter start date
|
|
|
|
* @param time_latest is the reset value for the filter end date
|
|
|
|
*/
|
|
|
|
void mainWindow_set_meta_information(struct mainWindow *mainWindow, guint time_earliest, guint time_latest)
|
|
|
|
{
|
|
|
|
mainWindow->time_earliest = time_earliest;
|
|
|
|
mainWindow->time_latest = time_latest;
|
|
|
|
|
|
|
|
mainWindow_clearSearch(NULL, mainWindow);
|
|
|
|
}
|
|
|
|
|
2017-02-03 20:38:44 +01:00
|
|
|
/**
|
2017-02-05 14:31:17 +01:00
|
|
|
* @brief mainWindow_otherWorkspaceClicked is called when the user clicks the Other Workspace button.
|
2017-02-03 20:38:44 +01:00
|
|
|
* @param widget N/A
|
|
|
|
* @param event N/A
|
|
|
|
* @param user_data struct mainWindow *
|
|
|
|
*/
|
2017-02-05 14:31:17 +01:00
|
|
|
void mainWindow_otherWorkspaceClicked(GtkWidget *widget, gint event, gpointer user_data)
|
2017-02-01 17:33:01 +01:00
|
|
|
{
|
2017-02-05 15:31:04 +01:00
|
|
|
g_print("TODO: Show directory browser dialog.\n");
|
2017-02-01 17:33:01 +01:00
|
|
|
}
|
|
|
|
|
2017-02-03 20:38:44 +01:00
|
|
|
/**
|
|
|
|
* @brief mainWindow_showPopover is called from a dateEntry when it is focused.
|
|
|
|
* @param widget is the text entry.
|
|
|
|
* @param event N/A
|
|
|
|
* @param user_data struct mainWindow *
|
|
|
|
*/
|
2017-02-03 19:14:42 +01:00
|
|
|
void mainWindow_showPopover(GtkWidget *widget, GdkEvent *event, gpointer user_data)
|
2017-02-01 17:33:01 +01:00
|
|
|
{
|
|
|
|
struct mainWindow *mainWindow = (struct mainWindow *)user_data;
|
2017-02-03 19:14:42 +01:00
|
|
|
GDateTime *datetime;
|
|
|
|
|
|
|
|
mainWindow->selectedDateEntry = NULL;
|
2017-02-01 17:33:01 +01:00
|
|
|
|
2017-02-03 19:14:42 +01:00
|
|
|
datetime = g_date_time_new_from_unix_local((widget == mainWindow->dateStart
|
|
|
|
? mainWindow->filterSettings.time_start
|
|
|
|
: mainWindow->filterSettings.time_end));
|
|
|
|
if (datetime) {
|
|
|
|
gtk_calendar_select_month(GTK_CALENDAR(mainWindow->calendarRange),
|
|
|
|
g_date_time_get_month(datetime) - 1,
|
|
|
|
g_date_time_get_year(datetime));
|
|
|
|
gtk_calendar_select_day(GTK_CALENDAR(mainWindow->calendarRange),
|
|
|
|
g_date_time_get_day_of_month(datetime));
|
|
|
|
g_date_time_unref(datetime);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* gtk_editable_select_region(GTK_EDITABLE(widget), 0, 255); */
|
2017-02-01 17:33:01 +01:00
|
|
|
mainWindow->selectedDateEntry = widget;
|
|
|
|
|
|
|
|
if (!gtk_widget_get_visible(mainWindow->popoverDate))
|
|
|
|
gtk_popover_popup(GTK_POPOVER(mainWindow->popoverDate));
|
|
|
|
gtk_popover_set_relative_to(GTK_POPOVER(mainWindow->popoverDate), widget);
|
|
|
|
}
|
|
|
|
|
2017-02-03 20:38:44 +01:00
|
|
|
/**
|
|
|
|
* @brief mainWindow_calendarSelected is the callback when the user selects a date in the calendar.
|
|
|
|
* @param widget is the calendar.
|
|
|
|
* @param user_data struct mainWindow *
|
|
|
|
*/
|
2017-02-01 17:33:01 +01:00
|
|
|
void mainWindow_calendarSelected(GtkWidget *widget, gpointer user_data)
|
|
|
|
{
|
|
|
|
struct mainWindow *mainWindow = (struct mainWindow *)user_data;
|
|
|
|
guint year, month, day;
|
|
|
|
gchar *text;
|
|
|
|
|
2017-02-03 19:14:42 +01:00
|
|
|
if (mainWindow->selectedDateEntry) {
|
|
|
|
gtk_calendar_get_date(GTK_CALENDAR(mainWindow->calendarRange), &year, &month, &day);
|
|
|
|
text = g_strdup_printf("%d-%02d-%02d", year, month + 1, day);
|
|
|
|
gtk_entry_set_text(GTK_ENTRY(mainWindow->selectedDateEntry), text);
|
|
|
|
g_free(text);
|
|
|
|
}
|
2017-02-01 17:33:01 +01:00
|
|
|
}
|
2017-02-02 20:02:33 +01:00
|
|
|
|
2017-02-03 20:38:44 +01:00
|
|
|
/**
|
|
|
|
* @brief mainWindow_entrySelected is the callback when the user selects a diary entry.
|
|
|
|
* @param widget N/A
|
|
|
|
* @param user_data struct mainWindow *
|
|
|
|
*/
|
2017-02-02 20:02:33 +01:00
|
|
|
void mainWindow_entrySelected(GtkWidget *widget, gpointer user_data)
|
|
|
|
{
|
|
|
|
struct mainWindow *mainWindow = (struct mainWindow *)user_data;
|
|
|
|
GtkTreeSelection *selection;
|
|
|
|
GtkTreeModel *model;
|
|
|
|
GtkTreeIter iter;
|
2017-02-04 18:31:05 +01:00
|
|
|
gchar *text;
|
|
|
|
gchar *title;
|
|
|
|
gchar *summary;
|
2017-02-02 20:02:33 +01:00
|
|
|
gchar *temp;
|
|
|
|
|
|
|
|
selection = gtk_tree_view_get_selection(mainWindow->entryListView);
|
2017-02-02 20:04:35 +01:00
|
|
|
if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
|
2017-02-04 18:31:05 +01:00
|
|
|
gtk_tree_model_get(model, &iter, COL_TEXT, &text, -1);
|
2017-02-04 20:18:57 +01:00
|
|
|
gtk_text_buffer_set_text(mainWindow->textBuffer, text, strlen(text));
|
2017-02-04 18:31:05 +01:00
|
|
|
g_free(text);
|
|
|
|
|
|
|
|
gtk_tree_model_get(model, &iter, COL_SUMMARY, &summary, -1);
|
|
|
|
gtk_tree_model_get(model, &iter, COL_TITLE, &title, -1);
|
|
|
|
temp = g_strdup_printf("<b>%s</b>: %s", title, summary);
|
|
|
|
gtk_label_set_markup(GTK_LABEL(mainWindow->labelSummary), temp);
|
|
|
|
g_free(title);
|
|
|
|
g_free(summary);
|
2017-02-02 20:02:33 +01:00
|
|
|
g_free(temp);
|
2017-02-04 18:31:05 +01:00
|
|
|
} else {
|
|
|
|
gtk_text_buffer_set_text(mainWindow->textBuffer, "", 0);
|
2017-02-04 18:52:31 +01:00
|
|
|
gtk_label_set_text(GTK_LABEL(mainWindow->labelSummary), "Please select an entry in the list above.");
|
2017-02-02 20:02:33 +01:00
|
|
|
}
|
|
|
|
}
|
2017-02-02 21:36:49 +01:00
|
|
|
|
2017-02-03 20:25:34 +01:00
|
|
|
/**
|
|
|
|
* @brief mainWindow_filterChanged updates the filter backend values
|
|
|
|
* @param widget The widget that caused the update request. Can be NULL to update all.
|
|
|
|
* @param user_data struct mainWindow *
|
|
|
|
*/
|
|
|
|
void mainWindow_filterChanged(GtkWidget *widget, gpointer user_data)
|
2017-02-02 21:36:49 +01:00
|
|
|
{
|
|
|
|
GDateTime *datetime;
|
|
|
|
struct mainWindow *mainWindow = (struct mainWindow *)user_data;
|
|
|
|
|
2017-02-03 20:25:34 +01:00
|
|
|
if (!widget || widget == mainWindow->dateStart) {
|
2017-02-04 16:12:46 +01:00
|
|
|
datetime = mdiary_get_date_from_string((gchar *)gtk_entry_get_text(
|
|
|
|
GTK_ENTRY(mainWindow->dateStart)));
|
2017-02-03 20:25:34 +01:00
|
|
|
if (datetime) {
|
|
|
|
mainWindow->filterSettings.time_start = g_date_time_to_unix(datetime);
|
|
|
|
g_date_time_unref(datetime);
|
|
|
|
}
|
2017-02-05 14:47:45 +01:00
|
|
|
|
|
|
|
gtk_entry_set_icon_from_icon_name(GTK_ENTRY(widget ? widget : mainWindow->dateStart),
|
|
|
|
GTK_ENTRY_ICON_SECONDARY, "edit-clear-symbolic");
|
2017-02-02 21:36:49 +01:00
|
|
|
}
|
2017-02-03 20:25:34 +01:00
|
|
|
if (!widget || widget == mainWindow->dateEnd) {
|
2017-02-04 16:12:46 +01:00
|
|
|
datetime = mdiary_get_date_from_string((gchar *)gtk_entry_get_text(
|
|
|
|
GTK_ENTRY(mainWindow->dateEnd)));
|
2017-02-03 20:25:34 +01:00
|
|
|
if (datetime) {
|
|
|
|
mainWindow->filterSettings.time_end = g_date_time_to_unix(datetime);
|
|
|
|
g_date_time_unref(datetime);
|
|
|
|
}
|
2017-02-05 14:47:45 +01:00
|
|
|
|
|
|
|
gtk_entry_set_icon_from_icon_name(GTK_ENTRY(widget ? widget : mainWindow->dateStart),
|
|
|
|
GTK_ENTRY_ICON_SECONDARY, "edit-clear-symbolic");
|
2017-02-03 20:25:34 +01:00
|
|
|
}
|
2017-02-02 21:36:49 +01:00
|
|
|
|
2017-02-04 18:40:51 +01:00
|
|
|
mainWindow->filterSettings.search_title = gtk_toggle_button_get_active(
|
|
|
|
GTK_TOGGLE_BUTTON(mainWindow->checkSearchTitle));
|
|
|
|
mainWindow->filterSettings.search_tags = gtk_toggle_button_get_active(
|
|
|
|
GTK_TOGGLE_BUTTON(mainWindow->checkSearchTags));
|
|
|
|
mainWindow->filterSettings.search_text = gtk_toggle_button_get_active(
|
|
|
|
GTK_TOGGLE_BUTTON(mainWindow->checkSearchText));
|
|
|
|
mainWindow->filterSettings.search_summary = gtk_toggle_button_get_active(
|
|
|
|
GTK_TOGGLE_BUTTON(mainWindow->checkSearchSummary));
|
2017-02-04 12:17:41 +01:00
|
|
|
|
2017-02-02 21:36:49 +01:00
|
|
|
gtk_tree_model_filter_refilter(mainWindow->entryListFiltered);
|
|
|
|
}
|
2017-02-03 19:37:31 +01:00
|
|
|
|
2017-02-03 20:38:44 +01:00
|
|
|
/**
|
|
|
|
* @brief mainWindow_checkDate checks the date in a text box and resets it if necessary.
|
|
|
|
* @param widget is the GtkEntry to be checked.
|
|
|
|
* @param event N/A
|
|
|
|
* @param user_data struct mainWindow *
|
|
|
|
*/
|
2017-02-03 19:37:31 +01:00
|
|
|
void mainWindow_checkDate(GtkWidget *widget, gint event, gpointer user_data)
|
|
|
|
{
|
|
|
|
struct mainWindow *mainWindow = (struct mainWindow *)user_data;
|
|
|
|
GDateTime *datetime;
|
|
|
|
|
2017-02-04 16:12:46 +01:00
|
|
|
datetime = mdiary_get_date_from_string((char *)gtk_entry_get_text(GTK_ENTRY(widget)));
|
2017-02-03 19:37:31 +01:00
|
|
|
if (!datetime) {
|
|
|
|
datetime = g_date_time_new_from_unix_local(widget == mainWindow->dateStart
|
|
|
|
? mainWindow->filterSettings.time_start
|
|
|
|
: mainWindow->filterSettings.time_end);
|
|
|
|
gtk_entry_set_text(GTK_ENTRY(widget),
|
|
|
|
g_date_time_format(datetime, "%Y-%m-%d"));
|
|
|
|
}
|
|
|
|
g_date_time_unref(datetime);
|
|
|
|
}
|
2017-02-04 18:52:31 +01:00
|
|
|
|
|
|
|
/**
|
|
|
|
* @brief mainWindow_clearSearch resets all search UI elements
|
|
|
|
* @param widget
|
|
|
|
* @param event
|
|
|
|
* @param user_data
|
|
|
|
*/
|
|
|
|
void mainWindow_clearSearch(GtkWidget *widget, gpointer user_data)
|
|
|
|
{
|
|
|
|
struct mainWindow *mainWindow = (struct mainWindow *)user_data;
|
2017-02-04 19:55:08 +01:00
|
|
|
GDateTime *datetime;
|
|
|
|
gchar *temp;
|
2017-02-04 18:52:31 +01:00
|
|
|
|
2017-02-04 20:38:29 +01:00
|
|
|
if (widget == mainWindow->buttonClearSearch)
|
|
|
|
widget = NULL;
|
2017-02-04 18:52:31 +01:00
|
|
|
|
2017-02-04 20:38:29 +01:00
|
|
|
if (!widget || widget == mainWindow->searchEntry)
|
|
|
|
gtk_entry_set_text(GTK_ENTRY(mainWindow->searchEntry), "");
|
2017-02-04 19:55:08 +01:00
|
|
|
|
2017-02-04 20:38:29 +01:00
|
|
|
if (!widget || widget == mainWindow->dateStart) {
|
|
|
|
datetime = g_date_time_new_from_unix_local(mainWindow->time_earliest);
|
|
|
|
temp = g_date_time_format(datetime, "%Y-%m-%d");
|
|
|
|
gtk_entry_set_text(GTK_ENTRY(mainWindow->dateStart), temp);
|
|
|
|
g_date_time_unref(datetime);
|
|
|
|
g_free(temp);
|
2017-02-05 14:47:45 +01:00
|
|
|
gtk_entry_set_icon_from_icon_name(GTK_ENTRY(widget ? widget : mainWindow->dateStart),
|
|
|
|
GTK_ENTRY_ICON_SECONDARY, "");
|
2017-02-04 20:38:29 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
if (!widget || widget == mainWindow->dateEnd) {
|
|
|
|
datetime = g_date_time_new_from_unix_local(mainWindow->time_latest);
|
|
|
|
temp = g_date_time_format(datetime, "%Y-%m-%d");
|
|
|
|
gtk_entry_set_text(GTK_ENTRY(mainWindow->dateEnd), temp);
|
|
|
|
g_date_time_unref(datetime);
|
|
|
|
g_free(temp);
|
2017-02-05 14:47:45 +01:00
|
|
|
gtk_entry_set_icon_from_icon_name(GTK_ENTRY(widget ? widget : mainWindow->dateEnd),
|
|
|
|
GTK_ENTRY_ICON_SECONDARY, "");
|
2017-02-04 20:38:29 +01:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void mainWindow_dateIconPress(GtkWidget *widget, gint icon_pos, gint event, gpointer user_data)
|
|
|
|
{
|
|
|
|
mainWindow_clearSearch(widget, user_data);
|
2017-02-04 18:52:31 +01:00
|
|
|
}
|
2017-02-05 15:31:04 +01:00
|
|
|
|
|
|
|
void mainWindow_workspaceListClicked(GtkWidget *widget,
|
2017-02-05 16:28:26 +01:00
|
|
|
GtkTreePath *tree_path,
|
2017-02-05 15:31:04 +01:00
|
|
|
GtkTreeViewColumn *column,
|
|
|
|
gpointer user_data)
|
|
|
|
{
|
|
|
|
struct mainWindow *mainWindow = (struct mainWindow *)user_data;
|
2017-02-05 16:28:26 +01:00
|
|
|
GtkTreeModel *model;
|
|
|
|
GtkTreeIter iter;
|
|
|
|
GtkTreeSelection *selection;
|
|
|
|
gchar *path;
|
2017-02-05 15:31:04 +01:00
|
|
|
|
|
|
|
gtk_popover_popdown(GTK_POPOVER(mainWindow->popoverWorkspace));
|
2017-02-05 16:28:26 +01:00
|
|
|
|
|
|
|
selection = gtk_tree_view_get_selection(mainWindow->workspaceListView);
|
|
|
|
if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
|
|
|
|
gtk_tree_model_get(model, &iter, WSCOL_PATH, &path, -1);
|
|
|
|
g_print("TODO: Switch workspace to %s\n", path);
|
|
|
|
g_free(path);
|
|
|
|
}
|
2017-02-05 15:31:04 +01:00
|
|
|
}
|