?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Don't show diff of removed or added files
[geanyvc.git] / geanyvc.c
blob58a13e8587f66b9a947c053d643d07140606bfd7
1 /*
2 * geanyvc.c - Plugin to geany light IDE to work with vc
3 *
4 * Copyright 2007 Frank Lanitz <frank(at)frank(dot)uvena(dot)de>
5 * Copyright 2007 Enrico Tröger <enrico.troeger@uvena.de>
6 * Copyright 2007 Nick Treleaven <nick.treleaven@btinternet.com>
7 * Copyright 2007 Yura Siamashka <yurand2@gmail.com>
8 *
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License as published by
11 * the Free Software Foundation; either version 2 of the License, or
12 * (at your option) any later version.
13 *
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 * GNU General Public License for more details.
18 *
19 * You should have received a copy of the GNU General Public License
20 * along with this program; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
22 */
23
24 /* VC plugin */
25 /* This plugin allow to works with cvs/svn/git inside geany light IDE. */
26
27 #include "geany.h"
28 #include "support.h"
29 #include "plugindata.h"
30 #include "document.h"
31 #include "filetypes.h"
32 #include "utils.h"
33 #include "project.h"
34 #include "pluginmacros.h"
35
36 #include "geanyvc.h"
37
38 PluginFields *plugin_fields;
39 GeanyData *geany_data;
40
41
42 VERSION_CHECK(27);
43 PLUGIN_INFO(_("VC"), _("Interface to different Version Control systems."), VERSION,
44 _("Yura Siamashka <yurand2@gmail.com>,\nFrank Lanitz <frank@frank.uvena.de>"));
45
46 /* Some global variables */
47 static gboolean set_changed_flag;
48 static gboolean set_add_confirmation;
49 static gchar *config_file;
50
51 static gboolean enable_cvs;
52 static gboolean enable_git;
53 static gboolean enable_svn;
54 static gboolean enable_svk;
55
56 static GSList *VC = NULL;
57
58 /* The addresses of these strings act as enums, their contents are not used. */
59 const gchar DIRNAME[] = "*DIRNAME*";
60 const gchar FILENAME[] = "*FILENAME*";
61 const gchar BASE_FILENAME[] = "*BASE_FILENAME*";
62 const gchar FILE_LIST[] = "*FILE_LIST*";
63 const gchar MESSAGE[] = "*MESSAGE*";
64
65 /* this string is used when action require to run several commands */
66 const gchar CMD_SEPARATOR[] = "*CMD-SEPARATOR*";
67
68 /* commit status */
69 const gchar FILE_STATUS_MODIFIED[] = "Modified";
70 const gchar FILE_STATUS_ADDED[] = "Added";
71 const gchar FILE_STATUS_DELETED[] = "Deleted";
72 const gchar FILE_STATUS_UNKNOWN[] = "Unknown";
73
74 void *NO_ENV[] = { NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL };
75
76 static void registrate();
77
78 GSList *
79 get_commit_files_null(const gchar * dir)
80 {
81 return NULL;
82 }
83
84 static void
85 free_commit_list(GSList * lst)
86 {
87 GSList *tmp;
88 if (!lst)
89 return;
90 for (tmp = lst; tmp != NULL; tmp = g_slist_next(tmp))
91 {
92 g_free(((CommitItem *) (tmp->data))->path);
93 g_free((CommitItem *) (tmp->data));
94 }
95 g_slist_free(lst);
96 }
97
98 gchar *
99 find_subdir_path(const gchar * filename, const gchar * subdir)
100 {
101 gboolean ret = FALSE;
102 gchar *base;
103 gchar *gitdir;
104 gchar *base_prev = g_strdup(":");
105
106 if (g_file_test(filename, G_FILE_TEST_IS_DIR))
107 base = g_strdup(filename);
108 else
109 base = g_path_get_dirname(filename);
110
111 while (strcmp(base, base_prev) != 0)
112 {
113 gitdir = g_build_path("/", base, subdir, NULL);
114 ret = g_file_test(gitdir, G_FILE_TEST_IS_DIR);
115 g_free(gitdir);
116 if (ret)
117 break;
118 g_free(base_prev);
119 base_prev = base;
120 base = g_path_get_dirname(base);
121 }
122
123 g_free(base_prev);
124 if (ret)
125 return base;
126 g_free(base);
127 return NULL;
128 }
129
130 static gboolean
131 find_subdir(const gchar * filename, const gchar * subdir)
132 {
133 gchar *basedir;
134 basedir = find_subdir_path(filename, subdir);
135 if (basedir)
136 {
137 g_free(basedir);
138 return TRUE;
139 }
140 return FALSE;
141 }
142
143 gboolean
144 find_dir(const gchar * filename, const char *find, gboolean recursive)
145 {
146 gboolean ret;
147 gchar *base;
148 gchar *dir;
149 gchar *path;
150
151 if (!filename)
152 return FALSE;
153
154 if (recursive)
155 {
156 ret = find_subdir(filename, find);
157 }
158 else
159 {
160 if (g_file_test(filename, G_FILE_TEST_IS_DIR))
161 base = g_strdup(filename);
162 else
163 base = g_path_get_dirname(filename);
164 dir = g_build_path("/", base, find, NULL);
165
166 ret = g_file_test(dir, G_FILE_TEST_IS_DIR);
167
168 g_free(base);
169 g_free(dir);
170 }
171 return ret;
172 }
173
174
175 static const VC_RECORD *
176 find_vc(const char *filename)
177 {
178 GSList *tmp;
179
180 for (tmp = VC; tmp != NULL; tmp = g_slist_next(tmp))
181 {
182 if (((VC_RECORD *) tmp->data)->in_vc(filename))
183 {
184 return (VC_RECORD *) tmp->data;
185 }
186 }
187 return NULL;
188 }
189
190 static void *
191 find_cmd_env(gint cmd_type, gboolean cmd, const gchar * filename)
192 {
193 const VC_RECORD *vc;
194 vc = find_vc(filename);
195 if (vc)
196 {
197 if (cmd)
198 return vc->commands[cmd_type];
199 else
200 return vc->envs[cmd_type];
201 }
202 return NULL;
203 }
204
205 /* Get list of commands for given command spec*/
206 static GSList *
207 get_cmd(const gchar ** argv, const gchar * filename, GSList * filelist, const gchar * message)
208 {
209 gint i, j;
210 gint len = 0;
211 gchar **ret;
212 gchar *dir;
213 gchar *base_filename;
214 GSList *head = NULL;
215 GSList *tmp;
216
217 if (g_file_test(filename, G_FILE_TEST_IS_DIR))
218 {
219 dir = g_strdup(filename);
220 }
221 else
222 {
223 dir = g_path_get_dirname(filename);
224 }
225 base_filename = g_path_get_basename(filename);
226
227 while (1)
228 {
229 if (argv[len] == NULL)
230 break;
231 len++;
232 }
233 if (filelist)
234 ret = g_malloc0(sizeof(gchar *) * (len * g_slist_length(filelist) + 1));
235 else
236 ret = g_malloc0(sizeof(gchar *) * (len + 1));
237
238 head = g_slist_alloc();
239 head->data = ret;
240
241 for (i = 0, j = 0; i < len; i++, j++)
242 {
243 if (argv[i] == CMD_SEPARATOR)
244 {
245 if (filelist)
246 ret = g_malloc0(sizeof(gchar *) *
247 (len * g_slist_length(filelist) + 1));
248 else
249 ret = g_malloc0(sizeof(gchar *) * (len + 1));
250 j = -1;
251 head = g_slist_append(head, ret);
252 }
253 else if (argv[i] == DIRNAME)
254 {
255 ret[j] = g_strdup(dir);
256 }
257 else if (argv[i] == FILENAME)
258 {
259 ret[j] = g_strdup(filename);
260 }
261 else if (argv[i] == BASE_FILENAME)
262 {
263 ret[j] = g_strdup(base_filename);
264 }
265 else if (argv[i] == FILE_LIST)
266 {
267 for (tmp = filelist; tmp != NULL; tmp = g_slist_next(tmp))
268 {
269 ret[j] = g_strdup((gchar *) tmp->data);
270 j++;
271 }
272 j--;
273 }
274 else if (argv[i] == MESSAGE)
275 {
276 ret[j] = g_strdup(message);
277 }
278 else
279 ret[j] = g_strdup(argv[i]);
280 }
281 g_free(dir);
282 g_free(base_filename);
283 return head;
284 }
285
286 static GSList *
287 get_cmd_int(gint cmd_type, const gchar * filename, GSList * list, const gchar * message)
288 {
289 gint i, j;
290 gint len = 0;
291 const gchar **argv;
292 gchar **ret;
293 gchar *dir;
294 gchar *base_filename;
295 GSList *head = NULL;
296
297 argv = find_cmd_env(cmd_type, TRUE, filename);
298 if (!argv)
299 return NULL;
300
301 return get_cmd(argv, filename, list, message);
302 }
303
304
305 static int
306 find_by_filename(const gchar * filename)
307 {
308 guint i;
309
310 for (i = 0; i < doc_array->len; i++)
311 {
312 if (doc_list[i].is_valid && doc_list[i].file_name &&
313 strcmp(doc_list[i].file_name, filename) == 0)
314 return i;
315 }
316 return -1;
317 }
318
319
320 /* name_prefix should be in UTF-8, and can have a path. */
321 static void
322 show_output(const gchar * std_output, const gchar * name, const gchar * force_encoding)
323 {
324 gint idx, page;
325 GtkNotebook *book;
326
327 if (std_output)
328 {
329 idx = find_by_filename(name);
330 if (idx == -1)
331 {
332 idx = documents->new_file(name,
333 geany_data->filetypes[GEANY_FILETYPES_DIFF],
334 std_output);
335 }
336 else
337 {
338 scintilla->set_text(doc_list[idx].sci, std_output);
339 book = GTK_NOTEBOOK(app->notebook);
340 page = gtk_notebook_page_num(book, GTK_WIDGET(doc_list[idx].sci));
341 gtk_notebook_set_current_page(book, page);
342 }
343 doc_list[idx].changed = TRUE;
344 if (!set_changed_flag)
345 doc_list[idx].changed = FALSE;
346 documents->set_text_changed(idx);
347 documents->set_encoding(idx, (force_encoding ? force_encoding : "utf-8"));
348 }
349 else
350 {
351 ui->set_statusbar(FALSE, _("Could not parse the output of the diff"));
352 }
353 }
354
355 /*
356 * Execute command by command spec, return std_out std_err
357 *
358 * @argv - command spec
359 * @env - envirounment
360 * @std_out - if not NULL here will be returned standard output converted to utf8 of last command in spec
361 * @std_err - if not NULL here will be returned standard error converted to utf8 of last command in spec
362 * @filename - filename for spec, commands will be running in it's basedir . Used to replace FILENAME, BASE_FILENAME in spec
363 * @list - used to replace FILE_LIST in spec
364 * @message - used to replace MESSAGE in spec
365 *
366 * @return - exit code of last command in spec
367 */
368 gint
369 execute_custom_command(const gchar ** argv, const gchar ** env, gchar ** std_out, gchar ** std_err,
370 const gchar * filename, GSList * list, const gchar * message)
371 {
372 gint exit_code;
373 gchar *text = NULL;
374 gchar *dir;
375 GSList *cur;
376 GSList *largv = get_cmd(argv, filename, list, message);
377 GError *error = NULL;
378 gchar *detect_enc = NULL;
379 gchar *force_encoding = NULL;
380
381 if (std_out)
382 *std_out = NULL;
383 if (std_err)
384 *std_err = NULL;
385
386 if (!largv)
387 {
388 return 0;
389 }
390
391 if (g_file_test(filename, G_FILE_TEST_IS_DIR))
392 {
393 dir = g_strdup(filename);
394 }
395 else
396 {
397 dir = g_path_get_dirname(filename);
398 }
399
400 for (cur = largv; cur != NULL; cur = g_slist_next(cur))
401 {
402 argv = cur->data;
403 if (cur != g_slist_last(largv))
404 {
405 g_spawn_sync(dir, cur->data, (gchar **) env,
406 G_SPAWN_SEARCH_PATH | G_SPAWN_STDOUT_TO_DEV_NULL |
407 G_SPAWN_STDERR_TO_DEV_NULL, NULL, NULL, NULL, NULL, &exit_code,
408 &error);
409 }
410 else
411 {
412 g_spawn_sync(dir, cur->data, (gchar **) env,
413 G_SPAWN_SEARCH_PATH | (std_out ? 0 :
414 G_SPAWN_STDOUT_TO_DEV_NULL) | (std_err ?
415 0 :
416 G_SPAWN_STDERR_TO_DEV_NULL),
417 NULL, NULL, std_out, std_err, &exit_code, &error);
418 }
419 if (error)
420 {
421 fprintf(stderr, "s_spawn_sync error: %s", error->message);
422 g_error_free(error);
423 ui->set_statusbar(FALSE, _("Something went really wrong."));
424 }
425
426 // need to convert output text from the encoding of the original file into
427 // UTF-8 because internally Geany always needs UTF-8
428 if (std_out && *std_out)
429 {
430 if (force_encoding)
431 {
432 setptr(*std_out,
433 encodings->convert_to_utf8_from_charset(*std_out, -1,
434 force_encoding,
435 TRUE));
436 }
437 else
438 {
439 setptr(*std_out,
440 encodings->convert_to_utf8(*std_out, -1, &detect_enc));
441 }
442 if (detect_enc)
443 {
444 g_free(detect_enc);
445 detect_enc = NULL;
446 }
447 if (!NZV(*std_out))
448 {
449 g_free(*std_out);
450 *std_out = NULL;
451 }
452 }
453 if (std_err && *std_err)
454 {
455 if (force_encoding)
456 {
457 setptr(*std_err,
458 encodings->convert_to_utf8_from_charset(*std_err, -1,
459 force_encoding,
460 TRUE));
461 }
462 else
463 {
464 setptr(*std_err,
465 encodings->convert_to_utf8(*std_err, -1, &detect_enc));
466 }
467 if (detect_enc)
468 {
469 g_free(detect_enc);
470 detect_enc = NULL;
471 }
472 if (!NZV(*std_err))
473 {
474 g_free(*std_err);
475 *std_err = NULL;
476 }
477 }
478 g_strfreev(cur->data);
479 }
480 g_free(dir);
481 g_slist_free(largv);
482 return exit_code;
483 }
484
485 gint
486 execute_command(const VC_RECORD * vc, gchar ** std_out, gchar ** std_err, const gchar * filename,
487 gint cmd, GSList * list, const gchar * message)
488 {
489 return execute_custom_command(vc->commands[cmd], vc->envs[cmd], std_out, std_err, filename,
490 list, message);
491 }
492
493 /* Callback if menu item for a single file was activated */
494 static void
495 vcfile_activated(GtkMenuItem * menuitem, gpointer gdata)
496 {
497 gint idx;
498 gchar *locale_filename, *text = NULL;
499 gchar *name;
500 const VC_RECORD *vc;
501
502 idx = documents->get_cur_idx();
503
504 g_return_if_fail(DOC_IDX_VALID(idx) && doc_list[idx].file_name != NULL);
505
506 if (doc_list[idx].changed)
507 {
508 documents->save_file(idx, FALSE);
509 }
510
511 locale_filename = utils->get_locale_from_utf8(doc_list[idx].file_name);
512
513 vc = find_vc(doc_list[idx].file_name);
514 g_return_if_fail(vc);
515
516 execute_command(vc, &text, NULL, locale_filename, VC_COMMAND_DIFF_FILE, NULL, NULL);
517 if (text)
518 {
519 name = g_strconcat(doc_list[idx].file_name, ".vc.diff", NULL);
520 show_output(text, name, doc_list[idx].encoding);
521 g_free(text);
522 g_free(name);
523 }
524 g_free(locale_filename);
525 }
526
527 /* Make a diff from the current directory */
528 static void
529 vcdirectory_activated(GtkMenuItem * menuitem, gpointer gdata)
530 {
531 gint idx;
532 gchar *base_name = NULL;
533 gchar *locale_filename = NULL;
534 gchar *text = NULL;
535 const VC_RECORD *vc;
536
537 idx = documents->get_cur_idx();
538
539 g_return_if_fail(DOC_IDX_VALID(idx) && doc_list[idx].file_name != NULL);
540
541 if (doc_list[idx].changed)
542 {
543 documents->save_file(idx, FALSE);
544 }
545
546 locale_filename = utils->get_locale_from_utf8(doc_list[idx].file_name);
547 base_name = g_path_get_dirname(locale_filename);
548
549 vc = find_vc(base_name);
550 g_return_if_fail(vc);
551
552 execute_command(vc, &text, NULL, base_name, VC_COMMAND_DIFF_DIR, NULL, NULL);
553 if (text)
554 {
555 setptr(base_name, g_strconcat(base_name, ".vc.diff", NULL));
556 show_output(text, base_name, NULL);
557 g_free(text);
558 }
559
560 g_free(base_name);
561 g_free(locale_filename);
562 }
563
564
565 /* Callback if menu item for the current project was activated */
566 static void
567 vcproject_activated(GtkMenuItem * menuitem, gpointer gdata)
568 {
569 gint idx;
570 gchar *locale_filename = NULL;
571 gchar *text = NULL;
572 gchar *name;
573 const VC_RECORD *vc;
574
575 idx = documents->get_cur_idx();
576
577 g_return_if_fail(project != NULL && NZV(project->base_path));
578
579 if (DOC_IDX_VALID(idx) && doc_list[idx].changed && doc_list[idx].file_name != NULL)
580 {
581 documents->save_file(idx, FALSE);
582 }
583
584 locale_filename = utils->get_locale_from_utf8(project->base_path);
585
586 vc = find_vc(project->base_path);
587 g_return_if_fail(vc);
588
589 execute_command(vc, &text, NULL, project->base_path, VC_COMMAND_DIFF_DIR, NULL, NULL);
590 if (text)
591 {
592 name = g_strconcat(project->name, ".vc.diff", NULL);
593 show_output(text, name, NULL);
594 g_free(text);
595 g_free(name);
596 }
597 g_free(locale_filename);
598 }
599
600 static void
601 vclog_file_activated(GtkMenuItem * menuitem, gpointer gdata)
602 {
603 gint idx;
604 gchar *locale_filename;
605 gchar *output = NULL;
606 const VC_RECORD *vc;
607
608 idx = documents->get_cur_idx();
609
610 g_return_if_fail(DOC_IDX_VALID(idx) && doc_list[idx].file_name != NULL);
611
612 locale_filename = utils->get_locale_from_utf8(doc_list[idx].file_name);
613
614 ui->set_statusbar(TRUE, locale_filename);
615
616 vc = find_vc(doc_list[idx].file_name);
617 g_return_if_fail(vc);
618
619 execute_command(vc, &output, NULL, locale_filename, VC_COMMAND_LOG_FILE, NULL, NULL);
620 if (output)
621 {
622 show_output(output, "*VC-LOG*", NULL);
623 g_free(output);
624 }
625 g_free(locale_filename);
626 }
627
628 static void
629 vclog_dir_activated(GtkMenuItem * menuitem, gpointer gdata)
630 {
631 gint idx;
632 gchar *base_name = NULL;
633 gchar *locale_filename = NULL;
634 gchar *text = NULL;
635 const VC_RECORD *vc;
636
637 idx = documents->get_cur_idx();
638
639 g_return_if_fail(DOC_IDX_VALID(idx) && doc_list[idx].file_name != NULL);
640
641 locale_filename = utils->get_locale_from_utf8(doc_list[idx].file_name);
642 base_name = g_path_get_dirname(locale_filename);
643
644 vc = find_vc(base_name);
645 g_return_if_fail(vc);
646
647 execute_command(vc, &text, NULL, base_name, VC_COMMAND_LOG_DIR, NULL, NULL);
648 if (text)
649 {
650 show_output(text, "*VC-LOG*", NULL);
651 g_free(text);
652 }
653
654 g_free(base_name);
655 g_free(locale_filename);
656 }
657
658 static void
659 vclog_project_activated(GtkMenuItem * menuitem, gpointer gdata)
660 {
661 gint idx;
662 gchar *locale_filename = NULL;
663 gchar *text = NULL;
664 const VC_RECORD *vc;
665
666 idx = documents->get_cur_idx();
667
668 g_return_if_fail(project != NULL && NZV(project->base_path));
669
670 locale_filename = utils->get_locale_from_utf8(project->base_path);
671
672 vc = find_vc(locale_filename);
673 g_return_if_fail(vc);
674
675 execute_command(vc, &text, NULL, locale_filename, VC_COMMAND_LOG_DIR, NULL, NULL);
676 if (text)
677 {
678 show_output(text, "*VC-LOG*", NULL);
679 g_free(text);
680 }
681 g_free(locale_filename);
682 }
683
684 /* Show status from the current directory */
685 static void
686 vcstatus_activated(GtkMenuItem * menuitem, gpointer gdata)
687 {
688 gint idx;
689 gchar *base_name = NULL;
690 gchar *locale_filename = NULL;
691 gchar *text = NULL;
692 const VC_RECORD *vc;
693
694 idx = documents->get_cur_idx();
695
696 g_return_if_fail(DOC_IDX_VALID(idx) && doc_list[idx].file_name != NULL);
697
698 if (doc_list[idx].changed)
699 {
700 documents->save_file(idx, FALSE);
701 }
702
703 locale_filename = utils->get_locale_from_utf8(doc_list[idx].file_name);
704 base_name = g_path_get_dirname(locale_filename);
705
706 vc = find_vc(doc_list[idx].file_name);
707 g_return_if_fail(vc);
708
709 execute_command(vc, &text, NULL, base_name, VC_COMMAND_STATUS, NULL, NULL);
710 if (text)
711 {
712 show_output(text, "*VC-STATUS*", NULL);
713 g_free(text);
714 }
715
716 g_free(base_name);
717 g_free(locale_filename);
718 }
719
720 static gboolean
721 command_with_question_activated(GtkMenuItem * menuitem, gpointer gdata, gint cmd,
722 const gchar * question, gboolean ask)
723 {
724 gint idx;
725 gchar *locale_filename, *text;
726 GtkWidget *dialog;
727 gint result;
728 gchar *dir;
729 const VC_RECORD *vc;
730
731 idx = documents->get_cur_idx();
732
733 g_return_val_if_fail(DOC_IDX_VALID(idx) && doc_list[idx].file_name != NULL, FALSE);
734
735 if (doc_list[idx].changed)
736 {
737 documents->save_file(idx, FALSE);
738 }
739
740 locale_filename = utils->get_locale_from_utf8(doc_list[idx].file_name);
741
742 if (ask)
743 {
744 dialog = gtk_message_dialog_new(GTK_WINDOW(app->window),
745 GTK_DIALOG_DESTROY_WITH_PARENT,
746 GTK_MESSAGE_QUESTION,
747 GTK_BUTTONS_YES_NO, question, locale_filename);
748 result = gtk_dialog_run(GTK_DIALOG(dialog));
749 gtk_widget_destroy(dialog);
750 }
751 else
752 {
753 result = GTK_RESPONSE_YES;
754 }
755
756 if (result == GTK_RESPONSE_YES)
757 {
758 dir = g_path_get_dirname(doc_list[idx].file_name);
759 vc = find_vc(dir);
760 g_return_if_fail(vc);
761
762 execute_command(vc, &text, NULL, locale_filename, cmd, NULL, NULL);
763 if (text)
764 {
765 g_free(text);
766 }
767 g_free(dir);
768 }
769 g_free(locale_filename);
770 return (result == GTK_RESPONSE_YES) ? TRUE : FALSE;
771 }
772
773 static void
774 vcrevert_activated(GtkMenuItem * menuitem, gpointer gdata)
775 {
776 gint idx;
777 gboolean ret;
778 ret = command_with_question_activated(menuitem, gdata, VC_COMMAND_REVERT_FILE,
779 _("Do you really want to revert: %s"), TRUE);
780 if (ret)
781 {
782 idx = documents->get_cur_idx();
783 documents->reload_file(idx, NULL);
784 }
785 }
786
787
788 static void
789 vcadd_activated(GtkMenuItem * menuitem, gpointer gdata)
790 {
791 command_with_question_activated(menuitem, gdata, VC_COMMAND_ADD,
792 _("Do you really want to add: %s"), set_add_confirmation);
793 }
794
795 static void
796 vcremove_activated(GtkMenuItem * menuitem, gpointer gdata)
797 {
798 gboolean ret;
799
800 ret = command_with_question_activated(menuitem, gdata, VC_COMMAND_REMOVE,
801 _("Do you really want to remove: %s"), TRUE);
802 if (ret)
803 {
804 documents->remove(gtk_notebook_get_current_page(GTK_NOTEBOOK(app->notebook)));
805 }
806 }
807
808 #include "generated/interface.c"
809
810 enum
811 {
812 COLUMN_COMMIT,
813 COLUMN_STATUS,
814 COLUMN_PATH,
815 NUM_COLUMNS
816 };
817
818 static GtkTreeModel *
819 create_commit_model(const GSList * commit)
820 {
821 GtkListStore *store;
822 GtkTreeIter iter;
823 const GSList *cur;
824
825 /* create list store */
826 store = gtk_list_store_new(NUM_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING);
827
828 /* add data to the list store */
829
830 for (cur = commit; cur != NULL; cur = g_slist_next(cur))
831 {
832 gtk_list_store_append(store, &iter);
833 gtk_list_store_set(store, &iter,
834 COLUMN_COMMIT, TRUE,
835 COLUMN_STATUS, ((CommitItem *) (cur->data))->status,
836 COLUMN_PATH, ((CommitItem *) (cur->data))->path, -1);
837 }
838
839 return GTK_TREE_MODEL(store);
840 }
841
842 static gboolean
843 get_commit_files_foreach(GtkTreeModel * model, GtkTreePath * path, GtkTreeIter * iter,
844 gpointer data)
845 {
846 GSList **files = (GSList **) data;
847 gboolean commit;
848 gchar *filename;
849
850 gtk_tree_model_get(model, iter, COLUMN_COMMIT, &commit, -1);
851 if (!commit)
852 return FALSE;
853
854 gtk_tree_model_get(model, iter, COLUMN_PATH, &filename, -1);
855 *files = g_slist_prepend(*files, filename);
856 return FALSE;
857 }
858
859 static gboolean
860 get_commit_diff_foreach(GtkTreeModel * model, GtkTreePath * path, GtkTreeIter * iter, gpointer data)
861 {
862 gchar **diff = (gchar **) data;
863 gboolean commit;
864 gchar *filename;
865 gchar *tmp = NULL;
866 gchar *status;
867 const VC_RECORD *vc;
868
869 gtk_tree_model_get(model, iter, COLUMN_COMMIT, &commit, -1);
870 if (!commit)
871 return FALSE;
872
873 gtk_tree_model_get(model, iter, COLUMN_STATUS, &status, -1);
874
875 if (strcmp(status, FILE_STATUS_MODIFIED) != 0)
876 {
877 g_free(status);
878 return FALSE;
879 }
880
881 gtk_tree_model_get(model, iter, COLUMN_PATH, &filename, -1);
882
883 vc = find_vc(filename);
884 g_return_val_if_fail(vc, FALSE);
885
886 execute_command(vc, &tmp, NULL, filename, VC_COMMAND_DIFF_FILE, NULL, NULL);
887 setptr(*diff, g_strdup_printf("%s%s", *diff, tmp));
888
889 g_free(tmp);
890 g_free(filename);
891 return FALSE;
892 }
893
894 static gchar *
895 get_commit_diff(GtkTreeView * treeview)
896 {
897 GtkTreeModel *model = gtk_tree_view_get_model(treeview);
898 GtkTreeIter iter;
899 gchar *ret = g_strdup("");
900
901 gtk_tree_model_foreach(model, get_commit_diff_foreach, &ret);
902 return ret;
903 }
904
905 static void
906 commit_toggled(GtkCellRendererToggle * cell, gchar * path_str, gpointer data)
907 {
908 GtkTreeView *treeview = GTK_TREE_VIEW(data);
909 GtkWidget *diffView = lookup_widget(GTK_WIDGET(treeview), "textDiff");
910 GtkTreeModel *model = gtk_tree_view_get_model(treeview);
911 GtkTreeIter iter;
912 GtkTreePath *path = gtk_tree_path_new_from_string(path_str);
913 gboolean fixed;
914 gchar *diff;
915
916 /* get toggled iter */
917 gtk_tree_model_get_iter(model, &iter, path);
918 gtk_tree_model_get(model, &iter, COLUMN_COMMIT, &fixed, -1);
919
920 /* do something with the value */
921 fixed ^= 1;
922
923 /* set new value */
924 gtk_list_store_set(GTK_LIST_STORE(model), &iter, COLUMN_COMMIT, fixed, -1);
925
926 diff = get_commit_diff(GTK_TREE_VIEW(treeview));
927 gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(diffView)), diff, -1);
928
929 /* clean up */
930 gtk_tree_path_free(path);
931 g_free(diff);
932 }
933
934 static void
935 add_commit_columns(GtkTreeView * treeview)
936 {
937 GtkCellRenderer *renderer;
938 GtkTreeViewColumn *column;
939 GtkTreeModel *model = gtk_tree_view_get_model(treeview);
940
941 /* column for fixed toggles */
942 renderer = gtk_cell_renderer_toggle_new();
943 g_signal_connect(renderer, "toggled", G_CALLBACK(commit_toggled), treeview);
944
945 column = gtk_tree_view_column_new_with_attributes("Commit?",
946 renderer, "active", COLUMN_COMMIT, NULL);
947
948 /* set this column to a fixed sizing (of 50 pixels) */
949 gtk_tree_view_column_set_sizing(GTK_TREE_VIEW_COLUMN(column), GTK_TREE_VIEW_COLUMN_FIXED);
950 gtk_tree_view_column_set_fixed_width(GTK_TREE_VIEW_COLUMN(column), 70);
951 gtk_tree_view_append_column(treeview, column);
952
953 /* column for bug numbers */
954 renderer = gtk_cell_renderer_text_new();
955 column = gtk_tree_view_column_new_with_attributes("Status",
956 renderer, "text", COLUMN_STATUS, NULL);
957 gtk_tree_view_column_set_sort_column_id(column, COLUMN_STATUS);
958 gtk_tree_view_append_column(treeview, column);
959
960 /* column for severities */
961 renderer = gtk_cell_renderer_text_new();
962 column = gtk_tree_view_column_new_with_attributes("Path",
963 renderer, "text", COLUMN_PATH, NULL);
964 gtk_tree_view_column_set_sort_column_id(column, COLUMN_PATH);
965 gtk_tree_view_append_column(treeview, column);
966 }
967
968 GtkWidget *
969 lookup_widget(GtkWidget * widget, const gchar * widget_name)
970 {
971 GtkWidget *parent, *found_widget;
972
973 for (;;)
974 {
975 if (GTK_IS_MENU(widget))
976 parent = gtk_menu_get_attach_widget(GTK_MENU(widget));
977 else
978 parent = widget->parent;
979 if (!parent)
980 parent = (GtkWidget *) g_object_get_data(G_OBJECT(widget),
981 "GladeParentKey");
982 if (parent == NULL)
983 break;
984 widget = parent;
985 }
986
987 found_widget = (GtkWidget *) g_object_get_data(G_OBJECT(widget), widget_name);
988 if (!found_widget)
989 g_warning("Widget not found: %s", widget_name);
990 return found_widget;
991 }
992
993 static void
994 vccommit_activated(GtkMenuItem * menuitem, gpointer gdata)
995 {
996 document *doc;
997 gint result;
998 const VC_RECORD *vc;
999 GSList *lst;
1000 GtkTreeModel *model;
1001 GtkWidget *commit = create_commitDialog();
1002 GtkWidget *treeview = lookup_widget(commit, "treeSelect");
1003 GtkWidget *diffView = lookup_widget(commit, "textDiff");
1004 GtkWidget *messageView = lookup_widget(commit, "textCommitMessage");
1005 GtkTextBuffer *mbuf;
1006 GtkTextIter begin;
1007 GtkTextIter end;
1008 GSList *selected_files = NULL;
1009
1010 gchar *dir;
1011 gchar *message;
1012 gchar *diff;
1013
1014 doc = documents->get_current();
1015 g_return_if_fail(doc);
1016 g_return_if_fail(doc->file_name);
1017 dir = g_path_get_dirname(doc->file_name);
1018
1019 vc = find_vc(dir);
1020 g_return_if_fail(vc);
1021
1022 lst = vc->get_commit_files(dir);
1023 model = create_commit_model(lst);
1024 gtk_tree_view_set_model(GTK_TREE_VIEW(treeview), model);
1025 g_object_unref(model);
1026
1027 /* add columns to the tree view */
1028 add_commit_columns(GTK_TREE_VIEW(treeview));
1029
1030 diff = get_commit_diff(GTK_TREE_VIEW(treeview));
1031 gtk_text_buffer_set_text(gtk_text_view_get_buffer(GTK_TEXT_VIEW(diffView)), diff, -1);
1032
1033 gtk_window_maximize(GTK_WINDOW(commit));
1034
1035 result = gtk_dialog_run(GTK_DIALOG(commit));
1036 if (result == GTK_RESPONSE_APPLY)
1037 {
1038 mbuf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(messageView));
1039 gtk_text_buffer_get_start_iter(mbuf, &begin);
1040 gtk_text_buffer_get_end_iter(mbuf, &end);
1041 message = gtk_text_buffer_get_text(mbuf, &begin, &end, FALSE);
1042 gtk_tree_model_foreach(model, get_commit_files_foreach, &selected_files);
1043 execute_command(vc, NULL, NULL, dir, VC_COMMAND_COMMIT, selected_files, message);
1044 g_free(message);
1045 }
1046 gtk_widget_destroy(commit);
1047 free_commit_list(lst);
1048 g_free(dir);
1049 g_free(diff);
1050 }
1051
1052 static GtkWidget *menu_vc_diff_file = NULL;
1053 static GtkWidget *menu_vc_diff_dir = NULL;
1054 static GtkWidget *menu_vc_diff_project = NULL;
1055 static GtkWidget *menu_vc_log_file = NULL;
1056 static GtkWidget *menu_vc_log_dir = NULL;
1057 static GtkWidget *menu_vc_log_project = NULL;
1058 static GtkWidget *menu_vc_status = NULL;
1059 static GtkWidget *menu_vc_revert_file = NULL;
1060 static GtkWidget *menu_vc_add_file = NULL;
1061 static GtkWidget *menu_vc_remove_file = NULL;
1062 static GtkWidget *menu_vc_commit = NULL;
1063
1064 static void
1065 update_menu_items()
1066 {
1067 document *doc;
1068 gboolean have_file;
1069 gboolean p_have_vc = FALSE;
1070 gboolean d_have_vc = FALSE;
1071 gboolean f_have_vc = FALSE;
1072
1073 gchar *dir;
1074
1075 doc = documents->get_current();
1076 have_file = doc && doc->file_name && g_path_is_absolute(doc->file_name);
1077
1078 if (have_file)
1079 {
1080 dir = g_path_get_dirname(doc->file_name);
1081 if (find_cmd_env(VC_COMMAND_DIFF_FILE, TRUE, dir))
1082 d_have_vc = TRUE;
1083
1084 if (find_cmd_env(VC_COMMAND_DIFF_FILE, TRUE, doc->file_name))
1085 f_have_vc = TRUE;
1086 g_free(dir);
1087 }
1088
1089 if (project != NULL && NZV(project->base_path) &&
1090 find_cmd_env(VC_COMMAND_DIFF_DIR, TRUE, project->base_path))
1091 p_have_vc = TRUE;
1092
1093 gtk_widget_set_sensitive(menu_vc_diff_file, f_have_vc);
1094 gtk_widget_set_sensitive(menu_vc_diff_dir, d_have_vc);
1095 gtk_widget_set_sensitive(menu_vc_diff_project, p_have_vc);
1096
1097 gtk_widget_set_sensitive(menu_vc_log_file, f_have_vc);
1098 gtk_widget_set_sensitive(menu_vc_log_dir, d_have_vc);
1099 gtk_widget_set_sensitive(menu_vc_log_project, p_have_vc);
1100
1101 gtk_widget_set_sensitive(menu_vc_status, d_have_vc);
1102
1103 gtk_widget_set_sensitive(menu_vc_revert_file, f_have_vc);
1104
1105 gtk_widget_set_sensitive(menu_vc_remove_file, f_have_vc);
1106 gtk_widget_set_sensitive(menu_vc_add_file, d_have_vc && !f_have_vc);
1107
1108 gtk_widget_set_sensitive(menu_vc_commit, d_have_vc);
1109 }
1110
1111 void
1112 configure(GtkWidget * parent)
1113 {
1114 GtkWidget *dialog, *vbox, *checkbox, *checkbox2, *checkbox3, *checkbox4, *checkbox5,
1115 *checkbox6;
1116 GtkTooltips *tooltip = NULL;
1117
1118 tooltip = gtk_tooltips_new();
1119 dialog = gtk_dialog_new_with_buttons(_("Version Control"),
1120 GTK_WINDOW(parent), GTK_DIALOG_DESTROY_WITH_PARENT,
1121 GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK,
1122 GTK_RESPONSE_ACCEPT, NULL);
1123 vbox = ui->dialog_vbox_new(GTK_DIALOG(dialog));
1124 gtk_widget_set_name(dialog, "GeanyDialog");
1125 gtk_box_set_spacing(GTK_BOX(vbox), 2);
1126
1127 checkbox =
1128 gtk_check_button_new_with_label(_
1129 ("Set Changed-flag for document tabs created by the plugin"));
1130 gtk_tooltips_set_tip(tooltip, checkbox,
1131 _
1132 ("If this option is activated, every new by the VC-plugin created document tab "
1133 "will be marked as changed. Even this option is useful in some cases, it could cause "
1134 "a big number of annoying \"Do you want to save\"-dialogs."), NULL);
1135 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox), FALSE);
1136 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox), set_changed_flag);
1137 gtk_box_pack_start(GTK_BOX(vbox), checkbox, FALSE, FALSE, 2);
1138
1139 checkbox2 = gtk_check_button_new_with_label(_("Confirm adding new files to a VCS"));
1140 gtk_tooltips_set_tip(tooltip, checkbox2,
1141 _
1142 ("Shows a confirmation dialog on adding a new (created) file to VCS."),
1143 NULL);
1144 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox2), FALSE);
1145 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox2), set_add_confirmation);
1146 gtk_box_pack_start(GTK_BOX(vbox), checkbox2, TRUE, FALSE, 2);
1147
1148 checkbox3 = gtk_check_button_new_with_label(_("Enable CVS"));
1149 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox3), FALSE);
1150 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox3), enable_cvs);
1151 gtk_box_pack_start(GTK_BOX(vbox), checkbox3, TRUE, FALSE, 2);
1152
1153 checkbox4 = gtk_check_button_new_with_label(_("Enable GIT"));
1154 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox4), FALSE);
1155 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox4), enable_git);
1156 gtk_box_pack_start(GTK_BOX(vbox), checkbox4, TRUE, FALSE, 2);
1157
1158 checkbox5 = gtk_check_button_new_with_label(_("Enable SVN"));
1159 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox5), FALSE);
1160 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox5), enable_svn);
1161 gtk_box_pack_start(GTK_BOX(vbox), checkbox5, TRUE, FALSE, 2);
1162
1163 checkbox6 = gtk_check_button_new_with_label(_("Enable SVK"));
1164 gtk_button_set_focus_on_click(GTK_BUTTON(checkbox6), FALSE);
1165 gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(checkbox6), enable_svk);
1166 gtk_box_pack_start(GTK_BOX(vbox), checkbox6, TRUE, FALSE, 2);
1167
1168 gtk_widget_show_all(vbox);
1169
1170 // run the dialog and check for the response code
1171 if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT)
1172 {
1173 GKeyFile *config = g_key_file_new();
1174 gchar *data;
1175 gchar *config_dir = g_path_get_dirname(config_file);
1176
1177 set_changed_flag = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbox));
1178 set_add_confirmation = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbox2));
1179
1180 enable_cvs = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbox3));
1181 enable_git = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbox4));
1182 enable_svn = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbox5));
1183 enable_svk = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(checkbox6));
1184
1185 g_key_file_load_from_file(config, config_file, G_KEY_FILE_NONE, NULL);
1186
1187 g_key_file_set_boolean(config, "VC", "set_changed_flag", set_changed_flag);
1188 g_key_file_set_boolean(config, "VC", "set_add_confirmation", set_add_confirmation);
1189
1190 g_key_file_set_boolean(config, "VC", "enable_cvs", enable_cvs);
1191 g_key_file_set_boolean(config, "VC", "enable_git", enable_git);
1192 g_key_file_set_boolean(config, "VC", "enable_svn", enable_svn);
1193 g_key_file_set_boolean(config, "VC", "enable_svk", enable_svk);
1194
1195 if (!g_file_test(config_dir, G_FILE_TEST_IS_DIR)
1196 && utils->mkdir(config_dir, TRUE) != 0)
1197 {
1198 dialogs->show_msgbox(GTK_MESSAGE_ERROR,
1199 _
1200 ("Plugin configuration directory could not be created."));
1201 }
1202 else
1203 {
1204 // write config to file
1205 data = g_key_file_to_data(config, NULL, NULL);
1206 utils->write_file(config_file, data);
1207 g_free(data);
1208 }
1209
1210 g_free(config_dir);
1211 g_key_file_free(config);
1212
1213 registrate();
1214 }
1215 gtk_widget_destroy(dialog);
1216 }
1217
1218 static void
1219 load_config()
1220 {
1221 GError *error = NULL;
1222 GKeyFile *config = g_key_file_new();
1223
1224 g_key_file_load_from_file(config, config_file, G_KEY_FILE_NONE, NULL);
1225 set_changed_flag = g_key_file_get_boolean(config, "VC", "set_changed_flag", &error);
1226 if (error != NULL)
1227 {
1228 // Set default value if something went wrong while reading file
1229 set_changed_flag = FALSE;
1230 g_error_free(error);
1231 error = NULL;
1232 }
1233 set_add_confirmation = g_key_file_get_boolean(config, "VC", "set_add_confirmation", &error);
1234 if (error != NULL)
1235 {
1236 // Set default value if something went wrong while reading file
1237 set_add_confirmation = TRUE;
1238 g_error_free(error);
1239 error = NULL;
1240 }
1241
1242 enable_cvs = g_key_file_get_boolean(config, "VC", "enable_cvs", &error);
1243 if (error != NULL)
1244 {
1245 // Set default value if something went wrong while reading file
1246 enable_cvs = TRUE;
1247 g_error_free(error);
1248 error = NULL;
1249 }
1250
1251 enable_git = g_key_file_get_boolean(config, "VC", "enable_git", &error);
1252 if (error != NULL)
1253 {
1254 // Set default value if something went wrong while reading file
1255 enable_git = TRUE;
1256 g_error_free(error);
1257 error = NULL;
1258 }
1259
1260 enable_svn = g_key_file_get_boolean(config, "VC", "enable_svn", &error);
1261 if (error != NULL)
1262 {
1263 // Set default value if something went wrong while reading file
1264 enable_svn = TRUE;
1265 g_error_free(error);
1266 error = NULL;
1267 }
1268
1269 enable_svk = g_key_file_get_boolean(config, "VC", "enable_svk", &error);
1270 if (error != NULL)
1271 {
1272 // Set default value if something went wrong while reading file
1273 enable_svk = TRUE;
1274 g_error_free(error);
1275 error = NULL;
1276 }
1277 g_key_file_free(config);
1278 }
1279
1280 static void
1281 registrate()
1282 {
1283 gchar *path;
1284 if (VC)
1285 {
1286 g_slist_free(VC);
1287 VC = NULL;
1288 }
1289 REGISTER_VC(GIT, enable_git);
1290 REGISTER_VC(SVN, enable_svn);
1291 REGISTER_VC(CVS, enable_cvs);
1292 REGISTER_VC(SVK, enable_svk);
1293 }
1294
1295 /* Called by Geany to initialize the plugin */
1296 void
1297 init(GeanyData * data)
1298 {
1299 GtkWidget *menu_vc = NULL;
1300 GtkWidget *menu_vc_menu = NULL;
1301 GtkTooltips *tooltips = NULL;
1302 gchar *path;
1303
1304 config_file = g_strconcat(app->configdir, G_DIR_SEPARATOR_S, "plugins", G_DIR_SEPARATOR_S,
1305 "VC", G_DIR_SEPARATOR_S, "VC.conf", NULL);
1306
1307 load_config();
1308 registrate();
1309
1310 tooltips = gtk_tooltips_new();
1311
1312 menu_vc = gtk_image_menu_item_new_with_mnemonic(_("_VC"));
1313 gtk_container_add(GTK_CONTAINER(data->tools_menu), menu_vc);
1314
1315 g_signal_connect((gpointer) menu_vc, "activate", G_CALLBACK(update_menu_items), NULL);
1316
1317 menu_vc_menu = gtk_menu_new();
1318 gtk_menu_item_set_submenu(GTK_MENU_ITEM(menu_vc), menu_vc_menu);
1319
1320 // Single file
1321 menu_vc_diff_file = gtk_menu_item_new_with_mnemonic(_("Diff From Current File"));
1322 gtk_container_add(GTK_CONTAINER(menu_vc_menu), menu_vc_diff_file);
1323 gtk_tooltips_set_tip(tooltips, menu_vc_diff_file,
1324 _("Make a diff from the current active file"), NULL);
1325
1326 g_signal_connect((gpointer) menu_vc_diff_file, "activate",
1327 G_CALLBACK(vcfile_activated), NULL);
1328
1329 // Directory
1330 menu_vc_diff_dir = gtk_menu_item_new_with_mnemonic(_("Diff From Current Directory"));
1331 gtk_container_add(GTK_CONTAINER(menu_vc_menu), menu_vc_diff_dir);
1332 gtk_tooltips_set_tip(tooltips, menu_vc_diff_dir,
1333 _("Make a diff from the directory of the current active file"), NULL);
1334
1335 g_signal_connect((gpointer) menu_vc_diff_dir, "activate",
1336 G_CALLBACK(vcdirectory_activated), NULL);
1337
1338 // Project
1339 menu_vc_diff_project = gtk_menu_item_new_with_mnemonic(_("Diff From Current Project"));
1340 gtk_container_add(GTK_CONTAINER(menu_vc_menu), menu_vc_diff_project);
1341 gtk_tooltips_set_tip(tooltips, menu_vc_diff_project,
1342 _("Make a diff from the current project's base path"), NULL);
1343
1344 g_signal_connect((gpointer) menu_vc_diff_project, "activate",
1345 G_CALLBACK(vcproject_activated), NULL);
1346
1347 gtk_container_add(GTK_CONTAINER(menu_vc_menu), gtk_separator_menu_item_new());
1348
1349 // Log
1350 menu_vc_log_file = gtk_menu_item_new_with_mnemonic(_("Log Of Current File"));
1351 gtk_container_add(GTK_CONTAINER(menu_vc_menu), menu_vc_log_file);
1352 gtk_tooltips_set_tip(tooltips, menu_vc_log_file,
1353 _("Shows the log of the current file"), NULL);
1354
1355 g_signal_connect((gpointer) menu_vc_log_file, "activate",
1356 G_CALLBACK(vclog_file_activated), NULL);
1357
1358 menu_vc_log_dir = gtk_menu_item_new_with_mnemonic(_("Log Of Current Directory"));
1359 gtk_container_add(GTK_CONTAINER(menu_vc_menu), menu_vc_log_dir);
1360 gtk_tooltips_set_tip(tooltips, menu_vc_log_dir,
1361 _("Shows the log of the current directory"), NULL);
1362
1363 g_signal_connect((gpointer) menu_vc_log_dir, "activate",
1364 G_CALLBACK(vclog_dir_activated), NULL);
1365
1366 menu_vc_log_project = gtk_menu_item_new_with_mnemonic(_("Log Of Current Project"));
1367 gtk_container_add(GTK_CONTAINER(menu_vc_menu), menu_vc_log_project);
1368 gtk_tooltips_set_tip(tooltips, menu_vc_log_project,
1369 _("Shows the log of the current project"), NULL);
1370
1371 g_signal_connect((gpointer) menu_vc_log_project, "activate",
1372 G_CALLBACK(vclog_project_activated), NULL);
1373
1374 gtk_container_add(GTK_CONTAINER(menu_vc_menu), gtk_separator_menu_item_new());
1375
1376 // Status
1377 menu_vc_status = gtk_menu_item_new_with_mnemonic(_("Status"));
1378 gtk_container_add(GTK_CONTAINER(menu_vc_menu), menu_vc_status);
1379 gtk_tooltips_set_tip(tooltips, menu_vc_status, _("Show status."), NULL);
1380
1381 g_signal_connect((gpointer) menu_vc_status, "activate",
1382 G_CALLBACK(vcstatus_activated), NULL);
1383
1384 gtk_container_add(GTK_CONTAINER(menu_vc_menu), gtk_separator_menu_item_new());
1385
1386 // Revert file
1387 menu_vc_revert_file = gtk_menu_item_new_with_mnemonic(_("Revert File"));
1388 gtk_container_add(GTK_CONTAINER(menu_vc_menu), menu_vc_revert_file);
1389 gtk_tooltips_set_tip(tooltips, menu_vc_revert_file,
1390 _("Restore pristine working copy file (undo local edits)."), NULL);
1391
1392 g_signal_connect((gpointer) menu_vc_revert_file, "activate",
1393 G_CALLBACK(vcrevert_activated), NULL);
1394
1395 gtk_container_add(GTK_CONTAINER(menu_vc_menu), gtk_separator_menu_item_new());
1396
1397 // Add file
1398 menu_vc_add_file = gtk_menu_item_new_with_mnemonic(_("Add File"));
1399 gtk_container_add(GTK_CONTAINER(menu_vc_menu), menu_vc_add_file);
1400 gtk_tooltips_set_tip(tooltips, menu_vc_add_file, _("Add file to repository."), NULL);
1401
1402 g_signal_connect((gpointer) menu_vc_add_file, "activate",
1403 G_CALLBACK(vcadd_activated), NULL);
1404
1405 // Remove file
1406 menu_vc_remove_file = gtk_menu_item_new_with_mnemonic(_("Remove File"));
1407 gtk_container_add(GTK_CONTAINER(menu_vc_menu), menu_vc_remove_file);
1408 gtk_tooltips_set_tip(tooltips, menu_vc_remove_file,
1409 _("Remove file from repository."), NULL);
1410
1411 g_signal_connect((gpointer) menu_vc_remove_file, "activate",
1412 G_CALLBACK(vcremove_activated), NULL);
1413
1414 gtk_container_add(GTK_CONTAINER(menu_vc_menu), gtk_separator_menu_item_new());
1415
1416 // Commit
1417 menu_vc_commit = gtk_menu_item_new_with_mnemonic(_("Commit"));
1418 gtk_container_add(GTK_CONTAINER(menu_vc_menu), menu_vc_commit);
1419 gtk_tooltips_set_tip(tooltips, menu_vc_commit, _("Commit changes."), NULL);
1420
1421 g_signal_connect((gpointer) menu_vc_commit, "activate",
1422 G_CALLBACK(vccommit_activated), NULL);
1423
1424 gtk_widget_show_all(menu_vc);
1425
1426 plugin_fields->menu_item = menu_vc;
1427 plugin_fields->flags = PLUGIN_IS_DOCUMENT_SENSITIVE;
1428 }
1429
1430
1431 /* Called by Geany before unloading the plugin. */
1432 void
1433 cleanup()
1434 {
1435 // remove the menu item added in init()
1436 gtk_widget_destroy(plugin_fields->menu_item);
1437 g_slist_free(VC);
1438 VC = NULL;
1439 g_free(config_file);
1440 }
Plugin for geany IDE to work with different version control systems.