menu.c

   1 #include "cache.h"
   2
   3 #include <shlobj.h>
   4 #include <tchar.h>
   5 #include "menuengine.h"
   6 #include "cheetahmenu.h"
   7 #include "menu.h"
   8 #include "ext.h"
   9 #include "debug.h"
  10 #include "systeminfo.h"
  11 #include "exec.h"
  12
  13 #define LONGEST_MENU_ITEM 40
  14
  15 /*
  16  * Windows-specific Cheetah menu functions
  17  */
  18 struct windows_menu_data {
  19         HMENU menu;
  20         UINT index;
  21         UINT first;
  22         UINT last;
  23 };
  24
  25 void reset_platform(void *platform)
  26 {
  27         /* On Windows, we don't do anything to reset the menu */
  28 }
  29
  30 /*
  31  * menu_item_builder to build a Windows-specific menu separator
  32  *
  33  * Always returns FALSE so the menu engine does not track this item
  34  */
  35 BOOL build_separator(struct git_data *data, const struct menu_item *item,
  36                      void *platform)
  37 {
  38         struct windows_menu_data *windows_menu = platform;
  39         InsertMenu(windows_menu->menu, windows_menu->index,
  40                 MF_SEPARATOR | MF_BYPOSITION, 0, "");
  41         windows_menu->index++;
  42
  43         return FALSE;
  44 }
  45
  46 /*
  47  * menu_item_builder to build a simple menu item
  48  *
  49  * Explorer's context menu are limited in the number of comands
  50  * that they can use, so build_item would:
  51  * - do nothing if that limit is reached and return FALSE to
  52  *   instruct the menu engine to not track this item
  53  * - create item and return TRUE, so the item can be handled later
  54  */
  55 BOOL build_item(struct git_data *data, const struct menu_item *item,
  56                 void *platform)
  57 {
  58         struct windows_menu_data *windows_menu = platform;
  59         if (windows_menu->last < windows_menu->first + next_active_item)
  60                 return FALSE;
  61
  62         InsertMenu(windows_menu->menu, windows_menu->index,
  63                 MF_STRING | MF_BYPOSITION,
  64                 windows_menu->first + next_active_item,
  65                 item->string);
  66         windows_menu->index++;
  67
  68         return TRUE;
  69 }
  70
  71 /*
  72  * These are the functions for handling the context menu.
  73  */
  74
  75 inline STDMETHODIMP query_context_menu(void *p, HMENU menu,
  76                                        UINT index, UINT first_command,
  77                                        UINT last_command, UINT flags)
  78 {
  79         struct git_menu *this_menu = p;
  80         struct git_data *this_ = this_menu->git_data;
  81         struct windows_menu_data windows_menu =
  82                 { menu, index, first_command, last_command };
  83
  84         if (flags & CMF_DEFAULTONLY)
  85                 return MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL, 0);
  86
  87         build_cheetah_menu(this_, &windows_menu);
  88
  89         return MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL,
  90                 next_active_item);
  91 }
  92
  93 /*
  94  * Perform a couple of transformations, such that a directory
  95  *    C:\Program Files\Bunch of stuff\in\A dir
  96  * becomes
  97  *    /C/Program\ Files/Bunch\ of\ stuff/in/A\ dir
  98  *
  99  * Assumes path is initially a correctly formed Windows-style path.
 100  * Returns a new string.
 101  */
 102 static char *convert_directory_format(const char *path)
 103 {
 104         int i;
 105         int size_incr = 0;
 106         char *converted;
 107         char *dst;
 108
 109         /* Figure out how much extra space we need to escape spaces */
 110         for (i = 0; i < MAX_PATH && path[i] != '\0'; ++i)
 111                 if (path[i] == ' ')
 112                         size_incr++;
 113
 114         converted = (char *)calloc(size_incr + i + 1, sizeof(char));
 115         dst = converted;
 116
 117         /* Transform:
 118          * " " -> "\ "
 119          * "\" -> "/"
 120          */
 121         for (i = 0; i < MAX_PATH && path[i] != '\0'; ++i)
 122         {
 123                 switch (path[i])
 124                 {
 125                 case ' ':
 126                         *(dst++) = '\\';
 127                         *(dst++) = ' ';
 128                         break;
 129                 case '\\':
 130                         *(dst++) = '/';
 131                         break;
 132                 default:
 133                         *(dst++) = path[i];
 134                         break;
 135                 }
 136         }
 137         *dst = '\0';
 138
 139         /* X: -> /X */
 140         converted[1] = converted[0];
 141         converted[0] = '/';
 142
 143         return converted;
 144 }
 145
 146 inline STDMETHODIMP invoke_command(void *p,
 147                                    LPCMINVOKECOMMANDINFO info)
 148 {
 149         struct git_menu *this_menu = p;
 150         struct git_data *this_ = this_menu->git_data;
 151         UINT id = LOWORD(info->lpVerb);
 152
 153         if (HIWORD(info->lpVerb))
 154                 return E_INVALIDARG;
 155
 156         handle_menu_item(this_, id);
 157         return S_OK;
 158 }
 159
 160 inline STDMETHODIMP get_command_string(void *p, UINT id,
 161                                        UINT flags, UINT *reserved,
 162                                        LPSTR name, UINT size)
 163 {
 164         const char *text;
 165
 166         if (!(flags & GCS_HELPTEXT))
 167                 return E_INVALIDARG;
 168
 169         text = get_menu_item_text(id);
 170         if (!text)
 171                 return E_INVALIDARG;
 172
 173         if (flags & GCS_UNICODE) {
 174                 size_t len = strlen(text) + 1;
 175                 LPWSTR tw = malloc(len * sizeof(wchar_t));
 176                 /* need to convert terminating NULL as well */
 177                 mbstowcs(tw, text, len);
 178                 lstrcpynW((LPWSTR)name, tw, size);
 179                 free(tw);
 180         } else
 181                 lstrcpynA(name, text, size);
 182
 183         return S_OK;
 184 }
 185
 186 DEFINE_STANDARD_METHODS(git_menu)
 187
 188 struct git_menu_virtual_table git_menu_virtual_table = {
 189         query_interface_git_menu,
 190         add_ref_git_menu,
 191         release_git_menu,
 192         query_context_menu,
 193         invoke_command,
 194         get_command_string
 195 };