plugins/cvs-plugin/cvs-callbacks.c

   1 /*
   2  * cvs-callbacks.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 "cvs-callbacks.h"
  19 #include "cvs-execute.h"
  20 #include "cvs-interface.h"
  21 #include "glade/glade.h"
  22 #include <libgnomevfs/gnome-vfs.h>
  23
  24 static gchar* get_log_from_textview(GtkWidget* textview)
  25 {
  26         gchar* log;
  27         GtkTextBuffer* textbuf;
  28         GtkTextIter iterbegin, iterend;
  29         gchar* escaped_log;
  30
  31         textbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
  32         gtk_text_buffer_get_start_iter(textbuf, &iterbegin);
  33         gtk_text_buffer_get_end_iter(textbuf, &iterend) ;
  34         log = gtk_text_buffer_get_text(textbuf, &iterbegin, &iterend, FALSE);
  35 /* #warning FIXME: Check for escape chars in log */
  36         /* Fixed. -naba*/
  37         escaped_log = anjuta_util_escape_quotes (log);
  38         return escaped_log;
  39 }
  40
  41
  42 static gboolean check_filename(GtkDialog* dialog, const gchar* filename)
  43 {
  44         if (!strlen(filename))
  45         {
  46                 GtkWidget* dlg = gtk_message_dialog_new(GTK_WINDOW(dialog),
  47                         GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO,
  48                         GTK_BUTTONS_CLOSE, _("Please enter a filename!"));
  49                 gtk_dialog_run(GTK_DIALOG(dlg));
  50                 gtk_widget_destroy(dlg);
  51                 return FALSE;
  52         }
  53         return TRUE;
  54 }
  55
  56 static gboolean check_entry(GtkDialog* dialog, GtkWidget* entry,
  57         const gchar* stringname)
  58 {
  59         if (!strlen(gtk_entry_get_text(GTK_ENTRY(entry))))
  60         {
  61                 gchar* message = g_strdup_printf(_("Please fill field: %s"), stringname);
  62                 GtkWidget* dlg = gtk_message_dialog_new(GTK_WINDOW(dialog),
  63                         GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO,
  64                         GTK_BUTTONS_CLOSE, message);
  65                 gtk_dialog_run(GTK_DIALOG(dlg));
  66                 gtk_widget_destroy(dlg);
  67                 return FALSE;
  68         }
  69         return TRUE;
  70         return FALSE;
  71 }
  72
  73 static gboolean
  74 is_busy (CVSPlugin* plugin, GtkDialog* dialog)
  75 {
  76         if (plugin->executing_command)
  77         {
  78                 GtkWidget* dlg = gtk_message_dialog_new(GTK_WINDOW(dialog),
  79                         GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO,
  80                         GTK_BUTTONS_CLOSE,
  81                         _("CVS command is running! Please wait until it is finished!"));
  82                 gtk_dialog_run(GTK_DIALOG(dlg));
  83                 gtk_widget_destroy(dlg);
  84                 return TRUE;
  85         }
  86         return FALSE;
  87 }
  88
  89 CVSData* cvs_data_new(CVSPlugin* plugin, GladeXML* gxml)
  90 {
  91         CVSData* data = g_new0(CVSData, 1);
  92         data->plugin = plugin;
  93         data->gxml = gxml;
  94
  95         return data;
  96 }
  97
  98 void cvs_data_free(CVSData* data)
  99 {
 100         g_free(data);
 101 }
 102
 103 void
 104 on_cvs_add_response(GtkDialog* dialog, gint response, CVSData* data)
 105 {
 106         if (is_busy(data->plugin, dialog))
 107                 return;
 108
 109         switch (response)
 110         {
 111         case GTK_RESPONSE_OK:
 112         {
 113                 GtkWidget* binary = glade_xml_get_widget(data->gxml, "cvs_binary");
 114                 GtkWidget* fileentry = glade_xml_get_widget(data->gxml, "cvs_filename");
 115
 116                 const gchar* filename = gtk_entry_get_text(GTK_ENTRY(fileentry));
 117                 if (!check_filename(dialog, filename))
 118                         break;
 119
 120                 anjuta_cvs_add(ANJUTA_PLUGIN(data->plugin), filename,
 121                         gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(binary)), NULL);
 122
 123                 gtk_widget_destroy(GTK_WIDGET(dialog));
 124                 cvs_data_free(data);
 125                 break;
 126         }
 127         default:
 128                 gtk_widget_destroy (GTK_WIDGET(dialog));
 129                 cvs_data_free(data);
 130         }
 131 }
 132
 133 void
 134 on_cvs_remove_response(GtkDialog* dialog, gint response, CVSData* data)
 135 {
 136         if (is_busy(data->plugin, dialog))
 137                 return;
 138
 139         switch (response)
 140         {
 141         case GTK_RESPONSE_OK:
 142         {
 143                 GtkWidget* fileentry = glade_xml_get_widget(data->gxml, "cvs_filename");
 144                 const gchar* filename = gtk_entry_get_text(GTK_ENTRY(fileentry));
 145
 146                 if (!check_filename(dialog, filename))
 147                         break;
 148
 149                 if (gnome_vfs_unlink(gtk_entry_get_text(GTK_ENTRY(fileentry)))
 150                         != GNOME_VFS_OK)
 151                 {
 152                         anjuta_util_dialog_error
 153                                 (GTK_WINDOW(dialog),_("Unable to delete file"), NULL);
 154                         gtk_widget_destroy(GTK_WIDGET(dialog));
 155                         cvs_data_free(data);
 156                         break;
 157                 }
 158
 159                 anjuta_cvs_remove(ANJUTA_PLUGIN(data->plugin), filename, NULL);
 160                 gtk_widget_destroy (GTK_WIDGET(dialog));
 161                 cvs_data_free(data);
 162                 break;
 163                 }
 164         default:
 165                 cvs_data_free(data);
 166                 gtk_widget_destroy (GTK_WIDGET(dialog));
 167         }
 168 }
 169
 170 void
 171 on_cvs_update_response(GtkDialog* dialog, gint response, CVSData* data)
 172 {
 173         if (is_busy(data->plugin, dialog))
 174                 return;
 175
 176         switch (response)
 177         {
 178         case GTK_RESPONSE_OK:
 179         {
 180                 const gchar* revision;
 181
 182                 GtkWidget* createdir;
 183                 GtkWidget* removedir;
 184                 GtkWidget* norecurse;
 185                 GtkWidget* removesticky;
 186                 GtkWidget* revisionentry;
 187                 GtkWidget* fileentry = glade_xml_get_widget(data->gxml, "cvs_filename");
 188                 const gchar* filename = g_strdup(gtk_entry_get_text(GTK_ENTRY(fileentry)));
 189
 190                 norecurse = glade_xml_get_widget(data->gxml, "cvs_norecurse");
 191                 removedir = glade_xml_get_widget(data->gxml, "cvs_removedir");
 192                 createdir = glade_xml_get_widget(data->gxml, "cvs_createdir");
 193                 revisionentry = glade_xml_get_widget(data->gxml, "cvs_revision");
 194                 revision = gtk_entry_get_text(GTK_ENTRY(revisionentry));
 195                 removesticky = glade_xml_get_widget(data->gxml, "cvs_removesticky");
 196
 197                 if (!check_filename(dialog, filename))
 198                         break;
 199
 200                 anjuta_cvs_update(ANJUTA_PLUGIN(data->plugin), filename,
 201                         !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(norecurse)),
 202                         gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(removedir)),
 203                         gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(createdir)),
 204                         gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(removesticky)),
 205                         revision, NULL);
 206
 207                 cvs_data_free(data);
 208                 gtk_widget_destroy(GTK_WIDGET(dialog));
 209                 break;
 210                 }
 211         default:
 212                 gtk_widget_destroy(GTK_WIDGET(dialog));
 213                 cvs_data_free(data);
 214                 break;
 215         }
 216 }
 217
 218 void
 219 on_cvs_commit_response(GtkDialog* dialog, gint response, CVSData* data)
 220 {
 221         if (is_busy(data->plugin, dialog))
 222                 return;
 223
 224         switch (response)
 225         {
 226         case GTK_RESPONSE_OK:
 227         {
 228                 gchar* log;
 229                 const gchar* rev;
 230                 GtkWidget* logtext;
 231                 GtkWidget* revisionentry;
 232                 GtkWidget* norecurse;
 233                 GtkWidget* fileentry = glade_xml_get_widget(data->gxml, "cvs_filename");
 234                 const gchar* filename = gtk_entry_get_text(GTK_ENTRY(fileentry));
 235
 236                 logtext = glade_xml_get_widget(data->gxml, "cvs_log");
 237                 log = get_log_from_textview(logtext);
 238                 if (!g_utf8_strlen(log, -1))
 239                 {
 240                         gint result;
 241                         GtkWidget* dlg = gtk_message_dialog_new(GTK_WINDOW(dialog),
 242                                 GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO,
 243                                 GTK_BUTTONS_YES_NO,
 244                                 _("Are you sure that you do not want a log message?"));
 245                         result = gtk_dialog_run(GTK_DIALOG(dlg));
 246                         if (result == GTK_RESPONSE_NO)
 247                         {
 248                                 gtk_widget_hide(dlg);
 249                                 gtk_widget_destroy(dlg);
 250                                 break;
 251                         }
 252                         gtk_widget_destroy(dlg);
 253                 }
 254
 255                 revisionentry = glade_xml_get_widget(data->gxml, "cvs_revision");
 256                 rev = gtk_entry_get_text(GTK_ENTRY(revisionentry));
 257
 258                 norecurse = glade_xml_get_widget(data->gxml, "cvs_norecurse");
 259
 260                 if (!check_filename(dialog, filename))
 261                         break;
 262
 263                 anjuta_cvs_commit(ANJUTA_PLUGIN(data->plugin), filename, log, rev,
 264                         !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(norecurse)), NULL);
 265
 266                 cvs_data_free(data);
 267                 gtk_widget_destroy(GTK_WIDGET(dialog));
 268                 break;
 269                 }
 270         default:
 271                 gtk_widget_destroy (GTK_WIDGET(dialog));
 272                 cvs_data_free(data);
 273                 break;
 274         }
 275 }
 276
 277 void
 278 on_cvs_diff_response(GtkDialog* dialog, gint response, CVSData* data)
 279 {
 280         if (is_busy(data->plugin, dialog))
 281                 return;
 282
 283         switch (response)
 284         {
 285         case GTK_RESPONSE_OK:
 286         {
 287                 const gchar* rev;
 288                 int diff_type_nr;
 289                 gboolean unified = FALSE;
 290                 gboolean patch_style = FALSE;
 291
 292                 GtkWidget* norecurse;
 293                 GtkWidget* revisionentry;
 294                 GtkWidget* diff_type;
 295                 GtkWidget* unified_diff;
 296
 297                 GtkWidget* fileentry = glade_xml_get_widget(data->gxml, "cvs_filename");
 298                 const gchar* filename = g_strdup(gtk_entry_get_text(GTK_ENTRY(fileentry)));
 299
 300
 301                 revisionentry = glade_xml_get_widget(data->gxml, "cvs_revision");
 302                 rev = gtk_entry_get_text(GTK_ENTRY(revisionentry));
 303                 norecurse = glade_xml_get_widget(data->gxml, "cvs_norecurse");
 304
 305                 diff_type = glade_xml_get_widget(data->gxml, "cvs_diff_type");
 306                 unified_diff = glade_xml_get_widget(data->gxml, "cvs_unified");
 307                 diff_type_nr = gtk_combo_box_get_active(GTK_COMBO_BOX(diff_type));
 308                 if (diff_type_nr == DIFF_PATCH)
 309                 {
 310                         unified = TRUE;
 311                         /* FIXME: rdiff do not take -u in my cvs */
 312                         /* diff = "rdiff"; */
 313                 }
 314
 315                 if (!check_filename(dialog, filename))
 316                         break;
 317
 318                 anjuta_cvs_diff(ANJUTA_PLUGIN(data->plugin), filename, rev,
 319                         !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(norecurse)), patch_style,
 320                         unified, NULL);
 321
 322                 cvs_data_free(data);
 323                 gtk_widget_destroy (GTK_WIDGET(dialog));
 324                 break;
 325                 }
 326         default:
 327                 cvs_data_free(data);
 328                 gtk_widget_destroy (GTK_WIDGET(dialog));
 329                 break;
 330         }
 331 }
 332
 333 void
 334 on_cvs_status_response(GtkDialog* dialog, gint response, CVSData* data)
 335 {
 336         if (is_busy(data->plugin, dialog))
 337                 return;
 338
 339         switch (response)
 340         {
 341         case GTK_RESPONSE_OK:
 342         {
 343                 GtkWidget* norecurse;
 344                 GtkWidget* verbose;
 345                 GtkWidget* fileentry = glade_xml_get_widget(data->gxml, "cvs_filename");
 346                 const gchar* filename = gtk_entry_get_text(GTK_ENTRY(fileentry));
 347
 348                 norecurse = glade_xml_get_widget(data->gxml, "cvs_norecurse");
 349                 verbose = glade_xml_get_widget(data->gxml, "cvs_verbose");
 350
 351
 352                 if (!check_filename(dialog, filename))
 353                         break;
 354
 355                 anjuta_cvs_status(ANJUTA_PLUGIN(data->plugin), filename,
 356                         !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(norecurse)),
 357                         gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(verbose)), NULL);
 358
 359                 cvs_data_free(data);
 360                 gtk_widget_destroy (GTK_WIDGET(dialog));
 361                 break;
 362                 }
 363         default:
 364                 cvs_data_free(data);
 365                 gtk_widget_destroy (GTK_WIDGET(dialog));
 366                 break;
 367         }
 368 }
 369
 370 void
 371 on_cvs_log_response(GtkDialog* dialog, gint response, CVSData* data)
 372 {
 373         if (is_busy(data->plugin, dialog))
 374                 return;
 375
 376         switch (response)
 377         {
 378         case GTK_RESPONSE_OK:
 379         {
 380                 const gchar* filename;
 381                 GtkWidget* norecurse;
 382                 GtkWidget* verbose;
 383                 GtkWidget* fileentry;
 384
 385                 norecurse = glade_xml_get_widget(data->gxml, "cvs_norecurse");
 386                 verbose = glade_xml_get_widget(data->gxml, "cvs_verbose");
 387
 388                 fileentry = glade_xml_get_widget(data->gxml, "cvs_filename");
 389                 filename = gtk_entry_get_text(GTK_ENTRY(fileentry));
 390                 if (!check_filename(dialog, filename))
 391                         break;
 392
 393                 anjuta_cvs_log(ANJUTA_PLUGIN(data->plugin), filename,
 394                         !gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(norecurse)),
 395                         gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(verbose)), NULL);
 396
 397
 398                 cvs_data_free(data);
 399                 gtk_widget_destroy (GTK_WIDGET(dialog));
 400                 break;
 401                 }
 402         default:
 403                 cvs_data_free(data);
 404                 gtk_widget_destroy (GTK_WIDGET(dialog));
 405                 break;
 406         }
 407 }
 408
 409 void
 410 on_cvs_import_response(GtkDialog* dialog, gint response, CVSData* data)
 411 {
 412         if (is_busy(data->plugin, dialog))
 413                 return;
 414
 415         switch (response)
 416         {
 417                 case GTK_RESPONSE_OK:
 418                 {
 419                         GtkWidget* username;
 420                         GtkWidget* password;
 421                         GtkWidget* cvsroot_entry;
 422                         GtkWidget* module_entry;
 423                         GtkWidget* vendortag;
 424                         GtkWidget* releasetag;
 425                         GtkWidget* logtext;
 426                         GtkWidget* typecombo;
 427                         GtkWidget* direntry;
 428                         gchar* log;
 429
 430                         username = glade_xml_get_widget(data->gxml, "cvs_username");
 431                         password = glade_xml_get_widget(data->gxml, "cvs_password");
 432
 433                         cvsroot_entry = glade_xml_get_widget(data->gxml, "cvs_cvsroot");
 434                         if (!check_entry(dialog, cvsroot_entry, _("CVSROOT")))
 435                                 break;
 436                         module_entry = glade_xml_get_widget(data->gxml, "cvs_module");
 437                         if (!check_entry(dialog, module_entry, _("Module")))
 438                                 break;
 439                         vendortag = glade_xml_get_widget(data->gxml, "cvs_vendor");
 440                         if (!check_entry(dialog, vendortag, _("Vendor")))
 441                                 break;
 442                         releasetag = glade_xml_get_widget(data->gxml, "cvs_release");
 443                         if (!check_entry(dialog, releasetag, _("Release")))
 444                                 break;
 445                         typecombo = glade_xml_get_widget(data->gxml, "cvs_server_type");
 446                         direntry = glade_xml_get_widget(data->gxml, "cvs_rootdir");
 447                         if (!check_entry(dialog, direntry, _("Directory")))
 448                                 break;
 449
 450                         logtext = glade_xml_get_widget(data->gxml, "cvs_log");
 451                         log = get_log_from_textview(logtext);
 452                         if (!strlen(log))
 453                         {
 454                                 gint result;
 455                                 GtkWidget* dlg = gtk_message_dialog_new(GTK_WINDOW(dialog),
 456                                 GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO,
 457                                 GTK_BUTTONS_YES_NO,
 458                                 _("Are you sure that you do not want a log message?"));
 459                                 result = gtk_dialog_run(GTK_DIALOG(dlg));
 460                                 gtk_widget_destroy(dlg);
 461                                 if (result == GTK_RESPONSE_NO)
 462                                         break;
 463                         }
 464
 465                         anjuta_cvs_import(ANJUTA_PLUGIN(data->plugin),
 466                                 gtk_entry_get_text(GTK_ENTRY(direntry)),
 467                                 gtk_entry_get_text(GTK_ENTRY(cvsroot_entry)),
 468                                 gtk_entry_get_text(GTK_ENTRY(module_entry)),
 469                                 gtk_entry_get_text(GTK_ENTRY(vendortag)),
 470                                 gtk_entry_get_text(GTK_ENTRY(releasetag)),
 471                                 log,
 472                                 gtk_combo_box_get_active(GTK_COMBO_BOX(typecombo)),
 473                                 gtk_entry_get_text(GTK_ENTRY(username)),
 474                                 gtk_entry_get_text(GTK_ENTRY(password)), NULL);
 475
 476                         cvs_data_free(data);
 477                         gtk_widget_destroy(GTK_WIDGET(dialog));
 478                         break;
 479                 }
 480                 default:
 481                         cvs_data_free(data);
 482                         gtk_widget_destroy(GTK_WIDGET(dialog));
 483                         break;
 484         }
 485 }