aboutsummaryrefslogblamecommitdiffstats
path: root/calendar/gui/memos-control.c
blob: 46719a55fe7f95cd4d2969f3abb4e16004b997ce (plain) (tree)
1
2
3
4
5
6
7
8
9
10
  

                                                                


                                                               



                                                                    


                                                                   
                                                                             
  
  

                                                
                            



                                                        





                    
                    
                       


                                  
                                  
                           
                                  
                            





                            
                                         









                                                                                    
                                                                               

                                                                              
                                                                               










                                                                               
                                                                               

                                                                              
                                                                               

                                                                              
                                                                               
 



                               
 
                                                                                                                          




                               

                                           














                                                                                              








                                                                                                                              






















                                                                           
                                                                                         

                               
                                                  

                         
                           

                                                        
                                       



                                                                        


                                                                                                                     








                                                                                  
                                                                                                 




                                                                               
                                                                              







                                                                                
                                                                    







                                                                      









                                                                                                                                                                           












                                                                              
                             











                                                                                               



                    




                                                              
                        

                              
                       

                                                        
                                       










                                                                            


                                                          
                                           
                                       

                                                 
                         
 

                                        




















                                                                                                  
                                       








                                                                                                     
                                                        



                                                                              
                                                                              









                                                                      
                                                                      









                                                                      
                                                                       











                                                                      
                                                                       


                              
                           

                               








                                                                                                                     




                                                                      
                                                                       











                                                                      
                                                                      






                                        



                                                
                                           
 

                                       
 

                                                                   
 


                                                         




                                                        
                                                   
 

                                       
 

                                                                   
 


                                                    
 
/*
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) version 3.
 *
 * This program 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with the program; if not, see <http://www.gnu.org/licenses/>
 *
 *
 * Authors:
 *      Damon Chaplin <damon@ximian.com>
 *      Ettore Perazzoli
 *      Nathan Owens <pianocomp81@yahoo.com>
 *
 * Copyright (C) 1999-2008 Novell, Inc. (www.novell.com)
 *
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <gtk/gtk.h>
#include <glib/gi18n.h>
#include <bonobo/bonobo-control.h>
#include <bonobo/bonobo-ui-util.h>
#include <e-util/e-dialog-utils.h>
#include <e-util/e-icon-factory.h>
#include <e-util/e-print.h>
#include <e-util/e-util-private.h>
#include <gtkhtml/gtkhtml.h>

#include "calendar-config.h"
#include "e-memos.h"
#include "e-memo-table.h"
#include "print.h"
#include "memos-control.h"
#include "e-cal-component-memo-preview.h"
#include "evolution-shell-component-utils.h"

#define FIXED_MARGIN                            .05


static void memos_control_activate_cb       (BonoboControl      *control,
                         gboolean        activate,
                         gpointer        user_data);
static void memos_control_open_memo_cmd     (BonoboUIComponent  *uic,
                         gpointer        data,
                         const gchar        *path);
static void memos_control_new_memo_cmd      (BonoboUIComponent  *uic,
                         gpointer        data,
                         const gchar        *path);
static void memos_control_cut_cmd               (BonoboUIComponent      *uic,
                         gpointer                data,
                         const gchar            *path);
static void memos_control_copy_cmd              (BonoboUIComponent      *uic,
                         gpointer                data,
                         const gchar            *path);
static void memos_control_paste_cmd             (BonoboUIComponent      *uic,
                         gpointer                data,
                         const gchar            *path);
static void memos_control_delete_cmd        (BonoboUIComponent  *uic,
                         gpointer        data,
                         const gchar        *path);
static void memos_control_print_cmd     (BonoboUIComponent  *uic,
                         gpointer        data,
                         const gchar        *path);
static void memos_control_print_preview_cmd (BonoboUIComponent  *uic,
                         gpointer        data,
                         const gchar        *path);

struct focus_changed_data {
    BonoboControl *control;
    EMemos *memos;
};

static gboolean memos_control_focus_changed (GtkWidget *widget, GdkEventFocus *event, struct focus_changed_data *fc_data);

BonoboControl *
memos_control_new (void)
{
    BonoboControl *control;
    GtkWidget *memos, *preview;
    struct focus_changed_data *fc_data;

    memos = e_memos_new ();
    if (!memos)
        return NULL;
    gtk_widget_show (memos);

    control = bonobo_control_new (memos);
    if (!control) {
        gtk_widget_destroy (memos);
        g_message ("control_factory_fn(): could not create the control!");
        return NULL;
    }

    g_signal_connect (control, "activate", G_CALLBACK (memos_control_activate_cb), memos);

    fc_data = g_new0 (struct focus_changed_data, 1);
    fc_data->control = control;
    fc_data->memos = E_MEMOS (memos);

    preview = e_cal_component_memo_preview_get_html (E_CAL_COMPONENT_MEMO_PREVIEW (e_memos_get_preview (fc_data->memos)));
    g_object_set_data_full (G_OBJECT (preview), "memos-ctrl-fc-data", fc_data, g_free);
    g_signal_connect (preview, "focus-in-event", G_CALLBACK (memos_control_focus_changed), fc_data);
    g_signal_connect (preview, "focus-out-event", G_CALLBACK (memos_control_focus_changed), fc_data);

    return control;
}


static void
memos_control_activate_cb       (BonoboControl      *control,
                     gboolean        activate,
                     gpointer        user_data)
{
    EMemos *memos;

    memos = E_MEMOS (user_data);

    if (activate)
        memos_control_activate (control, memos);
    else
        memos_control_deactivate (control, memos);
}

/* Sensitizes the UI Component menu/toolbar commands based on the number of
 * selected memos.
 */
