common/cheetahmenu.c

   1
   2 #include "cache.h"
   3 #include "exec.h"
   4 #include "menuengine.h"
   5 #include "cheetahmenu.h"
   6 #include "debug.h"
   7 #include "systeminfo.h"
   8
   9 char *wd_from_path(const char *path, BOOL *is_path_dir)
  10 {
  11         BOOL directory = TRUE;
  12         char *cheetah_wd = strdup(path);
  13         if (!is_directory(cheetah_wd)) {
  14                 char *c = strrchr(cheetah_wd, PATH_SEPERATOR);
  15                 if (c) /* sanity check in case it's a weird directory */
  16                         *c = 0;
  17
  18                 directory = FALSE;
  19         }
  20
  21         if (is_path_dir)
  22                 *is_path_dir = directory;
  23
  24         return cheetah_wd;
  25 }
  26
  27 static char *get_git_prefix(const char *wd, int *out_status)
  28 {
  29         char *prefix = NULL, *eol;
  30         int status;
  31         struct strbuf output = STRBUF_INIT;
  32
  33         status = exec_program(wd, &output, NULL, WAITMODE,
  34                 "git", "rev-parse", "--show-prefix", NULL);
  35         if (out_status)
  36                 *out_status = status;
  37
  38         eol = strchr(output.buf, '\n');
  39         if (eol)
  40                 *eol = 0;
  41
  42         if (!status) /* we're in the repo */
  43                 prefix = strdup(output.buf);
  44
  45         strbuf_release(&output);
  46         return prefix;
  47 }
  48
  49 /*
  50  * Cheetah-specific menu
  51  */
  52
  53 static int menu_gui(struct git_data *this_, UINT id)
  54 {
  55         char *wd = wd_from_path(this_->name, NULL);
  56         const char **argv;
  57
  58         free_func_t argv_free;
  59         void *argv_data;
  60
  61         const char *generic_argv[] = { "git", "gui", NULL };
  62
  63         argv = menu_get_platform_argv(MENU_GUI, NULL,
  64                         &argv_free, &argv_data);
  65
  66         if (!argv)
  67                 argv = generic_argv;
  68
  69         exec_program_v(wd, NULL, NULL, HIDDENMODE, argv);
  70
  71         if (argv_free)
  72                 argv_free(argv_data);
  73         free(wd);
  74
  75         return 0;
  76 }
  77
  78 static int menu_init(struct git_data *this_, UINT id)
  79 {
  80         char *wd = wd_from_path(this_->name, NULL);
  81         const char **argv;
  82
  83         free_func_t argv_free;
  84         void *argv_data;
  85
  86         const char *generic_argv[] = { "git", "init", NULL };
  87
  88         argv = menu_get_platform_argv(MENU_INIT, NULL,
  89                         &argv_free, &argv_data);
  90         if (!argv)
  91                 argv = generic_argv;
  92
  93         exec_program_v(wd, NULL, NULL, HIDDENMODE | WAITMODE, argv);
  94
  95         if (argv_free)
  96                 argv_free(argv_data);
  97         free(wd);
  98
  99         return 1;
 100 }
 101
 102 static int menu_history(struct git_data *this_, unsigned int id)
 103 {
 104         BOOL is_directory;
 105         char *wd = wd_from_path(this_->name, &is_directory);
 106         char *name = NULL;
 107         const char **argv;
 108
 109         free_func_t argv_free;
 110         void *argv_data;
 111
 112         const char *generic_argv[] = { "gitk", "HEAD", "--",
 113                 NULL, NULL };
 114
 115         if (!is_directory)
 116                 name = this_->name + strlen(wd) + 1;
 117         generic_argv[3] = name;
 118
 119         argv = menu_get_platform_argv(MENU_HISTORY, name,
 120                         &argv_free, &argv_data);
 121         if (!argv)
 122                 argv = generic_argv;
 123
 124         exec_program_v(wd, NULL, NULL, HIDDENMODE, argv);
 125
 126         if (argv_free)
 127                 argv_free(argv_data);
 128         free(wd);
 129
 130         return 0;
 131 }
 132
 133 static int menu_bash(struct git_data *this_, UINT id)
 134 {
 135         char *wd = wd_from_path(this_->name, NULL);
 136         const char **argv;
 137
 138         free_func_t argv_free;
 139         void *argv_data;
 140
 141         argv = menu_get_platform_argv(MENU_BASH, wd,
 142                         &argv_free, &argv_data);
 143         /* There is no generic implementation for this item */
 144         if (!argv) {
 145                 debug_git("Error: Got no platform terminal for bash");
 146                 return 0;
 147         }
 148
 149         exec_program_v(wd, NULL, NULL, NORMALMODE, argv);
 150
 151         if (argv_free)
 152                 argv_free(argv_data);
 153         free(wd);
 154
 155         return 0;
 156 }
 157
 158 static int menu_blame(struct git_data *this_, UINT id)
 159 {
 160         BOOL is_directory;
 161         char *wd = wd_from_path(this_->name, &is_directory);
 162         char *name = "";
 163         const char **argv;
 164
 165         free_func_t argv_free = NULL;
 166         void *argv_data;
 167
 168         const char *generic_argv[] = { "git", "gui", "blame",
 169                 NULL, NULL };
 170
 171         if (!is_directory) {
 172                 name = this_->name + strlen(wd) + 1;
 173                 generic_argv[3] = name;
 174
 175                 argv = menu_get_platform_argv(MENU_BLAME, name,
 176                                 &argv_free, &argv_data);
 177                 if (!argv)
 178                         argv = generic_argv;
 179
 180                 exec_program_v(wd, NULL, NULL, HIDDENMODE, argv);
 181         }
 182
 183         if (argv_free)
 184                 argv_free(argv_data);
 185         free(wd);
 186
 187         return 0;
 188 }
 189
 190 static int menu_citool(struct git_data *this_, UINT id)
 191 {
 192         char *wd = wd_from_path(this_->name, NULL);
 193         const char **argv;
 194
 195         free_func_t argv_free;
 196         void *argv_data;
 197
 198         const char *generic_argv[] = { "git", "citool", NULL };
 199
 200         argv = menu_get_platform_argv(MENU_CITOOL, NULL,
 201                         &argv_free, &argv_data);
 202         if (!argv)
 203                 argv = generic_argv;
 204
 205         exec_program_v(wd, NULL, NULL, HIDDENMODE, argv);
 206
 207         if (argv_free)
 208                 argv_free(argv_data);
 209         free(wd);
 210
 211         return 0;
 212 }
 213
 214 static int menu_addall(struct git_data *this_, UINT id)
 215 {
 216         char *wd = wd_from_path(this_->name, NULL);
 217         const char **argv;
 218
 219         free_func_t argv_free;
 220         void *argv_data;
 221
 222         const char *generic_argv[] = { "git", "add", "--all", NULL };
 223
 224         argv = menu_get_platform_argv(MENU_ADDALL, NULL,
 225                         &argv_free, &argv_data);
 226         if (!argv)
 227                 argv = generic_argv;
 228
 229         exec_program_v(wd, NULL, NULL, HIDDENMODE, argv);
 230
 231         if (argv_free)
 232                 argv_free(argv_data);
 233         free(wd);
 234
 235         return 0;
 236 }
 237
 238 static int menu_branch(struct git_data *this_, UINT id)
 239 {
 240         int status;
 241         char *wd = wd_from_path(this_->name, NULL);
 242         struct strbuf err;
 243         const char *menu_item_text;
 244         const char **argv;
 245
 246         free_func_t argv_free;
 247         void *argv_data;
 248
 249         const char *generic_argv[] = { "git", "checkout", NULL, NULL };
 250
 251         menu_item_text = get_menu_item_text(id);
 252         generic_argv[2] = menu_item_text;
 253
 254         argv = menu_get_platform_argv(MENU_BRANCH, menu_item_text,
 255                         &argv_free, &argv_data);
 256         if (!argv)
 257                 argv = generic_argv;
 258
 259         strbuf_init(&err, 0);
 260
 261         status = exec_program_v(wd, NULL, &err, HIDDENMODE | WAITMODE, argv);
 262
 263         /* if nothing, terribly wrong happened, show the confirmation */
 264         if (-1 != status)
 265                 /* strangely enough even success message is on stderr */
 266                 debug_git_mbox(err.buf);
 267
 268         if (argv_free)
 269                 argv_free(argv_data);
 270         free(wd);
 271
 272         return 1;
 273 }
 274
 275 static BOOL build_branch_menu(struct git_data *data,
 276                               const struct menu_item *item,
 277                               void *platform)
 278 {
 279         void *submenu;
 280
 281         int status;
 282         char *wd = wd_from_path(data->name, NULL);
 283
 284         struct strbuf output;
 285         struct strbuf **lines, **it;
 286         strbuf_init(&output, 0);
 287
 288         status = exec_program(wd, &output, NULL, WAITMODE,
 289                 "git", "branch", NULL);
 290         free(wd);
 291         if (status)
 292                 return FALSE;
 293
 294         submenu = start_submenu(data, item, platform);
 295
 296         lines = strbuf_split(&output, '\n');
 297         for (it = lines; *it; it++) {
 298                 struct menu_item item = {
 299                         MENU_ITEM_CLEANUP, 0,
 300                         NULL, NULL,
 301                         NULL, menu_branch
 302                 };
 303
 304                 strbuf_rtrim(*it);
 305                 item.string = strdup((*it)->buf + 2);
 306                 item.helptext = strdup((*it)->buf + 2);
 307                 item.flags = '*' == (*it)->buf[0] ?
 308                         MI_CHECKED | MI_DISABLED : 0;
 309                 if (build_item(data, &item, submenu))
 310                         append_active_menu(&item);
 311                 else
 312                         /*
 313                          * if the platform failed to create an item
 314                          * there is no point to try other items
 315                          */
 316                         break;
 317         }
 318
 319         end_submenu(platform, submenu);
 320
 321         /* technically, there is nothing to track for the menu engine */
 322         return FALSE;
 323 }
 324
 325 UINT cheetah_menu_mask(struct git_data *this_)
 326 {
 327         BOOL is_directory;
 328         char *wd = wd_from_path(this_->name, &is_directory);
 329         UINT selection = is_directory ? MENU_ITEM_DIR : MENU_ITEM_FILE;
 330         int status;
 331         char *prefix = get_git_prefix(wd, &status);
 332
 333         if (status < 0) /* something went terribly wrong */
 334                 selection = MENU_ITEM_LAST;
 335         else if (status)
 336                 selection |= MENU_ITEM_NOREPO;
 337         else {
 338                 char head_path[MAX_PATH] = "HEAD";
 339                 if (!is_directory)
 340                         sprintf(head_path, "HEAD:%s%s",
 341                                 prefix,
 342                                 this_->name + strlen(wd) + 1);
 343
 344                 status = exec_program(wd, NULL, NULL, WAITMODE,
 345                         "git", "rev-parse", "--verify", head_path, NULL);
 346                 if (status < 0) /* something went terribly wrong */
 347                         selection = MENU_ITEM_LAST;
 348                 else
 349                         selection |= MENU_ITEM_REPO |
 350                                 (status ?
 351                                         MENU_ITEM_NOTRACK : MENU_ITEM_TRACK);
 352         }
 353
 354         free(prefix);
 355         free(wd);
 356         return selection;
 357 }
 358
 359 const struct menu_item cheetah_menu[] = {
 360         { MENU_ITEM_ALWAYS, 0, NULL, NULL, build_separator, NULL },
 361
 362         { MENU_ITEM_REPO, 0, "Git &Add all files now",
 363                 "Add all files from this folder now",
 364                 build_item, menu_addall },
 365         { MENU_ITEM_REPO, 0, "Git &Commit Tool",
 366                 "Launch the GIT commit tool in the local or chosen directory.",
 367                 build_item, menu_citool },
 368         { MENU_ITEM_TRACK, 0, "Git &History",
 369                 "Show GIT history of the chosen file or directory.",
 370                 build_item,
 371                 menu_history },
 372         { MENU_ITEM_TRACK | MENU_ITEM_FILE, 0, "Git &Blame",
 373                 "Start a blame viewer on the specified file.",
 374                 build_item, menu_blame },
 375
 376         { MENU_ITEM_REPO, 0, "Git &Gui",
 377                 "Launch the GIT Gui in the local or chosen directory.",
 378                 build_item, menu_gui },
 379
 380         { MENU_ITEM_REPO, 0, "Git Bra&nch",
 381                 "Checkout a branch",
 382                 build_branch_menu, NULL },
 383
 384         { MENU_ITEM_NOREPO, 0, "Git I&nit Here",
 385                 "Initialize GIT repo in the local directory.",
 386                 build_item, menu_init },
 387         { MENU_ITEM_NOREPO | MENU_ITEM_DIR, 0, "Git &Gui",
 388                 "Launch the GIT Gui in the local or chosen directory.",
 389                 build_item, menu_gui },
 390
 391         { MENU_ITEM_ALWAYS, 0, "Git Ba&sh",
 392                 "Start GIT shell in the local or chosen directory",
 393                 build_item, menu_bash },
 394         { MENU_ITEM_ALWAYS, 0, NULL, NULL, build_separator, NULL },
 395 };
 396
 397 void build_cheetah_menu(struct git_data *data, void *platform_data)
 398 {
 399         reset_platform(platform_data);
 400         build_menu_items(data, cheetah_menu_mask,
 401                 cheetah_menu,
 402                 sizeof(cheetah_menu) / sizeof(cheetah_menu[0]),
 403                 platform_data);
 404 }