plugins/macro/macro-edit.c

   1 /*
   2  * macro_edit.c (c) 2005 Johannes Schmid
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  11  * GNU Library General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License
  14  * along with this program; if not, write to the Free Software
  15  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16  */
  17
  18 #include "macro-edit.h"
  19
  20 enum
  21 {
  22         OK,
  23         CANCEL
  24 };
  25
  26 static gboolean
  27 on_macro_edit_key_press_event(GtkWidget *widget, GdkEventKey *event,
  28                                gpointer user_data)
  29 {
  30         if (event->keyval == GDK_Escape)
  31         {
  32                 gtk_widget_hide (widget);
  33                 return TRUE;
  34         }
  35         return FALSE;
  36 }
  37
  38 static void
  39 fill_category_combo (MacroEdit * edit, GtkWidget * combo)
  40 {
  41         GtkTreeIter iter_user;
  42         GtkTreeIter iter_cat;
  43         GtkTreeModel *tree_model = macro_db_get_model (edit->macro_db);
  44
  45         if (gtk_tree_model_get_iter_first (tree_model, &iter_user))
  46         {
  47                 gtk_tree_model_iter_next (tree_model, &iter_user);
  48                 if (gtk_tree_model_iter_children
  49                     (tree_model, &iter_cat, &iter_user))
  50                 {
  51                         do
  52                         {
  53                                 gchar *name;
  54                                 gboolean is_category;
  55                                 gtk_tree_model_get (tree_model, &iter_cat,
  56                                                     MACRO_NAME, &name,
  57                                                     MACRO_IS_CATEGORY,
  58                                                     &is_category, -1);
  59                                 if (is_category && name)
  60                                 {
  61                                         gtk_combo_box_append_text
  62                                                 (GTK_COMBO_BOX
  63                                                  (edit->category_entry),
  64                                                  name);
  65                                 }
  66                         }
  67                         while (gtk_tree_model_iter_next
  68                                (tree_model, &iter_cat));
  69                 }
  70         }
  71 }
  72
  73 static void
  74 on_add_ok_clicked (MacroEdit * edit)
  75 {
  76         GtkTextIter begin, end;
  77         GtkTextBuffer *buffer =
  78                 gtk_text_view_get_buffer (GTK_TEXT_VIEW (edit->text));
  79         gchar *text;
  80
  81         g_return_if_fail (edit != NULL);
  82         gtk_text_buffer_get_start_iter (buffer, &begin);
  83         gtk_text_buffer_get_end_iter (buffer, &end);
  84         text = gtk_text_buffer_get_text (buffer, &begin, &end, -1);
  85
  86         macro_db_add (edit->macro_db,
  87                       gtk_entry_get_text (GTK_ENTRY (edit->name_entry)),
  88                       gtk_entry_get_text (GTK_ENTRY
  89                                           (GTK_BIN (edit->category_entry)->
  90                                            child)),
  91                       gtk_entry_get_text (GTK_ENTRY (edit->shortcut_entry)),
  92                       text);
  93         gtk_widget_destroy (GTK_WIDGET (edit));
  94 }
  95
  96 static void
  97 on_add_cancel_clicked (MacroEdit * edit)
  98 {
  99         gtk_widget_hide (GTK_WIDGET (edit));
 100         gtk_widget_destroy (GTK_WIDGET (edit));
 101 }
 102
 103 static void
 104 on_edit_ok_clicked (MacroEdit * edit)
 105 {
 106         GtkTextIter begin, end;
 107         GtkTreeIter iter;
 108         GtkTreeModel *model;
 109         GtkTextBuffer *buffer =
 110                 gtk_text_view_get_buffer (GTK_TEXT_VIEW (edit->text));
 111         gchar *text;
 112
 113         g_return_if_fail (edit != NULL);
 114         gtk_tree_selection_get_selected (edit->select, &model, &iter);
 115         gtk_text_buffer_get_start_iter (buffer, &begin);
 116         gtk_text_buffer_get_end_iter (buffer, &end);
 117         text = gtk_text_buffer_get_text (buffer, &begin, &end, -1);
 118
 119         macro_db_change (edit->macro_db, &iter,
 120                          gtk_entry_get_text (GTK_ENTRY (edit->name_entry)),
 121                          gtk_entry_get_text (GTK_ENTRY
 122                                              (GTK_BIN (edit->category_entry)->
 123                                               child)),
 124                          gtk_entry_get_text (GTK_ENTRY
 125                                              (edit->shortcut_entry)), text);
 126         gtk_widget_destroy (GTK_WIDGET (edit));
 127 }
 128
 129 static void
 130 on_edit_cancel_clicked (MacroEdit * edit)
 131 {
 132         on_add_cancel_clicked (edit);
 133 }
 134
 135 static void
 136 on_dialog_response (GtkWidget * dialog, gint response, MacroEdit * edit)
 137 {
 138         if (edit->type == MACRO_EDIT)
 139         {
 140                 switch (response)
 141                 {
 142                 case OK:
 143                         on_edit_ok_clicked (edit);
 144                         break;
 145                 case CANCEL:
 146                         on_edit_cancel_clicked (edit);
 147                         break;
 148                 }
 149         }
 150         else if (edit->type == MACRO_ADD)
 151         {
 152                 switch (response)
 153                 {
 154                 case OK:
 155                         on_add_ok_clicked (edit);
 156                         break;
 157                 case CANCEL:
 158                         on_add_cancel_clicked (edit);
 159                         break;
 160                 }
 161         }
 162 }
 163
 164 static gpointer parent_class;
 165
 166 static void
 167 macro_edit_dispose (GObject * edit)
 168 {
 169         //MacroEdit *medit = MACRO_EDIT (edit);
 170         //g_object_unref(medit->gxml);
 171         G_OBJECT_CLASS (parent_class)->dispose (edit);
 172 }
 173
 174 static void
 175 macro_edit_finalize (GObject * edit)
 176 {
 177         //MacroEdit *medit = MACRO_EDIT (edit);
 178         //g_object_unref(medit->gxml);
 179         G_OBJECT_CLASS (parent_class)->finalize (edit);
 180 }
 181
 182 static void
 183 macro_edit_class_init (MacroEditClass * klass)
 184 {
 185         GObjectClass *object_class = G_OBJECT_CLASS (klass);
 186         parent_class = g_type_class_peek_parent (klass);
 187         object_class->dispose = macro_edit_dispose;
 188         object_class->finalize = macro_edit_finalize;
 189 }
 190
 191 static void
 192 macro_edit_init (MacroEdit * edit)
 193 {
 194         GtkWidget *table;
 195
 196         edit->gxml = glade_xml_new (GLADE_FILE, "macro_edit_table", NULL);
 197
 198         table = glade_xml_get_widget (edit->gxml, "macro_edit_table");
 199         gtk_container_add (GTK_CONTAINER (GTK_DIALOG (edit)->vbox), table);
 200         gtk_dialog_add_buttons (GTK_DIALOG (edit), GTK_STOCK_OK, OK,
 201                                 GTK_STOCK_CANCEL, CANCEL, NULL);
 202         g_signal_connect (G_OBJECT (edit), "response",
 203                           G_CALLBACK (on_dialog_response), edit);
 204         gtk_window_set_title (GTK_WINDOW (edit), _("Add/Edit macro"));
 205
 206         edit->name_entry = glade_xml_get_widget (edit->gxml, "macro_name");
 207         edit->category_entry = gtk_combo_box_entry_new_text ();
 208         gtk_widget_show (edit->category_entry);
 209         gtk_table_attach_defaults (GTK_TABLE (table),
 210                                    edit->category_entry, 1, 2, 2, 3);
 211         edit->shortcut_entry =
 212                 glade_xml_get_widget (edit->gxml, "macro_shortcut");
 213         edit->text = glade_xml_get_widget (edit->gxml, "macro_text");
 214
 215 }
 216
 217 GType
 218 macro_edit_get_type (void)
 219 {
 220         static GType macro_edit_type = 0;
 221         if (!macro_edit_type)
 222         {
 223                 static const GTypeInfo me_info = {
 224                         sizeof (MacroEditClass),
 225                         NULL,   /* base_init */
 226                         NULL,   /* base_finalize */
 227                         (GClassInitFunc) macro_edit_class_init,
 228                         NULL,   /* class_finalize */
 229                         NULL,   /* class_data */
 230                         sizeof (MacroEdit),
 231                         0,
 232                         (GInstanceInitFunc) macro_edit_init,
 233                 };
 234                 macro_edit_type =
 235                         g_type_register_static (GTK_TYPE_DIALOG, "MacroEdit",
 236                                                 &me_info, 0);
 237         }
 238         return macro_edit_type;
 239 }
 240
 241 GtkWidget *
 242 macro_edit_new (int type, MacroDB * db)
 243 {
 244         MacroEdit *edit =
 245                 MACRO_EDIT (g_object_new (macro_edit_get_type (), NULL));
 246         edit->type = type;
 247         edit->macro_db = db;
 248         fill_category_combo (edit, edit->category_entry);
 249
 250         g_signal_connect(G_OBJECT(edit), "key-press-event",
 251                         G_CALLBACK(on_macro_edit_key_press_event), NULL);
 252
 253         return GTK_WIDGET (edit);
 254 }
 255
 256 void
 257 macro_edit_fill (MacroEdit * edit, GtkTreeSelection * select)
 258 {
 259         GtkTreeIter iter;
 260         GtkTreeModel *model;
 261
 262         if (gtk_tree_selection_get_selected (select, &model, &iter))
 263         {
 264                 gchar *name;
 265                 gchar *category;
 266                 gchar shortcut;
 267                 gchar *text;
 268                 gboolean is_category;
 269                 gboolean predefined;
 270
 271
 272
 273                 gtk_tree_model_get (model, &iter,
 274                                     MACRO_NAME, &name,
 275                                     MACRO_CATEGORY, &category,
 276                                     MACRO_SHORTCUT, &shortcut,
 277                                     MACRO_TEXT, &text,
 278                                     MACRO_IS_CATEGORY, &is_category,
 279                                     MACRO_PREDEFINED, &predefined, -1);
 280                 if (!is_category && !predefined)
 281                 {
 282                         GtkTextBuffer *text_buffer;
 283                         gchar *shortcut_string =
 284                                 g_strdup_printf ("%c", shortcut);
 285                         gtk_entry_set_text (GTK_ENTRY (edit->name_entry),
 286                                             name);
 287                         gtk_entry_set_text (GTK_ENTRY
 288                                             (GTK_BIN (edit->category_entry)->
 289                                              child), category);
 290                         gtk_entry_set_text (GTK_ENTRY (edit->shortcut_entry),
 291                                             shortcut_string);
 292                         g_free (shortcut_string);
 293
 294                         text_buffer =
 295                                 gtk_text_view_get_buffer (GTK_TEXT_VIEW
 296                                                           (edit->text));
 297                         gtk_text_buffer_set_text (text_buffer, text, -1);
 298                 }
 299         }
 300         edit->select = select;
 301 }
 302
 303 void macro_edit_set_macro (MacroEdit* edit, const gchar* macro)
 304 {
 305         GtkTextBuffer* buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(edit->text));
 306         gtk_text_buffer_set_text(buffer, macro, strlen(macro));
 307 }