menu.c

   1 #include "cache.h"
   2
   3 #include <shlobj.h>
   4 #include <tchar.h>
   5 #include "menuengine.h"
   6 #include "menu.h"
   7 #include "ext.h"
   8 #include "debug.h"
   9 #include "systeminfo.h"
  10 #include "exec.h"
  11
  12 #define LONGEST_MENU_ITEM 40
  13
  14 /*
  15  * These are the functions for handling the context menu.
  16  */
  17
  18 static STDMETHODIMP query_context_menu(void *p, HMENU menu,
  19                                        UINT index, UINT first_command,
  20                                        UINT last_command, UINT flags)
  21 {
  22         struct git_menu *this_menu = p;
  23         struct git_data *this_ = this_menu->git_data;
  24         char *wd;
  25         BOOL bDirSelected = TRUE;
  26
  27         UINT original_first = first_command;
  28         char menu_item[LONGEST_MENU_ITEM];
  29
  30         int status;
  31
  32         if (flags & CMF_DEFAULTONLY)
  33                 return MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL, 0);
  34
  35         /* figure out the directory */
  36         wd = strdup(this_->name);
  37         if (!(FILE_ATTRIBUTE_DIRECTORY & GetFileAttributes(wd))) {
  38                 char *c = strrchr(wd, '\\');
  39                 if (c) {
  40                         *c = 0;
  41                         bDirSelected = FALSE;
  42                 }
  43         }
  44
  45         status = exec_program(wd, NULL, NULL, WAITMODE,
  46                 "git", "rev-parse", "--show-cdup", NULL);
  47         free (wd);
  48
  49         /* something really bad happened, could run git */
  50         if (status < 0)
  51                 return MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL, 0);
  52
  53         /*
  54          * TODO: the following big, ugly code needs to be something like
  55          *       build_menu_items()
  56          *       It's left as is to signify the preview nature of the patch
  57          */
  58         if (status) { /* this is not a repository */
  59                 if (bDirSelected)
  60                         strcpy(menu_item, "&Git Clone Here");
  61                 else
  62                         strcpy(menu_item, "&Git Init Here");
  63         } else
  64                 strcpy(menu_item, "&Git");
  65
  66         InsertMenu(menu, index, MF_SEPARATOR | MF_BYPOSITION,
  67                         first_command++, "");
  68         InsertMenu(menu, index+1, MF_STRING | MF_BYPOSITION,
  69                    first_command++, menu_item);
  70
  71         /*
  72          * TODO: when the above block is fixed, we'll just have
  73          *       return MAKE_RESULT(..., build_menu_items());
  74          */
  75         return MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL,
  76                 first_command - original_first);
  77 }
  78
  79 /*
  80  * Perform a couple of transformations, such that a directory
  81  *    C:\Program Files\Bunch of stuff\in\A dir
  82  * becomes
  83  *    /C/Program\ Files/Bunch\ of\ stuff/in/A\ dir
  84  *
  85  * Assumes path is initially a correctly formed Windows-style path.
  86  * Returns a new string.
  87  */
  88 static char *convert_directory_format(const char *path)
  89 {
  90         int i;
  91         int size_incr = 0;
  92         char *converted;
  93         char *dst;
  94
  95         /* Figure out how much extra space we need to escape spaces */
  96         for (i = 0; i < MAX_PATH && path[i] != '\0'; ++i)
  97                 if (path[i] == ' ')
  98                         size_incr++;
  99
 100         converted = (char *)calloc(size_incr + i + 1, sizeof(char));
 101         dst = converted;
 102
 103         /* Transform:
 104          * " " -> "\ "
 105          * "\" -> "/"
 106          */
 107         for (i = 0; i < MAX_PATH && path[i] != '\0'; ++i)
 108         {
 109                 switch (path[i])
 110                 {
 111                 case ' ':
 112                         *(dst++) = '\\';
 113                         *(dst++) = ' ';
 114                         break;
 115                 case '\\':
 116                         *(dst++) = '/';
 117                         break;
 118                 default:
 119                         *(dst++) = path[i];
 120                         break;
 121                 }
 122         }
 123         *dst = '\0';
 124
 125         /* X: -> /X */
 126         converted[1] = converted[0];
 127         converted[0] = '/';
 128
 129         return converted;
 130 }
 131
 132 static STDMETHODIMP invoke_command(void *p,
 133                                    LPCMINVOKECOMMANDINFO info)
 134 {
 135         struct git_menu *this_menu = p;
 136         struct git_data *this_ = this_menu->git_data;
 137         int command = LOWORD(info->lpVerb);
 138
 139         if (HIWORD(info->lpVerb) != 0)
 140                 return E_INVALIDARG;
 141
 142         if (command == 1)
 143         {
 144                 const char *wd;
 145                 DWORD dwAttr, fa;
 146
 147                 wd = this_->name;
 148                 if (wd == NULL || strlen(wd) == 0)
 149                         wd = info->lpDirectory;
 150
 151                 dwAttr = FILE_ATTRIBUTE_DIRECTORY;
 152                 fa = GetFileAttributes(wd);
 153                 if (!(fa & dwAttr))
 154                         wd = info->lpDirectory;
 155
 156                 exec_program(wd, NULL, NULL, NORMALMODE,
 157                         "git", "gui", NULL);
 158
 159                 return S_OK;
 160         }
 161
 162         return E_INVALIDARG;
 163 }
 164
 165 static STDMETHODIMP get_command_string(void *p, UINT id,
 166                                        UINT flags, UINT *reserved,
 167                                        LPSTR name, UINT size)
 168 {
 169
 170         struct git_menu *this_menu = p;
 171         struct git_data *this_ = this_menu->git_data;
 172
 173         if (id != 1)
 174                 return E_INVALIDARG;
 175
 176
 177         if (flags & GCS_HELPTEXT) {
 178                 LPCTSTR text = _T("Launch the GIT Gui in the local or chosen directory.");
 179                 size_t len = strlen(text) + 1;
 180                 LPWSTR tw = malloc(len * sizeof(wchar_t));
 181                 /* need to convert terminating NULL as well */
 182                 mbstowcs(tw, text, len);
 183                 /* use Win32 lstrcpyn to [automatically] avoid buffer overflow */
 184                 if (flags & GCS_UNICODE)
 185                         lstrcpynW((LPWSTR)name, tw, size);
 186                 else
 187                         lstrcpynA(name, text, size);
 188                 free(tw);
 189                 return S_OK;
 190         }
 191
 192
 193         return E_INVALIDARG;
 194 }
 195
 196 DEFINE_STANDARD_METHODS(git_menu)
 197
 198 struct git_menu_virtual_table git_menu_virtual_table = {
 199         query_interface_git_menu,
 200         add_ref_git_menu,
 201         release_git_menu,
 202         query_context_menu,
 203         invoke_command,
 204         get_command_string
 205 };