Federated_Computer/federated-calendar
3
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
e2a2721e9e85d3ed6b26ac0e07569aebda69ba0d
federated-calendar/src/gcal-window.c
T

1380 lines
45 KiB
C
Raw Blame History

/* -*- mode: c; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/*
* gcal-window.c
* Copyright (C) 2012 Erick Pérez Castellanos <erickpc@gnome.org>
* Copyright (C) 2014 Georges Basile Stavracas Neto <georges.stavracas@gmail.com>
*
* gnome-calendar is free software: you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* gnome-calendar is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
* See the GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "gcal-window.h"
#include "gcal-nav-bar.h"
#include "gcal-manager.h"
#include "gcal-view.h"
#include "gcal-month-view.h"
#include "gcal-week-view.h"
#include "gcal-year-view.h"
#include "gcal-search-view.h"
#include "gcal-event-widget.h"
#include "gcal-edit-dialog.h"
#include "gcal-enum-types.h"
#include "e-cell-renderer-color.h"
#include <glib/gi18n.h>
#include <libecal/libecal.h>
#include <libical/icaltime.h>
struct _NewEventData
{
gint x;
gint y;
icaltimetype *start_date;
icaltimetype *end_date;
};
typedef struct _NewEventData NewEventData;
typedef struct
{
/* timeout ids */
guint save_geometry_timeout_id;
/* upper level widgets */
GtkWidget *main_box;
GtkWidget *header_bar;
GtkWidget *search_bar;
GtkWidget *nav_bar;
GtkWidget *views_overlay;
GtkWidget *views_stack;
GtkWidget *notification;
GtkWidget *notification_label;
GtkWidget *notification_action_button;
GtkWidget *notification_close_button;
/* header_bar widets */
GtkWidget *menu_button;
GtkWidget *search_button;
GtkWidget *search_entry;
GtkWidget *back_button;
GtkWidget *today_button;
GtkWidget *forward_button;
GtkWidget *views_switcher;
/* new event popover widgets */
GtkWidget *popover;
GtkWidget *new_event_title_label;
GtkWidget *new_event_create_button;
GtkWidget *new_event_details_button;
GtkWidget *new_event_what_entry;
/* day, week, month, year, list, search */
GtkWidget *views [6];
GtkWidget *edit_dialog;
GcalManager *manager;
GcalWindowViewType active_view;
icaltimetype *active_date;
/* states */
gboolean new_event_mode;
gboolean search_mode;
gboolean leaving_search_mode;
NewEventData *event_creation_data;
GcalEventData *event_to_delete;
/* temp to keep event_creation */
gboolean open_edit_dialog;
} GcalWindowPrivate;
enum
{
PROP_0,
PROP_ACTIVE_VIEW,
PROP_ACTIVE_DATE,
PROP_NEW_EVENT_MODE,
PROP_MANAGER
};
#define SAVE_GEOMETRY_ID_TIMEOUT 100 /* ms */
static gboolean key_pressed (GtkWidget *widget,
GdkEvent *event,
gpointer user_data);
static void date_updated (GtkButton *buttton,
gpointer user_data);
static void load_geometry (GcalWindow *window);
static gboolean save_geometry (gpointer user_data);
static void update_view (GcalWindow *window);
static void view_changed (GObject *object,
GParamSpec *pspec,
gpointer user_data);
static void stack_transition_running (GObject *object,
GParamSpec *pspec,
gpointer user_data);
static void set_new_event_mode (GcalWindow *window,
gboolean enabled);
static void show_new_event_widget (GcalView *view,
gpointer start_span,
gpointer end_span,
gdouble x,
gdouble y,
gpointer user_data);
static void prepare_new_event_widget (GcalWindow *window);
static void place_new_event_widget (GcalWindow *window,
gint x,
gint y);
static void close_new_event_widget (GtkButton *button,
gpointer user_data);
static void create_notification (GcalWindow *window,
gchar *message,
gchar *button_label);
static void hide_notification (GtkWidget *button,
gpointer user_data);
/* handling events interaction */
static void create_event (gpointer user_data,
GtkWidget *widget);
static void event_activated (GcalView *view,
GcalEventWidget *event_widget,
gpointer user_data);
static void edit_dialog_closed (GtkDialog *dialog,
gint response,
gpointer user_data);
static void search_toggled (GObject *object,
GParamSpec *pspec,
gpointer user_data);
static void search_changed (GtkEditable *editable,
gpointer user_data);
static void remove_event (GtkWidget *notification,
GParamSpec *spec,
gpointer user_data);
static void undo_remove_event (GtkButton *button,
gpointer user_data);
static void gcal_window_constructed (GObject *object);
static void gcal_window_finalize (GObject *object);
static void gcal_window_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec);
static void gcal_window_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec);
static gboolean gcal_window_configure_event (GtkWidget *widget,
GdkEventConfigure *event);
static gboolean gcal_window_state_event (GtkWidget *widget,
GdkEventWindowState *event);
G_DEFINE_TYPE_WITH_PRIVATE (GcalWindow, gcal_window, GTK_TYPE_APPLICATION_WINDOW)
static gboolean
key_pressed (GtkWidget *widget,
GdkEvent *event,
gpointer user_data)
{
GcalWindowPrivate *priv;
priv = gcal_window_get_instance_private (GCAL_WINDOW (user_data));
/* special case: creating an event */
if (priv->new_event_mode)
return GDK_EVENT_PROPAGATE;
return gtk_search_bar_handle_event (GTK_SEARCH_BAR (priv->search_bar),
event);
}
static void
date_updated (GtkButton *button,
gpointer user_data)
{
GcalWindowPrivate *priv;
gboolean move_back, move_today;
priv = gcal_window_get_instance_private (GCAL_WINDOW (user_data));
move_today = priv->today_button == (GtkWidget*) button;
move_back = priv->back_button == (GtkWidget*) button;
if (move_today)
{
*(priv->active_date) =
icaltime_current_time_with_zone (
gcal_manager_get_system_timezone (priv->manager));
*(priv->active_date) =
icaltime_set_timezone (
priv->active_date,
gcal_manager_get_system_timezone (priv->manager));
}
else
{
switch (priv->active_view)
{
case GCAL_WINDOW_VIEW_DAY:
priv->active_date->day += 1 * (move_back ? -1 : 1);
break;
case GCAL_WINDOW_VIEW_WEEK:
priv->active_date->day += 7 * (move_back ? -1 : 1);
break;
case GCAL_WINDOW_VIEW_MONTH:
priv->active_date->month += 1 * (move_back ? -1 : 1);
break;
case GCAL_WINDOW_VIEW_YEAR:
priv->active_date->year += 1 * (move_back ? -1 : 1);
break;
case GCAL_WINDOW_VIEW_LIST:
case GCAL_WINDOW_VIEW_SEARCH:
break;
}
}
*(priv->active_date) = icaltime_normalize (*(priv->active_date));
g_object_notify (user_data, "active-date");
update_view (GCAL_WINDOW (user_data));
}
static void
load_geometry (GcalWindow *window)
{
GcalApplication *app;
GSettings *settings;
GVariant *variant;
gboolean maximized;
const gint32 *position;
const gint32 *size;
gsize n_elements;
app = GCAL_APPLICATION (gtk_window_get_application (GTK_WINDOW (window)));
settings = gcal_application_get_settings (app);
/* load window settings: size */
variant = g_settings_get_value (settings,
"window-size");
size = g_variant_get_fixed_array (variant,
&n_elements,
sizeof (gint32));
if (n_elements == 2)
gtk_window_set_default_size (GTK_WINDOW (window),
size[0],
size[1]);
g_variant_unref (variant);
/* load window settings: position */
variant = g_settings_get_value (settings,
"window-position");
position = g_variant_get_fixed_array (variant,
&n_elements,
sizeof (gint32));
if (n_elements == 2)
gtk_window_move (GTK_WINDOW (window),
position[0],
position[1]);
g_variant_unref (variant);
/* load window settings: state */
maximized = g_settings_get_boolean (settings,
"window-maximized");
if (maximized)
gtk_window_maximize (GTK_WINDOW (window));
}
static gboolean
save_geometry (gpointer user_data)
{
GtkWindow *self;
GdkWindow *window;
GcalWindowPrivate *priv;
GdkWindowState state;
GcalApplication *app;
GSettings *settings;
gboolean maximized;
GVariant *variant;
gint32 size[2];
gint32 position[2];
self = GTK_WINDOW (user_data);
window = gtk_widget_get_window (GTK_WIDGET (self));
state = gdk_window_get_state (window);
priv = gcal_window_get_instance_private (GCAL_WINDOW (self));
app = GCAL_APPLICATION (gtk_window_get_application (self));
settings = gcal_application_get_settings (app);
/* save window's state */
maximized = state & GDK_WINDOW_STATE_MAXIMIZED;
g_settings_set_boolean (settings,
"window-maximized",
maximized);
if (maximized)
{
priv->save_geometry_timeout_id = 0;
return FALSE;
}
/* save window's size */
gtk_window_get_size (self,
(gint *) &size[0],
(gint *) &size[1]);
variant = g_variant_new_fixed_array (G_VARIANT_TYPE_INT32,
size,
2,
sizeof (size[0]));
g_settings_set_value (settings,
"window-size",
variant);
/* save windows's position */
gtk_window_get_position (self,
(gint *) &position[0],
(gint *) &position[1]);
variant = g_variant_new_fixed_array (G_VARIANT_TYPE_INT32,
position,
2,
sizeof (position[0]));
g_settings_set_value (settings,
"window-position",
variant);
priv->save_geometry_timeout_id = 0;
return FALSE;
}
/**
* update_view:
* @window:
*
* Update the headers on the navbar. Everything else on the application
* updates itself on the date change.
**/
static void
update_view (GcalWindow *window)
{
GcalWindowPrivate *priv;
GtkWidget *widget;
gchar* header;
priv = gcal_window_get_instance_private (window);
widget = priv->views[priv->active_view];
if (widget != NULL)
{
header = gcal_view_get_left_header (GCAL_VIEW (widget));
g_object_set (priv->nav_bar, "left-header", header, NULL);
g_free (header);
header = gcal_view_get_right_header (GCAL_VIEW (widget));
g_object_set (priv->nav_bar, "right-header", header, NULL);
g_free (header);
}
}
/**
* view_changed:
* @object:
* @pspec:
* @user_data:
*
* Called every time the user activate the stack-switcher
* Retrieve the enum value representing the view, update internal
* @active_view with it and call @update_view
**/
static void
view_changed (GObject *object,
GParamSpec *pspec,
gpointer user_data)
{
GcalWindowPrivate *priv;
GEnumClass *eklass;
GEnumValue *eval;
GcalWindowViewType view_type;
priv = gcal_window_get_instance_private (GCAL_WINDOW (user_data));
/* XXX: this is the destruction process */
if (!gtk_widget_get_visible (priv->views_stack))
return;
eklass = g_type_class_ref (gcal_window_view_type_get_type ());
eval = g_enum_get_value_by_nick (
eklass,
gtk_stack_get_visible_child_name (GTK_STACK (priv->views_stack)));
view_type = eval->value;
g_type_class_unref (eklass);
if (view_type == GCAL_WINDOW_VIEW_SEARCH)
return;
priv->active_view = view_type;
g_object_notify (G_OBJECT (user_data), "active-view");
update_view (GCAL_WINDOW (user_data));
}
/**
* stack_transition_running:
* @object:
* @pspec:
* @user_data:
*
* Listen on the transition of the stack to leave search-mode properly
**/
static void
stack_transition_running (GObject *object,
GParamSpec *pspec,
gpointer user_data)
{
GcalWindowPrivate *priv;
priv = gcal_window_get_instance_private (GCAL_WINDOW (user_data));
/* XXX: this is the destruction process */
if (!gtk_widget_get_visible (priv->views_stack))
return;
if (!priv->leaving_search_mode)
return;
priv->leaving_search_mode = FALSE;
gtk_container_remove (GTK_CONTAINER (priv->views_stack),
priv->views[GCAL_WINDOW_VIEW_SEARCH]);
gtk_widget_hide (priv->views[GCAL_WINDOW_VIEW_SEARCH]);
gtk_widget_hide (priv->search_bar);
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (priv->header_bar),
priv->views_switcher);
}
static void
set_new_event_mode (GcalWindow *window,
gboolean enabled)
{
GcalWindowPrivate *priv;
priv = gcal_window_get_instance_private (window);
priv->new_event_mode = enabled;
g_object_notify (G_OBJECT (window), "new-event-mode");
if (! enabled && priv->views[priv->active_view] != NULL)
gcal_view_clear_marks (GCAL_VIEW (priv->views[priv->active_view]));
/* XXX: here we could disable clicks from the views, yet */
/* for now we relaunch the new-event widget */
if (!enabled &&
gtk_widget_is_visible (priv->popover))
{
gtk_widget_set_visible (priv->popover, FALSE);
}
}
/* new-event interaction: second variant */
static void
show_new_event_widget (GcalView *view,
gpointer start_span,
gpointer end_span,
gdouble x,
gdouble y,
gpointer user_data)
{
GcalWindowPrivate *priv;
g_return_if_fail (user_data);
priv = gcal_window_get_instance_private (GCAL_WINDOW (user_data));
/* 1st and 2nd steps */
set_new_event_mode (GCAL_WINDOW (user_data), TRUE);
if (priv->event_creation_data != NULL)
{
g_free (priv->event_creation_data->start_date);
g_free (priv->event_creation_data->end_date);
g_free (priv->event_creation_data);
}
priv->event_creation_data = g_new0 (NewEventData, 1);
priv->event_creation_data->x = x;
priv->event_creation_data->y = y;
priv->event_creation_data->start_date = gcal_dup_icaltime (start_span);
if (end_span != NULL)
priv->event_creation_data->end_date = gcal_dup_icaltime (end_span);
g_debug ("[show_new_event] position (%f, %f)", x, y);
/* Setup new event widget data */
prepare_new_event_widget (GCAL_WINDOW (user_data));
place_new_event_widget (GCAL_WINDOW (user_data), x, y);
}
static void
prepare_new_event_widget (GcalWindow *window)
{
GcalWindowPrivate *priv;
struct tm tm_date;
gchar start[64];
gchar *title_date;
priv = gcal_window_get_instance_private (window);
/* setting title */
tm_date = icaltimetype_to_tm (priv->event_creation_data->start_date);
e_utf8_strftime_fix_am_pm (start, 64, "%B %d", &tm_date);
title_date = g_strdup_printf (_("New Event on %s"), start);
gtk_label_set_text (GTK_LABEL (priv->new_event_title_label),
title_date);
g_free (title_date);
/* clear entry */
gtk_entry_set_text (GTK_ENTRY (priv->new_event_what_entry), "");
}
static void
place_new_event_widget (GcalWindow *window,
gint x,
gint y)
{
GcalWindowPrivate *priv;
gint out_x, out_y;
GdkRectangle rect;
priv = gcal_window_get_instance_private (window);
gtk_widget_translate_coordinates (priv->views[priv->active_view], priv->views_stack, x, y, &out_x, &out_y);
/* Place popover over the given (x,y) position */
rect.x = out_x;
rect.y = out_y;
rect.width = 1;
rect.height = 1;
gtk_popover_set_pointing_to (GTK_POPOVER (priv->popover), &rect);
gtk_widget_show_all (priv->popover);
}
static void
close_new_event_widget (GtkButton *button,
gpointer user_data)
{
set_new_event_mode (GCAL_WINDOW (user_data), FALSE);
}
/**
* create_notification: Internal method for creating a notification
* @window:
* @message: The label it goes into the message part
* @button_label: (allow-none): The label of the actionable button
*
**/
static void
create_notification (GcalWindow *window,
gchar *message,
gchar *button_label)
{
GcalWindowPrivate *priv;
priv = gcal_window_get_instance_private (window);
/* notification content */
gtk_label_set_text (GTK_LABEL (priv->notification_label), message);
gtk_widget_show_all (priv->notification);
if (button_label != NULL)
{
gtk_button_set_label (GTK_BUTTON (priv->notification_action_button),
button_label);
gtk_widget_show (priv->notification_action_button);
}
else
{
gtk_widget_hide (priv->notification_action_button);
}
}
static void
hide_notification (GtkWidget *button,
gpointer user_data)
{
GcalWindowPrivate *priv;
priv = gcal_window_get_instance_private (GCAL_WINDOW (user_data));
gtk_revealer_set_reveal_child (GTK_REVEALER (priv->notification),
FALSE);
}
static void
create_event (gpointer user_data,
GtkWidget *widget)
{
GcalWindowPrivate *priv;
ESource *source;
ECalComponent *comp;
priv = gcal_window_get_instance_private (GCAL_WINDOW (user_data));
/* reset and hide */
set_new_event_mode (GCAL_WINDOW (user_data), FALSE);
source = gcal_manager_get_default_source (priv->manager);
comp = build_component_from_details (gtk_entry_get_text (GTK_ENTRY (priv->new_event_what_entry)),
priv->event_creation_data->start_date,
priv->event_creation_data->end_date);
if (widget == priv->new_event_details_button)
{
GcalEventData *edata;
edata = g_new0 (GcalEventData, 1);
edata->source = source;
edata->event_component = comp;
gcal_edit_dialog_set_event_is_new (GCAL_EDIT_DIALOG (priv->edit_dialog),
TRUE);
gcal_edit_dialog_set_event_data (GCAL_EDIT_DIALOG (priv->edit_dialog),
edata);
g_object_unref (comp);
g_free (edata);
gtk_dialog_run (GTK_DIALOG (priv->edit_dialog));
}
else
{
/* create the event */
gcal_manager_create_event (priv->manager, source, comp);
}
g_object_unref (source);
}
static void
event_activated (GcalView *view,
GcalEventWidget *event_widget,
gpointer user_data)
{
GcalWindowPrivate *priv;
GcalEventData *data;
priv = gcal_window_get_instance_private (GCAL_WINDOW (user_data));
data = gcal_event_widget_get_data (event_widget);
gcal_edit_dialog_set_event_is_new (
GCAL_EDIT_DIALOG (priv->edit_dialog),
FALSE);
gcal_edit_dialog_set_event_data (
GCAL_EDIT_DIALOG (priv->edit_dialog),
data);
g_free (data);
gtk_dialog_run (GTK_DIALOG (priv->edit_dialog));
}
static void
edit_dialog_closed (GtkDialog *dialog,
gint response,
gpointer user_data)
{
GcalWindowPrivate *priv;
GcalEditDialog *edit_dialog;
ECalComponent *component;
GcalView *view;
gchar *uuid;
priv = gcal_window_get_instance_private (GCAL_WINDOW (user_data));
gtk_widget_hide (GTK_WIDGET (dialog));
view = GCAL_VIEW (priv->views[priv->active_view]);
edit_dialog = GCAL_EDIT_DIALOG (dialog);
switch (response)
{
case GCAL_RESPONSE_CREATE_EVENT:
/* retrieve the component from the dialog*/
gcal_manager_create_event (priv->manager,
gcal_edit_dialog_get_source (edit_dialog),
gcal_edit_dialog_get_component (edit_dialog));
break;
case GCAL_RESPONSE_SAVE_EVENT:
/* retrieve the component from the dialog*/
component = gcal_edit_dialog_get_component (edit_dialog);
gcal_manager_update_event (priv->manager,
gcal_edit_dialog_get_source (edit_dialog),
component);
break;
case GCAL_RESPONSE_DELETE_EVENT:
/* delete the event */
create_notification (GCAL_WINDOW (user_data),
_("Event deleted"),
_("Undo"));
gtk_revealer_set_reveal_child (GTK_REVEALER (priv->notification),
TRUE);
/* FIXME: this will crash if the notification is still open */
if (priv->event_to_delete != NULL)
g_free (priv->event_to_delete);
priv->event_to_delete = g_new0 (GcalEventData, 1);
priv->event_to_delete->source =
gcal_edit_dialog_get_source (edit_dialog);
priv->event_to_delete->event_component =
gcal_edit_dialog_get_component (edit_dialog);
uuid = gcal_edit_dialog_get_event_uuid (edit_dialog);
/* hide widget of the event */
gtk_widget_hide (gcal_view_get_by_uuid (view, uuid));
g_free (uuid);
break;
case GTK_RESPONSE_CANCEL:
break;
}
}
static void
search_toggled (GObject *object,
GParamSpec *pspec,
gpointer user_data)
{
GcalWindowPrivate *priv;
priv = gcal_window_get_instance_private (GCAL_WINDOW (user_data));
if (gtk_search_bar_get_search_mode (GTK_SEARCH_BAR (priv->search_bar)))
{
g_debug ("Entering search mode");
gtk_widget_show (priv->search_bar);
/* update header_bar widget */
gtk_header_bar_set_custom_title (GTK_HEADER_BAR (priv->header_bar),
NULL);
gtk_widget_hide (priv->today_button);
gtk_widget_hide (priv->nav_bar);
gtk_widget_show (priv->views[GCAL_WINDOW_VIEW_SEARCH]);
gtk_stack_add_named (GTK_STACK (priv->views_stack),
priv->views[GCAL_WINDOW_VIEW_SEARCH],
"search");
if (gtk_stack_get_visible_child (GTK_STACK (priv->views_stack)) !=
priv->views[GCAL_WINDOW_VIEW_SEARCH])
{
gtk_stack_set_visible_child (GTK_STACK (priv->views_stack),
priv->views[GCAL_WINDOW_VIEW_SEARCH]);
}
}
else
{
g_debug ("Leaving search mode");
/* update header_bar */
gtk_widget_show (priv->nav_bar);
gtk_widget_show (priv->today_button);
gtk_header_bar_set_title (GTK_HEADER_BAR (priv->header_bar), _("Calendar"));
gtk_stack_set_visible_child (GTK_STACK (priv->views_stack),
priv->views[priv->active_view]);
priv->leaving_search_mode = TRUE;
}
}
static void
search_changed (GtkEditable *editable,
gpointer user_data)
{
GcalWindowPrivate *priv;
priv = gcal_window_get_instance_private (GCAL_WINDOW (user_data));
if (gtk_search_bar_get_search_mode (GTK_SEARCH_BAR (priv->search_bar)))
{
if (gtk_entry_get_text_length (GTK_ENTRY (priv->search_entry)) != 0)
{
gchar *title;
gchar *query;
title =
g_strdup_printf (
_("Results for \"%s\""),
gtk_entry_get_text (GTK_ENTRY (priv->search_entry)));
gtk_header_bar_set_title (GTK_HEADER_BAR (priv->header_bar),
title);
g_free (title);
/**/
query =
g_strdup_printf ("(contains? \"summary\" \"%s\")",
gtk_entry_get_text (GTK_ENTRY (priv->search_entry)));
gcal_manager_set_query (priv->manager, query);
g_free (query);
}
else
{
gtk_header_bar_set_title (GTK_HEADER_BAR (priv->header_bar),
"");
}
}
}
static void
remove_event (GtkWidget *notification,
GParamSpec *spec,
gpointer user_data)
{
GcalWindowPrivate *priv;
priv = gcal_window_get_instance_private (GCAL_WINDOW (user_data));
if (gtk_revealer_get_child_revealed (GTK_REVEALER (notification)))
return;
if (priv->event_to_delete != NULL)
{
gcal_manager_remove_event (priv->manager,
priv->event_to_delete->source,
priv->event_to_delete->event_component);
g_clear_pointer (&(priv->event_to_delete), g_free);
}
}
static void
undo_remove_event (GtkButton *button,
gpointer user_data)
{
GcalWindowPrivate *priv;
gchar *uuid;
GtkWidget *event_widget;
priv = gcal_window_get_instance_private (GCAL_WINDOW (user_data));
if (priv->event_to_delete != NULL)
{
uuid = get_uuid_from_component (
priv->event_to_delete->source,
priv->event_to_delete->event_component);
event_widget = gcal_view_get_by_uuid (
GCAL_VIEW (priv->views[priv->active_view]),
uuid);
gtk_widget_show (event_widget);
g_clear_pointer (&(priv->event_to_delete), g_free);
g_free (uuid);
gtk_revealer_set_reveal_child (GTK_REVEALER (priv->notification),
FALSE);
}
}
static void
gcal_window_class_init(GcalWindowClass *klass)
{
GObjectClass *object_class;
GtkWidgetClass *widget_class;
object_class = G_OBJECT_CLASS (klass);
object_class->constructed = gcal_window_constructed;
object_class->finalize = gcal_window_finalize;
object_class->set_property = gcal_window_set_property;
object_class->get_property = gcal_window_get_property;
widget_class = GTK_WIDGET_CLASS (klass);
widget_class->configure_event = gcal_window_configure_event;
widget_class->window_state_event = gcal_window_state_event;
gtk_widget_class_set_template_from_resource (widget_class, "/org/gnome/calendar/window.ui");
g_object_class_install_property (
object_class,
PROP_ACTIVE_VIEW,
g_param_spec_enum ("active-view",
"Active View",
"The active view, eg: month, week, etc.",
GCAL_WINDOW_VIEW_TYPE,
GCAL_WINDOW_VIEW_MONTH,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_ACTIVE_DATE,
g_param_spec_boxed ("active-date",
"Date",
"The active/selected date",
ICAL_TIME_TYPE,
G_PARAM_CONSTRUCT |
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_NEW_EVENT_MODE,
g_param_spec_boolean ("new-event-mode",
"New Event mode",
"Whether the window is in new-event-mode or not",
FALSE,
G_PARAM_READWRITE));
g_object_class_install_property (
object_class,
PROP_MANAGER,
g_param_spec_pointer ("manager",
"The manager object",
"A weak reference to the app manager object",
G_PARAM_CONSTRUCT_ONLY |
G_PARAM_READWRITE));
/* widgets */
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, header_bar);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, main_box);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, menu_button);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, nav_bar);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, search_bar);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, search_button);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, search_entry);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, back_button);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, today_button);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, forward_button);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, views_overlay);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, views_stack);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, views_switcher);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, popover);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, new_event_title_label);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, new_event_create_button);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, new_event_details_button);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, new_event_what_entry);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, notification);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, notification_label);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, notification_action_button);
gtk_widget_class_bind_template_child_private (widget_class, GcalWindow, notification_close_button);
gtk_widget_class_bind_template_callback (widget_class, key_pressed);
gtk_widget_class_bind_template_callback (widget_class, search_toggled);
gtk_widget_class_bind_template_callback (widget_class, search_changed);
gtk_widget_class_bind_template_callback (widget_class, view_changed);
gtk_widget_class_bind_template_callback (widget_class, stack_transition_running);
gtk_widget_class_bind_template_callback (widget_class, date_updated);
/* Event removal related */
gtk_widget_class_bind_template_callback (widget_class, hide_notification);
gtk_widget_class_bind_template_callback (widget_class, remove_event);
gtk_widget_class_bind_template_callback (widget_class, undo_remove_event);
/* Event creation related */
gtk_widget_class_bind_template_callback (widget_class, create_event);
gtk_widget_class_bind_template_callback (widget_class, close_new_event_widget);
}
static void
gcal_window_init (GcalWindow *self)
{
GcalWindowPrivate *priv;
priv = gcal_window_get_instance_private (self);
/* states */
priv->search_mode = FALSE;
priv->event_creation_data = NULL;
/* FIXME: Review real need of this */
priv->save_geometry_timeout_id = 0;
priv->event_to_delete = NULL;
priv->open_edit_dialog = FALSE;
gtk_widget_init_template (GTK_WIDGET (self));
}
static void
gcal_window_constructed (GObject *object)
{
GcalWindowPrivate *priv;
GtkBuilder *builder;
GMenuModel *winmenu;
GSettings *helper_settings;
gchar *clock_format;
gboolean use_24h_format;
gint i;
if (G_OBJECT_CLASS (gcal_window_parent_class)->constructed != NULL)
G_OBJECT_CLASS (gcal_window_parent_class)->constructed (object);
priv = gcal_window_get_instance_private (GCAL_WINDOW (object));
helper_settings = g_settings_new ("org.gnome.desktop.interface");
clock_format = g_settings_get_string (helper_settings, "clock-format");
use_24h_format = (g_strcmp0 (clock_format, "24h") == 0);
g_free (clock_format);
g_object_unref (helper_settings);
/* header_bar: menu */
builder = gtk_builder_new ();
gtk_builder_add_from_resource (builder,
"/org/gnome/calendar/menus.ui",
NULL);
winmenu = (GMenuModel *)gtk_builder_get_object (builder, "winmenu");
gtk_menu_button_set_menu_model (GTK_MENU_BUTTON (priv->menu_button),
winmenu);
g_object_unref (builder);
/* edit dialog initialization */
priv->edit_dialog = gcal_edit_dialog_new ();
gtk_window_set_transient_for (GTK_WINDOW (priv->edit_dialog), GTK_WINDOW (object));
gcal_edit_dialog_set_manager (GCAL_EDIT_DIALOG (priv->edit_dialog), priv->manager);
g_signal_connect (priv->edit_dialog, "response", G_CALLBACK (edit_dialog_closed), object);
/* search bar */
gtk_search_bar_connect_entry (GTK_SEARCH_BAR (priv->search_bar),
GTK_ENTRY (priv->search_entry));
priv->views[GCAL_WINDOW_VIEW_WEEK] =
gcal_week_view_new (priv->manager);
gcal_week_view_set_first_weekday (
GCAL_WEEK_VIEW (priv->views[GCAL_WINDOW_VIEW_WEEK]),
get_first_weekday ());
gcal_week_view_set_use_24h_format (
GCAL_WEEK_VIEW (priv->views[GCAL_WINDOW_VIEW_WEEK]),
use_24h_format);
gtk_stack_add_titled (GTK_STACK (priv->views_stack),
priv->views[GCAL_WINDOW_VIEW_WEEK],
"week", _("Week"));
priv->views[GCAL_WINDOW_VIEW_MONTH] =
gcal_month_view_new (priv->manager);
gcal_month_view_set_first_weekday (
GCAL_MONTH_VIEW (priv->views[GCAL_WINDOW_VIEW_MONTH]),
get_first_weekday ());
gtk_stack_add_titled (GTK_STACK (priv->views_stack),
priv->views[GCAL_WINDOW_VIEW_MONTH],
"month", _("Month"));
priv->views[GCAL_WINDOW_VIEW_YEAR] =
gcal_year_view_new (priv->manager);
gtk_stack_add_titled (GTK_STACK (priv->views_stack),
priv->views[GCAL_WINDOW_VIEW_YEAR],
"year", _("Year"));
priv->views[GCAL_WINDOW_VIEW_SEARCH] =
gcal_search_view_new (priv->manager);
g_object_ref_sink (priv->views[GCAL_WINDOW_VIEW_SEARCH]);
g_object_bind_property (GCAL_WINDOW (object), "active-date",
priv->views[GCAL_WINDOW_VIEW_SEARCH],
"active-date",
G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
/* signals connection/handling */
/* HACK to ensure proper destroy of search-view widget */
g_signal_connect_swapped (priv->views_stack, "destroy",
G_CALLBACK (gtk_widget_destroy),
priv->views[GCAL_WINDOW_VIEW_SEARCH]);
/* only GcalView implementations */
for (i = 0; i < 4; ++i)
{
if (priv->views[i] != NULL)
{
g_object_bind_property (GCAL_WINDOW (object), "active-date",
priv->views[i], "active-date",
G_BINDING_DEFAULT |
G_BINDING_SYNC_CREATE);
g_signal_connect (priv->views[i], "create-event",
G_CALLBACK (show_new_event_widget), object);
g_signal_connect (priv->views[i], "event-activated",
G_CALLBACK (event_activated), object);
}
}
}
static void
gcal_window_finalize (GObject *object)
{
GcalWindowPrivate *priv;
priv = gcal_window_get_instance_private (GCAL_WINDOW (object));
if (priv->active_date != NULL)
g_free (priv->active_date);
if (priv->views_switcher != NULL)
g_object_unref (priv->views_switcher);
if (priv->views[GCAL_WINDOW_VIEW_SEARCH] != NULL)
g_object_unref (priv->views[GCAL_WINDOW_VIEW_SEARCH]);
G_OBJECT_CLASS (gcal_window_parent_class)->finalize (object);
}
static void
gcal_window_set_property (GObject *object,
guint property_id,
const GValue *value,
GParamSpec *pspec)
{
GcalWindowPrivate *priv;
priv = gcal_window_get_instance_private (GCAL_WINDOW (object));
switch (property_id)
{
case PROP_ACTIVE_VIEW:
priv->active_view = g_value_get_enum (value);
gtk_widget_show (priv->views[priv->active_view]);
gtk_stack_set_visible_child (GTK_STACK (priv->views_stack),
priv->views[priv->active_view]);
update_view (GCAL_WINDOW (object));
return;
case PROP_ACTIVE_DATE:
if (priv->active_date != NULL)
g_free (priv->active_date);
priv->active_date = g_value_dup_boxed (value);
return;
case PROP_NEW_EVENT_MODE:
set_new_event_mode (GCAL_WINDOW (object), g_value_get_boolean (value));
return;
case PROP_MANAGER:
priv->manager = g_value_get_pointer (value);
return;
}
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
static void
gcal_window_get_property (GObject *object,
guint property_id,
GValue *value,
GParamSpec *pspec)
{
GcalWindowPrivate *priv;
priv = gcal_window_get_instance_private (GCAL_WINDOW (object));
switch (property_id)
{
case PROP_ACTIVE_VIEW:
g_value_set_enum (value, priv->active_view);
return;
case PROP_ACTIVE_DATE:
g_value_set_boxed (value, priv->active_date);
return;
case PROP_NEW_EVENT_MODE:
g_value_set_boolean (value, priv->new_event_mode);
return;
}
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);
}
static gboolean
gcal_window_configure_event (GtkWidget *widget,
GdkEventConfigure *event)
{
GcalWindow *window;
GcalWindowPrivate *priv;
gboolean retval;
window = GCAL_WINDOW (widget);
priv = gcal_window_get_instance_private (window);
if (priv->save_geometry_timeout_id != 0)
{
g_source_remove (priv->save_geometry_timeout_id);
priv->save_geometry_timeout_id = 0;
}
priv->save_geometry_timeout_id = g_timeout_add (SAVE_GEOMETRY_ID_TIMEOUT,
save_geometry,
window);
retval = GTK_WIDGET_CLASS (gcal_window_parent_class)->configure_event (widget, event);
return retval;
}
static gboolean
gcal_window_state_event (GtkWidget *widget,
GdkEventWindowState *event)
{
GcalWindow *window;
GcalWindowPrivate *priv;
gboolean retval;
window = GCAL_WINDOW (widget);
priv = gcal_window_get_instance_private (window);
if (priv->save_geometry_timeout_id != 0)
{
g_source_remove (priv->save_geometry_timeout_id);
priv->save_geometry_timeout_id = 0;
}
priv->save_geometry_timeout_id = g_timeout_add (SAVE_GEOMETRY_ID_TIMEOUT,
save_geometry,
window);
retval = GTK_WIDGET_CLASS (gcal_window_parent_class)->window_state_event (widget, event);
return retval;
}
/* Public API */
GtkWidget*
gcal_window_new_with_view_and_date (GcalApplication *app,
GcalWindowViewType view_type,
icaltimetype *date)
{
GcalWindow *win;
GcalManager *manager;
manager = gcal_application_get_manager (GCAL_APPLICATION (app));
win = g_object_new (GCAL_TYPE_WINDOW, "application", GTK_APPLICATION (app), "active-date", date, "manager", manager,
NULL);
/* loading size */
load_geometry (win);
if (view_type == GCAL_WINDOW_VIEW_DAY)
view_changed (NULL, NULL, win);
return GTK_WIDGET (win);
}
/* new-event interaction: first variant */
void
gcal_window_new_event (GcalWindow *window)
{
GcalWindowPrivate *priv;
gint x, y;
priv = gcal_window_get_instance_private (window);
/* 1st and 2nd steps */
set_new_event_mode (window, TRUE);
gcal_view_mark_current_unit (GCAL_VIEW (priv->views[priv->active_view]),
&x, &y);
if (priv->event_creation_data != NULL)
{
g_free (priv->event_creation_data->start_date);
g_free (priv->event_creation_data->end_date);
g_free (priv->event_creation_data);
}
priv->event_creation_data = g_new0 (NewEventData, 1);
priv->event_creation_data->x = x;
priv->event_creation_data->y = y;
priv->event_creation_data->start_date = gcal_dup_icaltime (priv->active_date);
priv->event_creation_data->end_date = gcal_dup_icaltime (priv->active_date);
/* adjusting dates according to the actual view */
switch (priv->active_view)
{
case GCAL_WINDOW_VIEW_DAY:
case GCAL_WINDOW_VIEW_WEEK:
priv->event_creation_data->end_date->hour += 1;
*(priv->event_creation_data->end_date) =
icaltime_normalize (*(priv->event_creation_data->end_date));
break;
case GCAL_WINDOW_VIEW_YEAR:
priv->event_creation_data->start_date->day = 1;
priv->event_creation_data->end_date->day =
icaltime_days_in_month (priv->event_creation_data->end_date->month,
priv->event_creation_data->end_date->year);
break;
case GCAL_WINDOW_VIEW_MONTH:
priv->event_creation_data->start_date->is_date = 1;
priv->event_creation_data->end_date->is_date = 1;
break;
case GCAL_WINDOW_VIEW_LIST:
case GCAL_WINDOW_VIEW_SEARCH:
break;
}
prepare_new_event_widget (GCAL_WINDOW (window));
place_new_event_widget (GCAL_WINDOW (window), x, y);
}
void
gcal_window_set_search_mode (GcalWindow *window,
gboolean enabled)
{
GcalWindowPrivate *priv;
priv = gcal_window_get_instance_private (window);
priv->search_mode = enabled;
gtk_search_bar_set_search_mode (GTK_SEARCH_BAR (priv->search_bar),
enabled);
}
Reference in New Issue View Git Blame Copy Permalink