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 void *start_submenu(struct git_data *this_, const struct menu_item *item,
  72                     void *platform)
  73 {
  74         struct windows_menu_data *parent_menu = platform;
  75         struct windows_menu_data *submenu =
  76                 malloc(sizeof(struct windows_menu_data));
  77         submenu->menu = CreateMenu();
  78         InsertMenu(parent_menu->menu, parent_menu->index,
  79                 MF_POPUP | MF_BYPOSITION, (UINT_PTR)(submenu->menu),
  80                 item->string);
  81         parent_menu->index++;
  82
  83         submenu->index = 0;
  84         submenu->first = parent_menu->first;
  85
  86         return submenu;
  87 }
  88
  89 void end_submenu(void *parent, void *submenu)
  90 {
  91         free(submenu);
  92 }
  93
  94 /*
  95  * These are the functions for handling the context menu.
  96  */
  97
  98 inline STDMETHODIMP query_context_menu(void *p, HMENU menu,
  99                                        UINT index, UINT first_command,
 100                                        UINT last_command, UINT flags)
 101 {
 102         struct git_menu *this_menu = p;
 103         struct git_data *this_ = this_menu->git_data;
 104         struct windows_menu_data windows_menu =
 105                 { menu, index, first_command, last_command };
 106
 107         if (flags & CMF_DEFAULTONLY)
 108                 return MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL, 0);
 109
 110         build_cheetah_menu(this_, &windows_menu);
 111
 112         return MAKE_HRESULT(SEVERITY_SUCCESS, FACILITY_NULL,
 113                 next_active_item);
 114 }
 115
 116 /*
 117  * Perform a couple of transformations, such that a directory
 118  *    C:\Program Files\Bunch of stuff\in\A dir
 119  * becomes
 120  *    /C/Program\ Files/Bunch\ of\ stuff/in/A\ dir
 121  *
 122  * Assumes path is initially a correctly formed Windows-style path.
 123  * Returns a new string.
 124  */
 125 static char *convert_directory_format(const char *path)
 126 {
 127         int i;
 128         int size_incr = 0;
 129         char *converted;
 130         char *dst;
 131
 132         /* Figure out how much extra space we need to escape spaces */
 133         for (i = 0; i < MAX_PATH && path[i] != '\0'; ++i)
 134                 if (path[i] == ' ')
 135                         size_incr++;
 136
 137         converted = (char *)calloc(size_incr + i + 1, sizeof(char));
 138         dst = converted;
 139
 140         /* Transform:
 141          * " " -> "\ "
 142          * "\" -> "/"
 143          */
 144         for (i = 0; i < MAX_PATH && path[i] != '\0'; ++i)
 145         {
 146                 switch (path[i])
 147                 {
 148                 case ' ':
 149                         *(dst++) = '\\';
 150                         *(dst++) = ' ';
 151                         break;
 152                 case '\\':
 153                         *(dst++) = '/';
 154                         break;
 155                 default:
 156                         *(dst++) = path[i];
 157                         break;
 158                 }
 159         }
 160         *dst = '\0';
 161
 162         /* X: -> /X */
 163         converted[1] = converted[0];
 164         converted[0] = '/';
 165
 166         return converted;
 167 }
 168
 169 inline STDMETHODIMP invoke_command(void *p,
 170                                    LPCMINVOKECOMMANDINFO info)
 171 {
 172         struct git_menu *this_menu = p;
 173         struct git_data *this_ = this_menu->git_data;
 174         UINT id = LOWORD(info->lpVerb);
 175
 176         if (HIWORD(info->lpVerb))
 177                 return E_INVALIDARG;
 178
 179         handle_menu_item(this_, id);
 180         return S_OK;
 181 }
 182
 183 inline STDMETHODIMP get_command_string(void *p, UINT id,
 184                                        UINT flags, UINT *reserved,
 185                                        LPSTR name, UINT size)
 186 {
 187         const char *text;
 188
 189         if (!(flags & GCS_HELPTEXT))
 190                 return E_INVALIDARG;
 191
 192         text = get_menu_item_text(id);
 193         if (!text)
 194                 return E_INVALIDARG;
 195
 196         if (flags & GCS_UNICODE) {
 197                 size_t len = strlen(text) + 1;
 198                 LPWSTR tw = malloc(len * sizeof(wchar_t));
 199                 /* need to convert terminating NULL as well */
 200                 mbstowcs(tw, text, len);
 201                 lstrcpynW((LPWSTR)name, tw, size);
 202                 free(tw);
 203         } else
 204                 lstrcpynA(name, text, size);
 205
 206         return S_OK;
 207 }
 208
 209 DEFINE_STANDARD_METHODS(git_menu)
 210
 211 struct git_menu_virtual_table git_menu_virtual_table = {
 212         query_interface_git_menu,
 213         add_ref_git_menu,
 214         release_git_menu,
 215         query_context_menu,
 216         invoke_command,
 217         get_command_string
 218 };