void
memos_control_sensitize_commands (BonoboControl *control, EMemos *memos, gint n_selected)
{
    BonoboUIComponent *uic;
    gboolean read_only = TRUE, preview_active;
    ECal *ecal;
    ECalModel *model;
    GtkWidget *preview;

    uic = bonobo_control_get_ui_component (control);
    g_return_if_fail (uic != NULL);

    if (bonobo_ui_component_get_container (uic) == CORBA_OBJECT_NIL)
        return;

    preview = e_cal_component_memo_preview_get_html (E_CAL_COMPONENT_MEMO_PREVIEW (e_memos_get_preview (memos)));
    preview_active = preview && GTK_WIDGET_VISIBLE (preview) && GTK_WIDGET_HAS_FOCUS (preview);

    model = e_memo_table_get_model (e_memos_get_calendar_table (memos));
    ecal = e_cal_model_get_default_client (model);
    if (ecal)
        e_cal_is_read_only (ecal, &read_only, NULL);

    bonobo_ui_component_set_prop (uic, "/commands/MemosOpenMemo", "sensitive",
                      n_selected != 1 ? "0" : "1",
                      NULL);
    bonobo_ui_component_set_prop (uic, "/commands/MemosCut", "sensitive",
                      n_selected == 0 || read_only || preview_active ? "0" : "1",
                      NULL);
    bonobo_ui_component_set_prop (uic, "/commands/MemosCopy", "sensitive",
                      n_selected == 0 ? "0" : "1",
                      NULL);
    bonobo_ui_component_set_prop (uic, "/commands/MemosPaste", "sensitive",
                      read_only || preview_active ? "0" : "1",
                      NULL);
    bonobo_ui_component_set_prop (uic, "/commands/MemosDelete", "sensitive",
                      n_selected == 0 || read_only ? "0" : "1",
                      NULL);
}

/* Callback used when the selection in the table changes */
static void
selection_changed_cb (EMemos *memos, gint n_selected, gpointer data)
{
    BonoboControl *control;

    control = BONOBO_CONTROL (data);

    memos_control_sensitize_commands (control, memos, n_selected);
}

static gboolean
memos_control_focus_changed (GtkWidget *widget, GdkEventFocus *event, struct focus_changed_data *fc_data)
{
    g_return_val_if_fail (fc_data != NULL, FALSE);

    memos_control_sensitize_commands (fc_data->control, fc_data->memos, e_table_selected_count (e_memo_table_get_table (e_memos_get_calendar_table (fc_data->memos))));

    return FALSE;
}

static BonoboUIVerb verbs [] = {
    BONOBO_UI_VERB ("MemosOpenMemo", memos_control_open_memo_cmd),
    BONOBO_UI_VERB ("MemosNewMemo", memos_control_new_memo_cmd),
    BONOBO_UI_VERB ("MemosCut", memos_control_cut_cmd),
    BONOBO_UI_VERB ("MemosCopy", memos_control_copy_cmd),
    BONOBO_UI_VERB ("MemosPaste", memos_control_paste_cmd),
    BONOBO_UI_VERB ("MemosDelete", memos_control_delete_cmd),
    BONOBO_UI_VERB ("MemosPrint", memos_control_print_cmd),
    BONOBO_UI_VERB ("MemosPrintPreview", memos_control_print_preview_cmd),

    BONOBO_UI_VERB_END
};

static EPixmap pixmaps [] = {
    E_PIXMAP ("/commands/MemosCopy", "edit-copy", GTK_ICON_SIZE_MENU),
    E_PIXMAP ("/commands/MemosCut", "edit-cut", GTK_ICON_SIZE_MENU),
    E_PIXMAP ("/commands/MemosDelete", "edit-delete", GTK_ICON_SIZE_MENU),
    E_PIXMAP ("/commands/MemosPaste", "edit-paste", GTK_ICON_SIZE_MENU),
    E_PIXMAP ("/commands/MemosPrint", "document-print", GTK_ICON_SIZE_MENU),
    E_PIXMAP ("/commands/MemosPrintPreview", "document-print-preview", GTK_ICON_SIZE_MENU),

    E_PIXMAP ("/Toolbar/Cut", "edit-cut", GTK_ICON_SIZE_LARGE_TOOLBAR),
    E_PIXMAP ("/Toolbar/Copy", "edit-copy", GTK_ICON_SIZE_LARGE_TOOLBAR),
    E_PIXMAP ("/Toolbar/Paste", "edit-paste", GTK_ICON_SIZE_LARGE_TOOLBAR),
    E_PIXMAP ("/Toolbar/Print", "document-print", GTK_ICON_SIZE_LARGE_TOOLBAR),
    E_PIXMAP ("/Toolbar/Delete", "edit-delete", GTK_ICON_SIZE_LARGE_TOOLBAR),

    E_PIXMAP_END
};

void
memos_control_activate (BonoboControl *control, EMemos *memos)
{
    Bonobo_UIContainer remote_uih;
    BonoboUIComponent *uic;
    gint n_selected;
    EMemoTable *cal_table;
    ETable *etable;
    gchar *xmlfile;

    uic = bonobo_control_get_ui_component (control);
    g_return_if_fail (uic != NULL);

    remote_uih = bonobo_control_get_remote_ui_container (control, NULL);
    bonobo_ui_component_set_container (uic, remote_uih, NULL);
    bonobo_object_release_unref (remote_uih, NULL);

    e_memos_set_ui_component (memos, uic);

    bonobo_ui_component_add_verb_list_with_data (uic, verbs, memos);

    bonobo_ui_component_freeze (uic, NULL);

    xmlfile = g_build_filename (EVOLUTION_UIDIR,
                    "evolution-memos.xml",
                    NULL);
    bonobo_ui_util_set_ui (uic, PREFIX,
                   xmlfile,
                   "evolution-memos",
                   NULL);
    g_free (xmlfile);

    e_pixmaps_update (uic, pixmaps);

    e_memos_setup_view_menus (memos, uic);

    /* Signals from the memos widget; also sensitize the menu items as appropriate */

    g_signal_connect (memos, "selection_changed", G_CALLBACK (selection_changed_cb), control);

    cal_table = e_memos_get_calendar_table (memos);
    etable = e_memo_table_get_table (cal_table);
    n_selected = e_table_selected_count (etable);

    memos_control_sensitize_commands (control, memos, n_selected);

    bonobo_ui_component_thaw (uic, NULL);
}


void
memos_control_deactivate (BonoboControl *control, EMemos *memos)
{
    BonoboUIComponent *uic = bonobo_control_get_ui_component (control);

    g_return_if_fail (uic != NULL);

    e_memos_set_ui_component (memos, NULL);

    e_memos_discard_view_menus (memos);

    /* Stop monitoring the "selection_changed" signal */
    g_signal_handlers_disconnect_matched (memos, G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, control);

    bonobo_ui_component_rm (uic, "/", NULL);
    bonobo_ui_component_unset_container (uic, NULL);
}

static void memos_control_open_memo_cmd     (BonoboUIComponent  *uic,
                         gpointer        data,
                         const gchar        *path)
{
    EMemos *memos;

    memos = E_MEMOS (data);
    e_memos_open_memo (memos);
}

static void
memos_control_new_memo_cmd      (BonoboUIComponent  *uic,
                     gpointer        data,
                     const gchar        *path)
{
    EMemos *memos;

    memos = E_MEMOS (data);
    e_memos_new_memo (memos);
}

static void
memos_control_cut_cmd                   (BonoboUIComponent      *uic,
                     gpointer                data,
                     const gchar             *path)
{
    EMemos *memos;
    EMemoTable *cal_table;

    memos = E_MEMOS (data);
    cal_table = e_memos_get_calendar_table (memos);
    e_memo_table_cut_clipboard (cal_table);
}

static void
memos_control_copy_cmd                  (BonoboUIComponent      *uic,
                     gpointer                data,
                     const gchar             *path)
{
    EMemos *memos;
    EMemoTable *cal_table;
    GtkWidget *preview;

    memos = E_MEMOS (data);

    preview = e_cal_component_memo_preview_get_html (E_CAL_COMPONENT_MEMO_PREVIEW (e_memos_get_preview (memos)));
    if (preview && GTK_WIDGET_VISIBLE (preview) && GTK_WIDGET_HAS_FOCUS (preview)) {
        /* copy selected text in a preview when that's shown and focused */
        gtk_html_copy (GTK_HTML (preview));
    } else {
        cal_table = e_memos_get_calendar_table (memos);
        e_memo_table_copy_clipboard (cal_table);
    }
}

static void
memos_control_paste_cmd                 (BonoboUIComponent      *uic,
                     gpointer                data,
                     const gchar             *path)
{
    EMemos *memos;
    EMemoTable *cal_table;

    memos = E_MEMOS (data);
    cal_table = e_memos_get_calendar_table (memos);
    e_memo_table_paste_clipboard (cal_table);
}

static void
memos_control_delete_cmd        (BonoboUIComponent  *uic,
                     gpointer        data,
                     const gchar        *path)
{
    EMemos *memos;

    memos = E_MEMOS (data);
    e_memos_delete_selected (memos);
}

/* File/Print callback */
static void
memos_control_print_cmd (BonoboUIComponent *uic,
             gpointer data,
             const gchar *path)
{
    EMemos *memos = E_MEMOS (data);
    ETable *table;

    table = e_memo_table_get_table (
        E_MEMO_TABLE (e_memos_get_calendar_table (memos)));

    print_table (
        table, _("Print Memos"), _("Memos"),
        GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG);
}

static void
memos_control_print_preview_cmd (BonoboUIComponent *uic,
                 gpointer data,
                 const gchar *path)
{
    EMemos *memos = E_MEMOS (data);
    ETable *table;

    table = e_memo_table_get_table (
        E_MEMO_TABLE (e_memos_get_calendar_table (memos)));

    print_table (
        table, _("Print Memos"), _("Memos"),
        GTK_PRINT_OPERATION_ACTION_PREVIEW);
}