/[winpt]/trunk/Src/wptKeyManagerDlg.cpp
ViewVC logotype

Diff of /trunk/Src/wptKeyManagerDlg.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 23 by twoaday, Fri Sep 30 10:10:16 2005 UTC revision 128 by twoaday, Mon Dec 19 13:05:59 2005 UTC
# Line 1  Line 1 
1  /* wptKeyManagerDlg.cpp - WinPT Key Manager  /* wptKeyManagerDlg.cpp - WinPT Key Manager
2   *      Copyright (C) 2000-2005 Timo Schulz   *      Copyright (C) 2000-2005 Timo Schulz
3   *      Copyright (C) 2004 Andreas Jobs   *      Copyright (C) 2004 Andreas Jobs
4   *   *
5   * This file is part of WinPT.   * This file is part of WinPT.
6   *   *
7   * WinPT is free software; you can redistribute it and/or modify   * WinPT is free software; you can redistribute it and/or modify
8   * it under the terms of the GNU General Public License as published by   * it under the terms of the GNU General Public License as published by
9   * the Free Software Foundation; either version 2 of the License, or   * the Free Software Foundation; either version 2 of the License, or
10   * (at your option) any later version.   * (at your option) any later version.
11   *   *
12   * WinPT is distributed in the hope that it will be useful,   * WinPT is distributed in the hope that it will be useful,
13   * but WITHOUT ANY WARRANTY; without even the implied warranty of   * but WITHOUT ANY WARRANTY; without even the implied warranty of
14   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15   * GNU General Public License for more details.   * GNU General Public License for more details.
16   *   *
17   * You should have received a copy of the GNU General Public License   * You should have received a copy of the GNU General Public License
18   * along with WinPT; if not, write to the Free Software Foundation,   * along with WinPT; if not, write to the Free Software Foundation,
19   * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA   * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
20   */   */
21    #ifdef HAVE_CONFIG_H
22  #include <windows.h>  #include <config.h>
23  #include <commctrl.h>  #endif
24    
25  #include "../resource.h"  #include <windows.h>
26  #include "wptTypes.h"  #include <commctrl.h>
27  #include "wptGPG.h"  
28  #include "wptCommonCtl.h"  #include "resource.h"
29  #include "wptContext.h" /* for passphrase_s */  #include "wptTypes.h"
30  #include "wptDlgs.h"  #include "wptGPG.h"
31  #include "wptW32API.h"  #include "wptCommonCtl.h"
32  #include "wptVersion.h"  #include "wptContext.h" /* for passphrase_s */
33  #include "wptKeylist.h"  #include "wptDlgs.h"
34  #include "wptNLS.h"  #include "wptW32API.h"
35  #include "wptErrors.h"  #include "wptVersion.h"
36  #include "wptHotkey.h"  #include "wptKeylist.h"
37  #include "wptKeyManager.h"  #include "wptNLS.h"
38  #include "wptKeyserver.h"  #include "wptErrors.h"
39  #include "wptKeyEdit.h"  #include "wptHotkey.h"
40  #include "wptRegistry.h"  #include "wptKeyManager.h"
41    #include "wptKeyserver.h"
42    #include "wptKeyEdit.h"
43  #define WINDOWCLASS_SEPARATOR_CHILD "WINPT_SEP_CHILD"  #include "wptRegistry.h"
44  #define SEPARATOR_HEIGHT            5  
45    /* Name and ID of the separator window. */
46  void km_dump_key (gpgme_key_t key);  #define KM_SEPARATOR_ID                10000
47    #define WINDOWCLASS_SEPARATOR_CHILD "WINPT_SEP_CHILD"
48  //int treeview_add_item (HWND tree, HTREEITEM parent, const char * text);  
49    /* Virtual key codes. */
50  static subclass_s keylist_proc;  #ifndef VK_F
51  static int km_index = -1;  #define VK_F 70
52    #endif
53  HIMAGELIST glob_imagelist;  #ifndef VK_A
54    #define VK_A 65
55  struct km_info {  #endif
56      /* Window positions */  #ifndef VK_C
57      int pos_x, pos_y;  #define VK_C 67
58      int ypos_sep;  #endif
59      int ypercent_sep;  #ifndef VK_P
60    #define VK_P 80
61      HWND hwnd_sep;  #endif
62      HWND toolbar;  
63      HWND statbar;  static subclass_s keylist_proc;
64    
65      listview_ctrl_t lv;  HIMAGELIST glob_imagelist;
66      int keylist_sortby;  
67  };  struct km_info {
68        /* Window positions */
69  struct mybuttons {      int pos_x, pos_y;
70      long icon;      int ypos_sep;
71      long command;      int ypercent_sep;
72      char *text;  
73  };      HWND hwnd_sep;
74        HWND toolbar;
75  struct mybuttons myb[] = {      HWND statbar;
76      {IMI_KEY_DELETE, ID_KEYMISC_DELETE, "Delete"},  
77      {IMI_KEY_PROPS,  ID_KEYMISC_PROPS,  "Properties"},      listview_ctrl_t lv;
78      {IMI_KEY_SIGN,   ID_KEYMISC_SIGN,   "Sign"},      int             lv_idx;
79      {IMI_KEY_IMPORT, ID_KEYMISC_IMPORT, "Import"},      int keylist_sortby;
80      {IMI_KEY_EXPORT, ID_KEYMISC_EXPORT, "Export"},  };
81  };  
82    /* Toolbar button structure. */
83    struct mybuttons {
84  #ifndef VK_F      long icon;
85  #define VK_F 70      long command;
86  #endif      char *text;
87  #ifndef VK_A  };
88  #define VK_A 65  
89  #endif  struct mybuttons myb[] = {
90  #ifndef VK_C      {IMI_KEY_DELETE, ID_KEYMISC_DELETE, "Delete"},
91  #define VK_C 67      {IMI_KEY_PROPS,  ID_KEYMISC_PROPS,  "Properties"},
92  #endif      {IMI_KEY_SIGN,   ID_KEYMISC_SIGN,   "Sign"},
93  #ifndef VK_P      {IMI_KEY_IMPORT, ID_KEYMISC_IMPORT, "Import"},
94  #define VK_P 80      {IMI_KEY_EXPORT, ID_KEYMISC_EXPORT, "Export"},
95  #endif  };
96    
97  static BOOL CALLBACK  
98  keylist_subclass_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)  /* Subclass the keylist listview control to allow extended commands. */
99  {  static BOOL CALLBACK
100      struct listview_ctrl_s lv;  keylist_subclass_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
101    {
102      switch (msg) {      struct listview_ctrl_s lv;
103      case WM_LBUTTONDBLCLK:  
104          send_cmd_id (keylist_proc.dlg, ID_KEYMISC_PROPS);      switch (msg) {
105          break;      case WM_LBUTTONDBLCLK:
106                    send_cmd_id (keylist_proc.dlg, ID_KEYMISC_PROPS);
107      case WM_KEYUP:          break;
108          int virt_key = (int)wparam;          
109          switch (virt_key) {      case WM_KEYUP:
110          case VK_SPACE:          int virt_key = (int)wparam;
111              send_cmd_id( keylist_proc.dlg, ID_KEYMISC_PROPS );          switch (virt_key) {
112              break;          case VK_SPACE:
113                        send_cmd_id (keylist_proc.dlg, ID_KEYMISC_PROPS);
114          case VK_DELETE:              break;
115              send_cmd_id( keylist_proc.dlg, ID_KEYMISC_DELETE );          
116              break;          case VK_DELETE:
117                        send_cmd_id (keylist_proc.dlg, ID_KEYMISC_DELETE);
118          case VK_INSERT:              break;
119              send_cmd_id (keylist_proc.dlg, ID_KEYMISC_PASTE);          
120              break;          case VK_INSERT:
121                send_cmd_id (keylist_proc.dlg, ID_KEYMISC_PASTE);
122          case VK_A:              break;
123              if (GetAsyncKeyState (VK_CONTROL)) {  
124                  lv.ctrl = GetDlgItem (keylist_proc.dlg, IDC_KEYMISC_KEYLIST);          case VK_A:
125                  listview_select_all (&lv);              if (GetAsyncKeyState (VK_CONTROL)) {
126              }                  lv.ctrl = GetDlgItem (keylist_proc.dlg, IDC_KEYMISC_KEYLIST);
127              break;                  listview_select_all (&lv);
128                            }
129          case VK_C:              break;
130              if (GetAsyncKeyState (VK_CONTROL)) {              
131                  lv.ctrl = GetDlgItem (keylist_proc.dlg, IDC_KEYMISC_KEYLIST);          case VK_C:
132                  km_index = listview_get_curr_pos (&lv);              if (GetAsyncKeyState (VK_CONTROL)) {
133                  km_clip_export (keylist_proc.dlg, &lv);                  lv.ctrl = GetDlgItem (keylist_proc.dlg, IDC_KEYMISC_KEYLIST);
134              }                  km_clip_export (keylist_proc.dlg, &lv);
135              break;              }
136                break;
137          case VK_P:  
138              if (GetAsyncKeyState (VK_CONTROL)) {          case VK_P:
139                  km_index = -1;              if (GetAsyncKeyState (VK_CONTROL))          
140                  km_clip_import (keylist_proc.dlg);                  km_clip_import (keylist_proc.dlg);
141              }              break;
142              break;  
143            case VK_F:
144          case VK_F:              if (GetAsyncKeyState (VK_CONTROL)) {
145              if (GetAsyncKeyState (VK_CONTROL)) {                  lv.ctrl = GetDlgItem (keylist_proc.dlg, IDC_KEYMISC_KEYLIST);
146                  lv.ctrl = GetDlgItem (keylist_proc.dlg, IDC_KEYMISC_KEYLIST);                  km_find_key (dlg, &lv);
147                  km_find_key (dlg, &lv);              }
148              }              break;
149              break;          }
150          }          break;
151          break;      }
152      }      
153            return CallWindowProc (keylist_proc.old, dlg, msg, wparam, lparam);
154      return CallWindowProc( keylist_proc.old, dlg, msg, wparam, lparam );  }
155  } /* keylist_subclass_proc */  
156    
157    static HWND
158  static HWND  load_toolbar (HWND dlg, struct km_info *kmi)
159  load_toolbar (HWND dlg, struct km_info * kmi)  {
160  {      HWND tbwnd;
161      HWND tbwnd;      TBSAVEPARAMS tbsp;
162      TBSAVEPARAMS tbsp;      TBBUTTON tb_buttons[] = {
163      TBBUTTON tb_buttons[] = {          /*{imagelist_getindex(IMI_EXIT),       ID_KEYMISC_QUIT,   TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0L, 0},*/
164          /*{imagelist_getindex(IMI_EXIT),       ID_KEYMISC_QUIT,   TBSTATE_ENABLED, TBSTYLE_BUTTON, 0, 0L, 0},*/          {imagelist_getindex(IMI_KEY_DELETE), ID_KEYMISC_DELETE, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0}, 0L, 0},
165          {imagelist_getindex(IMI_KEY_DELETE), ID_KEYMISC_DELETE, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0}, 0L, 0},          {imagelist_getindex(IMI_KEY_PROPS),  ID_KEYMISC_PROPS,  TBSTATE_ENABLED, TBSTYLE_BUTTON, {0}, 0L, 0},
166          {imagelist_getindex(IMI_KEY_PROPS),  ID_KEYMISC_PROPS,  TBSTATE_ENABLED, TBSTYLE_BUTTON, {0}, 0L, 0},          {imagelist_getindex(IMI_KEY_SIGN),   ID_KEYMISC_SIGN,   TBSTATE_ENABLED, TBSTYLE_BUTTON, {0}, 0L, 0},
167          {imagelist_getindex(IMI_KEY_SIGN),   ID_KEYMISC_SIGN,   TBSTATE_ENABLED, TBSTYLE_BUTTON, {0}, 0L, 0},          {0,                                  0,                 0,               TBSTYLE_SEP,    {0}, 0L, 0},
168          {0,                                  0,                 0,               TBSTYLE_SEP,    {0}, 0L, 0},          {imagelist_getindex(IMI_KEY_IMPORT), ID_KEYMISC_IMPORT, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0}, 0L, 0},
169          {imagelist_getindex(IMI_KEY_IMPORT), ID_KEYMISC_IMPORT, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0}, 0L, 0},          {imagelist_getindex(IMI_KEY_EXPORT), ID_KEYMISC_EXPORT, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0}, 0L, 0},
170          {imagelist_getindex(IMI_KEY_EXPORT), ID_KEYMISC_EXPORT, TBSTATE_ENABLED, TBSTYLE_BUTTON, {0}, 0L, 0},       };
171       };      
172            tbwnd = CreateWindowEx (0, TOOLBARCLASSNAME, NULL,
173      tbwnd = CreateWindowEx (0, TOOLBARCLASSNAME, NULL,                              WS_CHILD|TBSTYLE_TOOLTIPS|TBSTYLE_FLAT|CCS_ADJUSTABLE,
174                              WS_CHILD|TBSTYLE_TOOLTIPS|TBSTYLE_FLAT|CCS_ADJUSTABLE,                              0, 0, 0, 0, dlg, (HMENU)IDR_WINPT_KMTB, glob_hinst, NULL);
175                              0, 0, 0, 0, dlg, (HMENU)IDR_WINPT_KMTB, glob_hinst, NULL);      if (tbwnd) {
176      if (tbwnd) {          SendMessage (tbwnd, TB_BUTTONSTRUCTSIZE, (WPARAM) sizeof(TBBUTTON), 0);
177          SendMessage (tbwnd, TB_BUTTONSTRUCTSIZE, (WPARAM) sizeof(TBBUTTON), 0);          SendMessage (tbwnd, TB_SETIMAGELIST, 0, (LPARAM)glob_imagelist);
178          SendMessage (tbwnd, TB_SETIMAGELIST, 0, (LPARAM)glob_imagelist);                  SendMessage (tbwnd, TB_AUTOSIZE, 0, 0);
179                  SendMessage (tbwnd, TB_AUTOSIZE, 0, 0);          ShowWindow (tbwnd, SW_SHOW);
180          ShowWindow (tbwnd, SW_SHOW);  
181            /* Restore toolbar */
182          /* Restore toolbar */          tbsp.hkr = HKEY_CURRENT_USER;
183          tbsp.hkr = HKEY_CURRENT_USER;          tbsp.pszSubKey = "Software\\WinPT";
184          tbsp.pszSubKey = "Software\\WinPT";          tbsp.pszValueName = "KM_toolbar";
185          tbsp.pszValueName = "KM_toolbar";          if (SendMessage(tbwnd, TB_SAVERESTORE, FALSE, (LPARAM)&tbsp ) == 0)
186          if (SendMessage(tbwnd, TB_SAVERESTORE, FALSE, (LPARAM)&tbsp ) == 0)              SendMessage (tbwnd, TB_ADDBUTTONS, sizeof(tb_buttons) / sizeof(tb_buttons[0]),
187              SendMessage (tbwnd, TB_ADDBUTTONS, sizeof(tb_buttons) / sizeof(tb_buttons[0]), (LONG)&tb_buttons[0]);                           (LONG)&tb_buttons[0]);
188       }       }
189       return tbwnd;       return tbwnd;
190  } /* load_toolbar */  }
191    
192    
193  static void  /* Restore the width of the columns from the registry.
194  do_center_window (HWND dlg, struct km_info * kmi)     If no bitstring was found, the default size is used. */
195  {  int
196      RECT rect;  restore_column_size (listview_ctrl_t hd)
197      char * p;  {
198      int pos_x = 0, pos_y = 0;      WORD *buf;
199                HKEY root;
200      /* Find bottom of keylist */      DWORD type;
201      GetWindowRect (GetDlgItem(dlg, IDC_KEYMISC_KEYLIST), &rect);      DWORD size = hd->cols*sizeof (WORD), i;
202      MapWindowPoints (NULL, dlg, (POINT*)&rect, 2);      LONG ec;
203    
204      kmi->ypos_sep = rect.bottom;      ec = RegOpenKeyEx (HKEY_CURRENT_USER, "Software\\WinPT", 0,
205                           KEY_ALL_ACCESS, &root);
206      p = get_reg_entry( HKEY_CURRENT_USER, "Software\\WinPT", "KM_Pos_X" );      if (ec != ERROR_SUCCESS)
207      if( p && !strcmp( p, " " ) ) {          return -1;
208          free_if_alloc( p );      
209          center_window( dlg, NULL );      buf = new WORD[size/2];
210          return;      if (!buf)
211      }          BUG (NULL);
212      else if( p )      ec = RegQueryValueEx (root, "KMColumnSize", NULL, &type,
213          pos_x = atol( p );                            (BYTE*)buf, &size);
214        RegCloseKey (root);
215      p = get_reg_entry( HKEY_CURRENT_USER, "Software\\WinPT", "KM_Pos_Y" );      if (ec != ERROR_SUCCESS) {
216      if( p && !strcmp( p, " " ) ) {          free_if_alloc (buf);
217          free_if_alloc( p );          return -1;
218          center_window( dlg, NULL );      }
219          return;  
220      }      /* check for garbled values. */
221      else if( p )      for (i=0; i < size/2; i++) {
222          pos_y = atol( p );          if (buf[i] > 512) {
223                free_if_alloc (buf);
224      if( !pos_y && !pos_x ) {              return -1;
225          center_window( dlg, NULL );          }
226          return;      }
227      }      for (i=0; i < size/2; i++) {
228                LVCOLUMN lvc;
229      if( pos_x > GetSystemMetrics( SM_CXSCREEN )  
230          || pos_y > GetSystemMetrics( SM_CYSCREEN ) ) {          memset (&lvc, 0, sizeof (lvc));
231          pos_x = pos_y = 0;          lvc.mask = LVCF_WIDTH;
232      }          lvc.cx = buf[i];
233      GetClientRect( dlg, &rect );          ListView_SetColumn (hd->ctrl, i, &lvc);
234      MoveWindow( dlg, pos_x, pos_y, rect.right, rect.bottom, TRUE );      }
235  }      free_if_alloc (buf);
236        return 0;
237    }
238  static void  
239  do_resize_window( HWND dlg, struct km_info *kmi)  
240  {  /* Save the current column width to the registry. */
241      HWND h;  int
242      RECT rclient, rect;  save_column_size (listview_ctrl_t hd)
243      BOOL bRepaint = FALSE;  {
244        WORD *buf;
245      /* Get rect of client area and make life easier */      HKEY root;
246      GetClientRect( dlg, &rclient );      LONG ec;
247        int i;
248      /* Move toolbar to the top of the window */  
249      if (kmi->toolbar) {      buf = new WORD[hd->cols];
250          GetWindowRect(kmi->toolbar, &rect);      if (!buf)
251          ScreenToClient(dlg, (POINT*)&rect);          BUG (NULL);
252          ScreenToClient(dlg, (POINT*)&(rect.right));      for (i=0; i < hd->cols; i++) {
253            LVCOLUMN lvc;
254          rclient.top += rect.bottom - rect.top;  
255          MoveWindow (kmi->toolbar, 0, 0, rclient.right - rclient.left,          memset (&lvc, 0, sizeof (lvc));
256                      rect.bottom - rect.top, bRepaint);          lvc.mask = LVCF_WIDTH;
257      }          ListView_GetColumn (hd->ctrl, i, &lvc);
258            buf[i] = lvc.cx;
259      /* Move statusbar to the bottom of the window */      }
260      if (kmi->statbar) {  
261          GetWindowRect( kmi->statbar, &rect );      ec = RegOpenKeyEx (HKEY_CURRENT_USER, "Software\\WinPT", 0,
262          ScreenToClient(dlg, (POINT*)&rect);                         KEY_ALL_ACCESS, &root);
263          ScreenToClient(dlg, (POINT*)&(rect.right));      if (ec != ERROR_SUCCESS) {
264            free_if_alloc (buf);
265          rclient.bottom -= rect.bottom - rect.top;          return -1;
266          MoveWindow (kmi->statbar, 0, rclient.bottom, rclient.right - rclient.left,      }
267                      rect.bottom - rect.top, bRepaint);  
268      }      ec = RegSetValueEx (root, "KMColumnSize", 0, REG_BINARY,
269                            (const BYTE*)buf, 2*hd->cols);
270      // Obtain separator information and move it to the desired posistion      RegCloseKey (root);
271      if (kmi->ypercent_sep)      free_if_alloc (buf);
272          kmi->ypos_sep = (rclient.bottom - rclient.top) * kmi->ypercent_sep / 100;      return ec == ERROR_SUCCESS? 0 : -1;
273      else  }
274          kmi->ypercent_sep = kmi->ypos_sep * 100 / (rclient.bottom - rclient.top);  
275            
276      // Don't move away  /* Center window @dlg. */
277      if (kmi->ypos_sep+5 > rclient.bottom)  static void
278          kmi->ypos_sep = rclient.bottom - 5;  do_center_window (HWND dlg, struct km_info *kmi)
279      if (kmi->ypos_sep < rclient.top)  {
280          kmi->ypos_sep = rclient.top;      RECT rect;
281      MoveWindow (kmi->hwnd_sep, 0, kmi->ypos_sep, (rclient.right - rclient.left), 5, bRepaint);      char *p;
282                int pos_x = 0;
283      // Place the keylist above the separator      int pos_y = 0;
284      h = GetDlgItem( dlg, IDC_KEYMISC_KEYLIST );          
285      MoveWindow (h, rclient.left, rclient.top, rclient.right - rclient.left,      /* Find bottom of keylist */
286                  kmi->ypos_sep - rclient.top, bRepaint);      GetWindowRect (GetDlgItem(dlg, IDC_KEYMISC_KEYLIST), &rect);
287      rclient.top = kmi->ypos_sep + 5 + 8;      MapWindowPoints (NULL, dlg, (POINT*)&rect, 2);
288    
289      /* Place the group text and the group box below the separator */      kmi->ypos_sep = rect.bottom;
290      h = GetDlgItem( dlg, IDC_KEYMISC_GTEXT );  
291      MoveWindow( h, rclient.left, rclient.top, 100, 14, bRepaint);      p = get_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "KM_Pos_X");
292      rclient.top += 18;      if (p && !strcmp (p, " ")) {
293            free_if_alloc (p);      
294      h = GetDlgItem( dlg, IDC_KEYMISC_GROUP );          center_window (dlg, NULL);
295      MoveWindow (h, rclient.left, rclient.top, rclient.right - rclient.left,          return;
296                  (rclient.bottom < rclient.top) ? 0 : rclient.bottom - rclient.top, bRepaint);      }
297            else if (p)
298      /* Repaint the whole thing */          pos_x = atol (p);
299      InvalidateRect (dlg, NULL, TRUE);  
300  } /* do_resize_window */      p = get_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "KM_Pos_Y");
301        if (p && !strcmp (p, " ")) {
302            free_if_alloc (p);
303  static void          center_window (dlg, NULL);
304  do_create_minpopup (HWND dlg)          return;
305  {      }
306      HMENU hm;      else if (p)
307      MENUITEMINFO mi;          pos_y = atol (p);
308      char * s;  
309      POINT p;      if (!pos_y && !pos_x) {
310                center_window (dlg, NULL);
311      if (gpg_read_only)          return;
312          return;      }
313      hm = CreatePopupMenu ();      
314      if (!hm)      if (pos_x < 0 || pos_y < 0)
315          BUG( NULL );          pos_x = pos_y = 0;
316      memset (&mi, 0, sizeof mi);      if (pos_x > GetSystemMetrics (SM_CXSCREEN)
317      mi.cbSize = sizeof mi;          || pos_y > GetSystemMetrics (SM_CYSCREEN)) {
318      s = (char *)_("Paste Key from Clipboard");          pos_x = pos_y = 0;
319      mi.fType = MF_STRING;      }
320      mi.dwTypeData = s;      GetClientRect (dlg, &rect);
321      mi.cch = strlen (s);      MoveWindow (dlg, pos_x, pos_y, rect.right, rect.bottom, TRUE);
322      mi.fMask = MIIM_DATA | MIIM_ID | MIIM_TYPE;  }
323      mi.wID = ID_KEYCTX_PASTE;  
324      InsertMenuItem (hm, 0, FALSE, &mi);  
325      GetCursorPos (&p);  /* Resize the key manager window with the information from @kmi. */
326      TrackPopupMenu (hm, 0, p.x, p.y, 0, dlg, NULL);  static void
327      DestroyMenu (hm);  do_resize_window (HWND dlg, struct km_info *kmi)
328  } /* do_create_minpopup */  {
329        HWND h;
330        RECT rclient, rect;
331  static void      BOOL bRepaint = FALSE;
332  do_check_cache( listview_ctrl_t lv, HWND dlg, HWND sb  )  
333  {      /* Get rect of client area and make life easier */
334      gpgme_keycache_t cache;      GetClientRect (dlg, &rclient);
335    
336      if( keycache_get_reload( ) ) {      /* Move toolbar to the top of the window */
337          keycache_reload( dlg );      if (kmi->toolbar) {
338          keycache_set_reload( 0 );          GetWindowRect (kmi->toolbar, &rect);
339          cache = keycache_get_ctx( 1 );          ScreenToClient (dlg, (POINT*)&rect);
340          if( !cache )          ScreenToClient (dlg, (POINT*)&(rect.right));
341              BUG( dlg );  
342          keylist_reload( lv, cache, KEYLIST_LIST, KEY_SORT_USERID );          rclient.top += rect.bottom - rect.top;
343          km_complete_status_bar (sb, lv);          MoveWindow (kmi->toolbar, 0, 0, rclient.right - rclient.left,
344      }                      rect.bottom - rect.top, bRepaint);
345  } /* do_check_cache */      }
346    
347        /* Move statusbar to the bottom of the window */
348  long CALLBACK      if (kmi->statbar) {
349  separator_wnd_proc( HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam )          GetWindowRect (kmi->statbar, &rect);
350  {          ScreenToClient (dlg, (POINT*)&rect);
351      static POINT last_mouse_pos;          ScreenToClient (dlg, (POINT*)&(rect.right));
352    
353      if (msg == WM_CREATE)          rclient.bottom -= rect.bottom - rect.top;
354          SetWindowLong (hwnd, GWL_USERDATA, (long)(((CREATESTRUCT*)lparam)->lpCreateParams));          MoveWindow (kmi->statbar, 0, rclient.bottom,
355                        rclient.right - rclient.left,
356      switch (msg) {                      rect.bottom - rect.top, bRepaint);
357      case WM_PAINT:      }
358          PAINTSTRUCT ps;  
359          RECT rect;      /* Obtain separator information and move it to the desired posistion */
360          HPEN hpen;      if (kmi->ypercent_sep)
361            kmi->ypos_sep = (rclient.bottom - rclient.top) * kmi->ypercent_sep / 100;
362          GetClientRect (hwnd, &rect);      else
363          BeginPaint (hwnd, &ps);          kmi->ypercent_sep = kmi->ypos_sep * 100 / (rclient.bottom - rclient.top);
364            
365          // Background      /* Don't move away */
366          FillRect (ps.hdc, &rect, (HBRUSH)(COLOR_3DFACE+1));      if (kmi->ypos_sep+5 > rclient.bottom)
367            kmi->ypos_sep = rclient.bottom - 5;
368          // The lines from the light into the dark      if (kmi->ypos_sep < rclient.top)
369          MoveToEx(ps.hdc, 0,0, NULL);          kmi->ypos_sep = rclient.top;
370          if ((hpen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_3DHILIGHT))) != NULL) {      MoveWindow (kmi->hwnd_sep, 0, kmi->ypos_sep,
371              SelectObject(ps.hdc, (LPVOID)hpen);                  (rclient.right - rclient.left), 5, bRepaint);
372              LineTo(ps.hdc, rect.right, 0);          
373              DeleteObject(hpen);      /* Place the keylist above the separator */
374          }      h = GetDlgItem (dlg, IDC_KEYMISC_KEYLIST);
375          MoveToEx(ps.hdc, 0, 1, NULL);      MoveWindow (h, rclient.left, rclient.top, rclient.right - rclient.left,
376          if ((hpen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_3DLIGHT))) != NULL) {                  kmi->ypos_sep - rclient.top, bRepaint);
377               SelectObject(ps.hdc, (LPVOID)hpen);      rclient.top = kmi->ypos_sep + 5 + 8;
378               LineTo(ps.hdc, rect.right, rect.bottom);  
379               DeleteObject(hpen);      /* Place the group text and the group box below the separator */
380           }      h = GetDlgItem (dlg, IDC_KEYMISC_GTEXT);
381        MoveWindow (h, rclient.left, rclient.top, 100, 14, bRepaint);
382          MoveToEx(ps.hdc, 0, rect.bottom-1, NULL);      rclient.top += 18;
383          if ((hpen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_3DSHADOW))) != NULL) {  
384              SelectObject(ps.hdc, (LPVOID)hpen);      h = GetDlgItem (dlg, IDC_KEYMISC_GROUP);
385              LineTo(ps.hdc, rect.right, rect.bottom-1);      MoveWindow (h, rclient.left, rclient.top, rclient.right - rclient.left,
386              DeleteObject(hpen);                  (rclient.bottom < rclient.top) ?
387          }                  0 : rclient.bottom - rclient.top, bRepaint);
388          MoveToEx(ps.hdc, 0, rect.bottom, NULL);      
389          if ((hpen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_3DDKSHADOW))) != NULL) {      /* Repaint the whole thing */
390              SelectObject(ps.hdc, (LPVOID)hpen);      InvalidateRect (dlg, NULL, TRUE);
391              LineTo(ps.hdc, rect.right, rect.bottom);  }
392              DeleteObject(hpen);  
393          }  
394    /* Return true if the clipboard contains an OpenPGP key. */
395          EndPaint (hwnd, &ps);  static bool
396          return 0;  clip_contains_pgpkey (void)
397    {
398      case WM_LBUTTONDOWN:      char *ctxt;
399          last_mouse_pos.x = LOWORD(lparam);      bool val = false;
400          last_mouse_pos.y = HIWORD(lparam);  
401          ClientToScreen (hwnd, &last_mouse_pos);      ctxt = get_clip_text (NULL);
402          SetCapture (hwnd);      if (!ctxt || strlen (ctxt) < 512)
403          return 0;          val = false;
404        else if (strstr (ctxt, "BEGIN PGP") && strstr (ctxt, "KEY BLOCK") &&
405      case WM_LBUTTONUP:               strstr (ctxt, "END PGP"))
406          ReleaseCapture ();          val = true;
407          return 0;      free_if_alloc (ctxt);
408        return val;
409      case WM_MOUSEMOVE:  }
410          if (wparam == MK_LBUTTON) {  
411              struct km_info *kmi;  
412              POINT p;  /* Show a mini popup menu to import keys. */
413              RECT rect;  static void
414    do_create_minpopup (HWND dlg)
415              if ((kmi = (struct km_info *)GetWindowLong (hwnd, GWL_USERDATA)) == NULL)  {
416                  break;      HMENU hm;
417        MENUITEMINFO mi;
418              // Calculate mouse movement      char * s;
419              p.x = LOWORD(lparam);      POINT p;
420              p.y = HIWORD(lparam);      
421              ClientToScreen (hwnd, &p);      if (gpg_read_only || !clip_contains_pgpkey ())
422            return;
423              GetWindowRect (hwnd, &rect);      hm = CreatePopupMenu ();
424              rect.top += (short)(p.y - last_mouse_pos.y);      if (!hm)
425              rect.bottom += (short)(p.y - last_mouse_pos.y);          BUG( NULL );
426        memset (&mi, 0, sizeof mi);
427              last_mouse_pos.y = p.y;      mi.cbSize = sizeof mi;
428        s = (char *)_("Paste Key from Clipboard");
429              // Apply mouse movement to window. Beware the MoveWindow is relaive      mi.fType = MF_STRING;
430              // to parent NOT screen      mi.dwTypeData = s;
431              MapWindowPoints (NULL, GetParent(hwnd), (POINT*)&rect, 2);      mi.cch = strlen (s);
432              kmi->ypos_sep = rect.top;      mi.fMask = MIIM_DATA | MIIM_ID | MIIM_TYPE;
433              kmi->ypercent_sep = 0; // This forces do_resize_window to use abs. position      mi.wID = ID_KEYCTX_PASTE;
434              do_resize_window (GetParent(hwnd), kmi);      InsertMenuItem (hm, 0, FALSE, &mi);
435              return 0;      GetCursorPos (&p);
436          }      TrackPopupMenu (hm, 0, p.x, p.y, 0, dlg, NULL);
437      }      DestroyMenu (hm);
438    }
439      return DefWindowProc (hwnd, msg, wparam, lparam);  
440  }  
441    /* Reload the key cache if requested. */
442    static void
443  static HWND  do_check_cache (listview_ctrl_t lv, HWND dlg, HWND sb)
444  regist_sep_wnd (HWND dlg, struct km_info * kmi)  {
445  {      gpg_keycache_t cache;
446      WNDCLASS wndclass;  
447      HWND h;      if (keycache_get_reload ()) {
448            keycache_reload (dlg);
449      wndclass.style         = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;          keycache_set_reload (0);
450      wndclass.lpfnWndProc   = separator_wnd_proc;          cache = keycache_get_ctx (1);
451      wndclass.cbClsExtra    = 0;          if (!cache)
452      wndclass.cbWndExtra    = sizeof (long);              BUG (dlg);
453      wndclass.hInstance     = glob_hinst;          keylist_reload (lv, cache, KEYLIST_LIST, KEY_SORT_USERID);
454      wndclass.hIcon         = NULL;          km_update_status_bar (sb, lv);
455      wndclass.hCursor       = LoadCursor (NULL, IDC_SIZENS);      }
456      wndclass.hbrBackground = (HBRUSH) GetStockObject (LTGRAY_BRUSH);  }
457      wndclass.lpszMenuName  = 0;  
458      wndclass.lpszClassName = WINDOWCLASS_SEPARATOR_CHILD;  
459      RegisterClass (&wndclass);  long CALLBACK
460    separator_wnd_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
461      h = CreateWindowEx (WS_EX_WINDOWEDGE, WINDOWCLASS_SEPARATOR_CHILD, NULL,  {
462                          WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE,      static POINT last_mouse_pos;
463                          0, 400, 2000, 5, dlg, (HMENU) 0, glob_hinst, kmi);      
464      ShowWindow (h, SW_SHOW);      if (msg == WM_CREATE)
465      return h;          SetWindowLong (hwnd, GWL_USERDATA,
466  } /* regist_sep_wnd */                         (long)(((CREATESTRUCT*)lparam)->lpCreateParams));
467    
468        switch (msg) {
469        case WM_PAINT:
470  #define enable_button(hwnd, cid) \          PAINTSTRUCT ps;
471      SendMessage ((hwnd), TB_ENABLEBUTTON, (cid), MAKELONG (key_selected, 0))          RECT rect;
472            HPEN hpen;
473  void  
474  update_ui_items (HWND hwnd, listview_ctrl_t lv)          GetClientRect (hwnd, &rect);
475  {          BeginPaint (hwnd, &ps);
476      int key_selected = 0, key_has_sec = 0;  
477      int i, key_inv = 0;          /* Background */
478      HWND hwnd_child;          FillRect (ps.hdc, &rect, (HBRUSH)(COLOR_3DFACE+1));
479      HMENU hmenu;  
480                /* The lines from the light into the dark */
481      /* Get some states */          MoveToEx(ps.hdc, 0,0, NULL);
482      key_selected = SendMessage (GetDlgItem (hwnd, IDC_KEYMISC_KEYLIST),          if ((hpen = CreatePen (PS_SOLID, 0, GetSysColor(COLOR_3DHILIGHT))) != NULL) {
483                                             LVM_GETSELECTEDCOUNT, 0, 0)              SelectObject (ps.hdc, (LPVOID)hpen);
484                                             ? TRUE : FALSE;              LineTo (ps.hdc, rect.right, 0);
485      key_has_sec = FALSE;              DeleteObject (hpen);
486      if (key_selected) {          }
487          i = listview_get_curr_pos (lv);          MoveToEx(ps.hdc, 0, 1, NULL);
488          key_has_sec = km_check_for_seckey( lv, i, NULL ) ? TRUE : FALSE;                  if ((hpen = CreatePen (PS_SOLID, 0, GetSysColor(COLOR_3DLIGHT))) != NULL) {
489          key_inv = km_get_key_status (lv, i) & KM_FLAG_REVOKED;               SelectObject (ps.hdc, (LPVOID)hpen);
490      }               LineTo (ps.hdc, rect.right, rect.bottom);
491                 DeleteObject (hpen);
492      /* Enable / disable toolbar buttons */           }
493      hwnd_child = GetDlgItem(hwnd, IDR_WINPT_KMTB);  
494      enable_button (hwnd_child, ID_KEYMISC_DELETE);          MoveToEx(ps.hdc, 0, rect.bottom-1, NULL);
495      enable_button (hwnd_child, ID_KEYMISC_PROPS);          if ((hpen = CreatePen (PS_SOLID, 0, GetSysColor(COLOR_3DSHADOW))) != NULL) {
496      enable_button (hwnd_child, ID_KEYMISC_SIGN);              SelectObject (ps.hdc, (LPVOID)hpen);
497      enable_button (hwnd_child, ID_KEYMISC_EXPORT);              LineTo (ps.hdc, rect.right, rect.bottom-1);
498                DeleteObject (hpen);
499      /* Enable / disable menu items */          }
500      hmenu = GetMenu (hwnd);          MoveToEx(ps.hdc, 0, rect.bottom, NULL);
501      set_menu_state (hmenu, ID_KEYMISC_EXPORT, key_selected ? MF_ENABLED : MF_GRAYED);          if ((hpen = CreatePen(PS_SOLID, 0, GetSysColor(COLOR_3DDKSHADOW))) != NULL) {
502      set_menu_state (hmenu, ID_KEYMISC_EXPORT_PRIVKEY, key_has_sec ? MF_ENABLED : MF_GRAYED);              SelectObject (ps.hdc, (LPVOID)hpen);
503      set_menu_state (hmenu, ID_KEYMISC_REVCERT, key_has_sec ? MF_ENABLED : MF_GRAYED);              LineTo (ps.hdc, rect.right, rect.bottom);
504      set_menu_state (hmenu, ID_KEYMISC_DELETE, key_selected ? MF_ENABLED : MF_GRAYED);              DeleteObject (hpen);
505      set_menu_state (hmenu, ID_KEYMISC_PROPS, key_selected ? MF_ENABLED : MF_GRAYED);          }
506      set_menu_state (hmenu, ID_KEYMISC_SIGN, key_selected && !key_inv ? MF_ENABLED : MF_GRAYED);      
507  } /* update_ui_items */          EndPaint (hwnd, &ps);
508            return 0;
509    
510  static void      case WM_LBUTTONDOWN:
511  popup_gpg_readonly (HWND dlg, HMENU hm)          last_mouse_pos.x = LOWORD (lparam);
512  {          last_mouse_pos.y = HIWORD (lparam);
513      int resids[] = {          ClientToScreen (hwnd, &last_mouse_pos);
514          ID_KEYCTX_PASTE,          SetCapture (hwnd);
515          ID_KEYCTX_EDIT,          return 0;
516          ID_KEYCTX_SIGN,  
517          ID_KEYCTX_REV,      case WM_LBUTTONUP:
518          ID_KEYCTX_DEL,          ReleaseCapture ();
519          ID_KEYCTX_ENABLE,          return 0;
520          ID_KEYCTX_DISABLE,  
521          ID_KEYCTX_RECVFROM,      case WM_MOUSEMOVE:
522          ID_KEYCTX_ADDKEY,          if (wparam == MK_LBUTTON) {
523          ID_KEYCTX_ADDPHOTO,              struct km_info *kmi;
524          ID_KEYCTX_ADDUID,              POINT p;
525          ID_KEYCTX_ADDREV,              RECT r;
526          0  
527      };              kmi = (struct km_info *)GetWindowLong (hwnd, GWL_USERDATA);
528      int i;              if (kmi == NULL)
529                    break;
530      if (gpg_read_only == 0)  
531          return;              /* Calculate mouse movement */
532      for (i=0; resids[i] != 0; i++)              p.x = LOWORD(lparam);
533          set_menu_state (hm, resids[i], MF_GRAYED);              p.y = HIWORD(lparam);
534  }              ClientToScreen (hwnd, &p);
535    
536                GetWindowRect (hwnd, &r);
537  static void              r.top += (short)(p.y - last_mouse_pos.y);
538  menu_gpg_readonly (HWND dlg, HMENU hm, int id)              r.bottom += (short)(p.y - last_mouse_pos.y);
539  {  
540      int key_resids[] = {              last_mouse_pos.y = p.y;
541          ID_KEYMISC_SIGN,  
542          ID_KEYMISC_DELETE,              /* Apply mouse movement to window. Beware the MoveWindow is relaive
543          ID_KEYMISC_REVCERT,                 to parent NOT screen */
544          ID_KEYMISC_IMPORT_HTTP,              MapWindowPoints (NULL, GetParent(hwnd), (POINT*)&r, 2);
545          ID_KEYMISC_IMPORT,              kmi->ypos_sep = r.top;
546          ID_KEYMISC_REFRESH_KEYS,              kmi->ypercent_sep = 0; /* This forces do_resize_window to use abs. position */
547          ID_KEYMISC_REBUILD,              do_resize_window (GetParent(hwnd), kmi);
548          ID_KEYMISC_KEYWIZARD,              return 0;
549          ID_KEYMISC_CARDNEW,          }
550          ID_KEYMISC_NEWKEY,      }
551          0,  
552      };      return DefWindowProc (hwnd, msg, wparam, lparam);
553      int edit_resids[] = {  }
554          ID_KEYMISC_PASTE,  
555          ID_KEYMISC_OT,  
556          ID_KEYMISC_EDITKEY,  /* Register the separator window with @dlg as the parent window. */
557          0  static HWND
558      };  regist_sep_wnd (HWND dlg, struct km_info * kmi)
559      int * resids;  {
560      int i;      WNDCLASS wndclass;
561        HWND h;
562        
563      if (gpg_read_only == 0)      wndclass.style         = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
564          return;      wndclass.lpfnWndProc   = separator_wnd_proc;
565      switch (id) {      wndclass.cbClsExtra    = 0;
566      case 0: return;      wndclass.cbWndExtra    = sizeof (long);
567      case 3: resids = key_resids; break;      wndclass.hInstance     = glob_hinst;
568      case 1: resids = edit_resids;break;      wndclass.hIcon         = NULL;
569      }      wndclass.hCursor       = LoadCursor (NULL, IDC_SIZENS);
570        wndclass.hbrBackground = (HBRUSH) GetStockObject (LTGRAY_BRUSH);
571      for (i=0; resids[i] != 0; i++)      wndclass.lpszMenuName  = 0;
572          set_menu_state (hm, resids[i], MF_GRAYED);      wndclass.lpszClassName = WINDOWCLASS_SEPARATOR_CHILD;
573  }      RegisterClass (&wndclass);
574    
575        h = CreateWindowEx (WS_EX_WINDOWEDGE, WINDOWCLASS_SEPARATOR_CHILD, NULL,
576  static char*                          WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE,
577  gen_export_filename (const char *keyid)                          0, 400, 2000, 5, dlg, (HMENU) 0, glob_hinst, kmi);    
578  {      ShowWindow (h, SW_SHOW);
579      gpgme_key_t key;      return h;
580      const char *s;  }
581      char *p;  
582    
583      if (get_pubkey (keyid, &key))  #define enable_button(hwnd, cid) \
584          return m_strdup (keyid);      SendMessage ((hwnd), TB_ENABLEBUTTON, (cid), MAKELONG (key_selected, 0))
585      s = key->uids->name;  
586      if (!s)  
587          return m_strdup (keyid);  /* Interactive modification of the dialog item which depend if an item
588      p = new char[strlen (s) + 8];     is selected or not and what kind of item. @lv is the list view with
589      if (!p)     the items. */
590          BUG (0);  void
591      sprintf (p, "%s.asc", s);  update_ui_items (HWND hwnd, listview_ctrl_t lv)
592      for (size_t i=0; i < strlen (p); i++) {  {
593          if (p[i] == ' ' || p[i] == ':' || p[i] == '?' || p[i] == '|')      HWND hwnd_child;
594              p[i] = '_';      HMENU hmenu;
595      }      int key_selected = 0;
596      return p;      int key_has_sec = 0;
597  }      int key_inv = 0;
598        int mult_resids[] = {ID_KEYMISC_PROPS, ID_KEYMISC_SIGN, ID_KEYMISC_EDITKEY,
599                             ID_KEYMISC_CHECKSIGS, ID_KEYMISC_REVCERT, 0};
600  static void      int i, state=0;
601  update_key (listview_ctrl_t lv, int pos, const char *keyid, int keypair)      
602  {      /* Get some states */
603      gpgme_key_t key;      key_selected = SendMessage (GetDlgItem (hwnd, IDC_KEYMISC_KEYLIST),
604                                               LVM_GETSELECTEDCOUNT, 0, 0)
605      keycache_update (0, keyid);                                             ? TRUE : FALSE;
606      if (keypair)      key_has_sec = FALSE;
607          keycache_update (1, keyid);      if (key_selected) {
608            i = listview_get_curr_pos (lv);
609      /* because we replaced the key item, we need to update the          key_has_sec = km_check_for_seckey (lv, i, NULL) ? TRUE : FALSE;
610         address of the pointer in the ListView control. */          key_inv = km_get_key_status (lv, i) & KM_FLAG_REVOKED ||
611      get_pubkey (keyid, &key);                    km_get_key_status (lv, i) & KM_FLAG_EXPIRED;
612      keylist_upd_key (lv, pos, key);      }
613  }  
614        /* Enable / disable toolbar buttons */
615        hwnd_child = GetDlgItem (hwnd, IDR_WINPT_KMTB);
616        enable_button (hwnd_child, ID_KEYMISC_DELETE);
617  BOOL CALLBACK      enable_button (hwnd_child, ID_KEYMISC_PROPS);
618  keymanager_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)      enable_button (hwnd_child, ID_KEYMISC_SIGN);
619  {      enable_button (hwnd_child, ID_KEYMISC_EXPORT);
620      struct km_info *kmi;  
621      static km_group_s *gc = NULL;      /* Enable / disable menu items */
622      static HMENU menu = NULL;      state = key_selected? MF_ENABLED : MF_DISABLED|MF_GRAYED;
623      static int refresh_keys = 0;          hmenu = GetMenu (hwnd);
624      INITCOMMONCONTROLSEX icex;      set_menu_state (hmenu, ID_KEYMISC_EXPORT, state);
625      HWND kl;      set_menu_state (hmenu, ID_KEYMISC_EXPORT_PRIVKEY, state);
626      HMENU hm;      set_menu_state (hmenu, ID_KEYMISC_REVCERT, state);
627      gpgme_keycache_t c;      set_menu_state (hmenu, ID_KEYMISC_DELETE, state);
628      gpgme_key_t key;      set_menu_state (hmenu, ID_KEYMISC_PROPS, state);
629      /*km_group_cb_s gcb; XXX */      set_menu_state (hmenu, ID_KEYMISC_EDITKEY, state);
630      struct genkey_s genkey;      set_menu_state (hmenu, ID_KEYMISC_CHECKSIGS, state);
631      struct winpt_key_s k = {0};      set_menu_state (hmenu, ID_KEYMISC_SIGN, key_selected && !key_inv ? MF_ENABLED : MF_GRAYED);
632      struct URL_ctx_s *url;  
633      refresh_cache_s rcs = {0};      /* Disable some menu items when multiple keys are selected. */
634      char keyid[48], uid[128], type[32], * name;      if (listview_count_items (lv, 1) > 1) {
635      const char *t, * host;          for (i=0; mult_resids[i] != 0; i++)
636      u16 port = 0;              set_menu_state (hmenu, mult_resids[i], MF_GRAYED);
637      int idx = 0, i=0, rc;      }
638      size_t size = 0;  }
639    
640      if ((msg != WM_INITDIALOG)  
641          && ((kmi = (struct km_info*)GetWindowLong (dlg, GWL_USERDATA)) == NULL))  /* Disable some context menu items when multiple keys are selected. */
642          return FALSE;  static void
643    popup_multiple (HWND dlg, HMENU hm)
644      switch (msg) {  {
645      case WM_INITDIALOG:      int resids[] = {
646          kmi = new struct km_info;          ID_KEYCTX_EDIT,
647          memset (kmi, 0, sizeof (struct km_info));          ID_KEYCTX_SIGN,
648          icex.dwSize = sizeof (INITCOMMONCONTROLSEX);          ID_KEYCTX_REV,
649          icex.dwICC  = ICC_BAR_CLASSES;          ID_KEYCTX_ENABLE,
650          InitCommonControlsEx (&icex);          ID_KEYCTX_DISABLE,
651          kmi->hwnd_sep = regist_sep_wnd (dlg, kmi);          ID_KEYCTX_ADDKEY,
652          imagelist_load (dlg);          ID_KEYCTX_ADDPHOTO,
653            ID_KEYCTX_ADDUID,
654  #ifndef LANG_DE          ID_KEYCTX_ADDREV,
655          SetWindowText( dlg, _("Key Manager") );          ID_KEYCTX_LISTSIGS,
656  #endif                  ID_KEYCTX_MAXTRUST,
657          menu = LoadMenu( glob_hinst, (LPCSTR)IDR_WINPT_KEYMISC );          ID_KEYCTX_PROPS,
658  #ifndef LANG_DE          ID_KEYCTX_SENDMAIL,
659          set_menu_text( menu, ID_KEYMISC_QUIT, _("&Quit") );          0};
660          set_menu_text( menu, ID_KEYMISC_UID, _("User ID") );      int i;
661          set_menu_text( menu, ID_KEYMISC_NEWKEY, _("&Expert") );      for (i=0; i < resids[i] != 0; i++)
662          set_menu_text( menu, ID_KEYMISC_KEYWIZARD, _("&Normal") );          set_menu_state (hm, resids[i], MF_GRAYED);
663          set_menu_text( menu, ID_KEYMISC_EDIT, _("Edit") );  }
664          set_menu_text( menu, ID_KEYMISC_SIGN, _("&Sign") );  
665          set_menu_text( menu, ID_KEYMISC_DELETE, _("&Delete") );  
666          set_menu_text( menu, ID_KEYMISC_REVCERT, _("&Revoke") );  /* The items which are shown when GPG is in read-only mode. */
667          set_menu_text( menu, ID_KEYMISC_CHECKSIGS, _("&List Signatures") );  static void
668          set_menu_text( menu, ID_KEYMISC_TRUSTPATH, _("List Trust Path") );  popup_gpg_readonly (HWND dlg, HMENU hm)
669          set_menu_text( menu, ID_KEYMISC_PROPS, _("&Properties") );  {
670          set_menu_text( menu, ID_KEYMISC_GPGOPT, _("Options") );      int resids[] = {
671          set_menu_text( menu, ID_KEYMISC_GPGPREFS, _("Preferences") );          ID_KEYCTX_PASTE,
672          set_menu_text( menu, ID_KEYMISC_SENDRECV, _("Keyserver") );          ID_KEYCTX_EDIT,
673          set_menu_text( menu, ID_KEYMISC_RECACHE, _("Re&load Key Cache") );          ID_KEYCTX_SIGN,
674          set_menu_text( menu, ID_KEYMISC_REBUILD, _("R&everify Signatures") );          ID_KEYCTX_REV,
675          set_menu_text( menu, ID_KEYMISC_INFO, _("Info") );          ID_KEYCTX_DEL,
676          set_menu_text (menu, ID_KEYMISC_HELP, _("Help"));          ID_KEYCTX_ENABLE,
677  #endif          ID_KEYCTX_DISABLE,
678          SetMenu( dlg, menu );          ID_KEYCTX_RECVFROM,
679          if( keyring_check_last_access() )          ID_KEYCTX_ADDKEY,
680              keycache_set_reload( 1 );          ID_KEYCTX_ADDPHOTO,
681          if( keycache_get_reload( ) )          ID_KEYCTX_ADDUID,
682              keycache_reload( dlg );          ID_KEYCTX_ADDREV,
683          c = keycache_get_ctx( KEYCACHE_PUB );          0
684          if( !c )      };
685              BUG( NULL );      int i;
686          kmi->keylist_sortby = KEY_SORT_USERID;  
687          Header_SetImageList(ListView_GetHeader(GetDlgItem( dlg, IDC_KEYMISC_KEYLIST )),      if (gpg_read_only == 0)
688                              glob_imagelist);          return;
689          kmi->lv = keylist_load( GetDlgItem( dlg, IDC_KEYMISC_KEYLIST ), c,      for (i=0; resids[i] != 0; i++)
690                                  NULL, KEYLIST_LIST, kmi->keylist_sortby );          set_menu_state (hm, resids[i], MF_GRAYED);
691          /* init subclassing for the listview */  }
692          kl = GetDlgItem( dlg, IDC_KEYMISC_KEYLIST );  
693          keylist_proc.dlg = dlg;  
694          keylist_proc.current = (WNDPROC)keylist_subclass_proc;  /* Change the 'Edit' menu based on the current state. */
695          keylist_proc.old = (WNDPROC)GetWindowLong( kl, GWL_WNDPROC );  static void
696          if( keylist_proc.old ) {  change_edit_menu (listview_ctrl_t lv, HMENU hm, int id)
697              if( !SetWindowLong( kl, GWL_WNDPROC, (LONG)keylist_proc.current) ) {  {
698                  msg_box( dlg, _("Could not set keylist window procedure."), _("Key Manager"), MB_ERR );      enum item { EDIT_MENU = 1 };
699                  BUG( NULL );      int no_sel;
700              }  
701          }      if (id != EDIT_MENU)
702          #if 0          return;
703          km_groups_new( &gc, GetDlgItem( dlg, IDC_KEYMISC_GROUP ) );  
704          km_groups_load( gc );      if (!clip_contains_pgpkey ())
705          #endif          set_menu_state (hm, ID_KEYMISC_PASTE, MF_GRAYED);
706          SetForegroundWindow( dlg );      else
707            set_menu_state (hm, ID_KEYMISC_PASTE, MF_ENABLED);
708          int partpos[3];      no_sel = listview_get_curr_pos (lv) == -1? 1 : 0;
709          RECT r;      set_menu_state (hm, ID_KEYMISC_DELETE2, no_sel? MF_GRAYED: MF_ENABLED);
710                set_menu_state (hm, ID_KEYMISC_COPY, no_sel? MF_GRAYED : MF_ENABLED);
711          GetClientRect (dlg, &r);  }
712          for (i=1; i <= 3; i++)  
713              partpos[i-1] = r.right/3*i;  
714          kmi->statbar = CreateStatusWindow (WS_CHILD | WS_VISIBLE | CCS_BOTTOM,  
715                                             "status bar", dlg, 100000);  /* Show limited key menu entries when GPG is in read-only mode. */
716          ShowWindow (kmi->statbar, SW_SHOW);  static void
717          SendMessage (kmi->statbar, SB_SETPARTS, (WPARAM)3, (LPARAM)partpos);  change_key_menu (HMENU hm, int id)
718                            {
719          km_update_default_key_str (kmi->statbar);      int key_resids[] = {
720          km_complete_status_bar( kmi->statbar, kmi->lv);          ID_KEYMISC_SIGN,
721            ID_KEYMISC_DELETE,
722          SetWindowLong (dlg, GWL_USERDATA, (LONG)kmi);          ID_KEYMISC_REVCERT,
723          kmi->toolbar = load_toolbar (dlg, kmi);          ID_KEYMISC_IMPORT_HTTP,
724            ID_KEYMISC_IMPORT,
725          do_center_window( dlg, kmi );          ID_KEYMISC_REFRESH_KEYS,
726          do_resize_window( dlg, kmi );          ID_KEYMISC_REBUILD,
727          update_ui_items (dlg, kmi->lv);          ID_KEYMISC_KEYWIZARD,
728          return TRUE;          ID_KEYMISC_CARDNEW,
729                    ID_KEYMISC_NEWKEY,
730      case WM_DESTROY:          0,
731          if (kmi->lv) {      };
732              keylist_delete (kmi->lv);      int edit_resids[] = {
733              kmi->lv = NULL;                ID_KEYMISC_PASTE,
734                    ID_KEYMISC_OT,
735           /*          ID_KEYMISC_EDITKEY,
736           if (gc) {          0
737              km_groups_release (gc);      };
738              gc = NULL;      int *resids;
739          }*/      int i;
740         imagelist_destroy ();  
741        
742         char buf[32];      if (gpg_read_only == 0)
743         ltoa (kmi->pos_x, buf, 10);          return;
744         set_reg_entry( HKEY_CURRENT_USER, "Software\\WinPT", "KM_Pos_X", buf );      switch (id) {
745         ltoa (kmi->pos_y, buf, 10);      case 0: return;
746         set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "KM_Pos_Y", buf);      case 3: resids = key_resids; break;
747         /* Remove runtime information. This should be the last action taken here. */      case 1: resids = edit_resids;break;
748         delete kmi; kmi = NULL;      default:resids = edit_resids; break;
749         SetWindowLong (dlg, GWL_USERDATA, NULL);          }
750         keycache_set_reload (refresh_keys);  
751         return FALSE;      for (i=0; resids[i] != 0; i++)
752            set_menu_state (hm, resids[i], MF_GRAYED);
753      case WM_MOVE:        }
754          /* kmi->pos_x = (int)(short)LOWORD(lparam);  
755             kmi->pos_y = (int)(short)HIWORD(lparam); */  
756          RECT r;  /* Return a user-friendly name for a key derrived from
757          GetWindowRect (dlg, &r);     name. If @is_secret is 1, a secret key name will be generated. */
758          kmi->pos_x = r.left;  static char*
759          kmi->pos_y = r.top;      gen_export_filename (const char *keyid, int is_secret)
760          break;  {
761                gpgme_key_t key;
762        const char *s;
763      case WM_RBUTTONUP:      char *p;
764          do_create_minpopup (dlg);  
765          break;      if (get_pubkey (keyid, &key))
766            return m_strdup (keyid);
767      case WM_NOTIFY:                  s = key->uids->name;
768          NMHDR * notify;      if (!s)
769          POINT p;          return m_strdup (keyid);
770          HMENU popup;      p = new char[strlen (s) + 8 + 16];
771                if (!p)
772          notify = (NMHDR *)lparam;          BUG (0);
773          if (notify == NULL)      sprintf (p, "%s%s.asc", s, is_secret? "_sec" : "");
774              break;      for (size_t i=0; i < strlen (p); i++) {
775          switch (notify->code)          if (p[i] == ' ' || p[i] == ':' || p[i] == '?' || p[i] == '|')
776          {              p[i] = '_';
777          case TBN_QUERYDELETE:      }
778              SetWindowLong(dlg, DWL_MSGRESULT, TRUE);      return p;
779              return TRUE;  }
780            
781          case TBN_QUERYINSERT:  
782              SetWindowLong(dlg, DWL_MSGRESULT, TRUE);  /* Reload a single key in the cache. */
783              return TRUE;  static void
784    update_key (listview_ctrl_t lv, int pos, const char *keyid, int keypair)
785          case TBN_GETBUTTONINFO:  {
786              LPTBNOTIFY lpTbNotify;      gpgme_key_t key;
787              lpTbNotify = (LPTBNOTIFY)lparam;  
788              if (lpTbNotify->iItem < (sizeof(myb) / sizeof(mybuttons))) {      keycache_update (0, keyid);
789                  lpTbNotify->tbButton.iBitmap = imagelist_getindex(myb[lpTbNotify->iItem].icon);      if (keypair)
790                  lpTbNotify->tbButton.idCommand = myb[lpTbNotify->iItem].command;          keycache_update (1, keyid);
791                  lpTbNotify->tbButton.fsState = TBSTATE_ENABLED;  
792                  lpTbNotify->tbButton.fsStyle = TBSTYLE_BUTTON;      /* because we replaced the key item, we need to update the
793                  lpTbNotify->tbButton.iString = 0;         address of the pointer in the ListView control. */
794                  strncpy (lpTbNotify->pszText, myb[lpTbNotify->iItem].text, lpTbNotify->cchText);      get_pubkey (keyid, &key);
795                  SetWindowLong(dlg, DWL_MSGRESULT, TRUE);      keylist_upd_key (lv, pos, key);
796              }  }
797              return TRUE;  
798    
799          case TBN_RESET: /* Restore last saved toolbar status */  /* Setup status bar for the main window @dlg. */
800              TBSAVEPARAMS tbsp;  static HWND
801    setup_status_bar (HWND dlg, listview_ctrl_t lv)
802              tbsp.hkr = HKEY_CURRENT_USER;  {      
803              tbsp.pszSubKey = "Software\\WinPT";      HWND statbar;
804              tbsp.pszValueName = "KM_toolbar";      RECT r;
805              SendMessage (notify->hwndFrom, TB_SAVERESTORE, FALSE, (LPARAM)&tbsp);      int partpos[3];
806              break;      int i;
807    
808          case TBN_BEGINADJUST: /* User is about to change the toolbar. Save it */      GetClientRect (dlg, &r);
809              tbsp.hkr = HKEY_CURRENT_USER;      for (i=1; i <= 3; i++)
810              tbsp.pszSubKey = "Software\\WinPT";          partpos[i-1] = r.right/3*i;
811              tbsp.pszValueName = "KM_toolbar";      statbar = CreateStatusWindow (WS_CHILD | WS_VISIBLE | CCS_BOTTOM,
812              SendMessage (notify->hwndFrom, TB_SAVERESTORE, TRUE, (LPARAM)&tbsp);                                    "status bar", dlg, KM_SEPARATOR_ID);
813              break;  
814        ShowWindow (statbar, SW_SHOW);
815          case TBN_ENDADJUST: /* User has finished customizing the toolbar. Save it. */      SendMessage (statbar, SB_SETPARTS, (WPARAM)3, (LPARAM)partpos);
816              tbsp.hkr = HKEY_CURRENT_USER;  
817              tbsp.pszSubKey = "Software\\WinPT";      km_update_default_key_str (statbar);
818              tbsp.pszValueName = "KM_toolbar";      km_update_status_bar (statbar, lv);
819              SendMessage (notify->hwndFrom, TB_SAVERESTORE, TRUE, (LPARAM)&tbsp);  
820              break;      return statbar;
821    }
822          case TTN_GETDISPINFO:  
823              LPTOOLTIPTEXT lpttt;  
824              lpttt = (LPTOOLTIPTEXT)lparam;  /* Translate all menu strings. */
825    static void
826              lpttt->hinst = NULL;  translate_menu_strings (HWND dlg)
827              switch (lpttt->hdr.idFrom) {  {
828              case ID_KEYMISC_DELETE:      HMENU menu;
829                  lpttt->lpszText = (char *)_("Delete key from keyring");  
830                  break;      menu = LoadMenu (glob_hinst, (LPCSTR)IDR_WINPT_KEYMISC);
831        set_menu_text_bypos (menu, 0, _("File"));
832              case ID_KEYMISC_PROPS:      set_menu_text_bypos (menu, 1, _("Edit"));
833                  lpttt->lpszText = (char *)_("Show key properties");      set_menu_text_bypos (menu, 2, _("View"));
834                  break;      set_menu_text_bypos (menu, 3, _("Key"));
835        set_menu_text_bypos (menu, 4, _("Groups"));
836              case ID_KEYMISC_SIGN:  
837                  lpttt->lpszText = (char *)_("Sign key");      set_menu_text (menu, ID_KEYMISC_EDITKEY, _("Edit"));
838                  break;      set_menu_text (menu, ID_KEYMISC_MAIL, _("Send Mail..."));
839        set_menu_text (menu, ID_KEYMISC_OT, _("Ownertrust")); /* XXX */
840              case ID_KEYMISC_IMPORT:      set_menu_text (menu, ID_KEYMISC_COPY, _("&Copy\tCtrl+C"));
841                  lpttt->lpszText = (char *)_("Import key to keyring");      set_menu_text (menu, ID_KEYMISC_PASTE, _("&Paste\tCtrl+V"));
842                  break;      set_menu_text (menu, ID_KEYMISC_FIND, _("Search...\tCtrl+F"));
843        set_menu_text (menu, ID_KEYMISC_SELALL, _("Select All\tCtrl+A"));
844              case ID_KEYMISC_EXPORT:      set_menu_text (menu, ID_KEYMISC_QUIT, _("&Quit"));
845                  lpttt->lpszText = (char *)_("Export key to a file");      set_menu_text (menu, ID_KEYMISC_UID, _("User ID"));
846                  break;      set_menu_text (menu, ID_KEYMISC_NEWKEY, _("&Expert"));
847              }      set_menu_text (menu, ID_KEYMISC_KEYWIZARD, _("&Normal"));
848              return TRUE;      set_menu_text (menu, ID_KEYMISC_EDIT, _("Edit"));
849                    set_menu_text (menu, ID_KEYMISC_SIGN, _("&Sign"));
850          case LVN_ITEMCHANGED:      set_menu_text (menu, ID_KEYMISC_DELETE, _("&Delete"));
851              if (((LPNMLISTVIEW)lparam)->uNewState) /* item selected? */      set_menu_text (menu, ID_KEYMISC_DELETE2, _("&Delete"));
852              {      set_menu_text (menu, ID_KEYMISC_REVCERT, _("&Revoke"));
853                  update_ui_items (dlg, kmi->lv);      set_menu_text (menu, ID_KEYMISC_CHECKSIGS, _("&List Signatures"));
854                  return TRUE;      set_menu_text (menu, ID_KEYMISC_TRUSTPATH, _("List Trust Path"));
855              }      set_menu_text (menu, ID_KEYMISC_EXPORT, _("&Export..."));
856              break;      set_menu_text (menu, ID_KEYMISC_IMPORT, _("&Import..."));
857        set_menu_text (menu, ID_KEYMISC_PROPS, _("&Properties"));
858          case NM_RCLICK:      set_menu_text (menu, ID_KEYMISC_GPGOPT, _("Options"));
859              if (notify->idFrom == IDC_KEYMISC_KEYLIST) {      set_menu_text (menu, ID_KEYMISC_GPGPREFS, _("Preferences"));
860                  if (listview_get_curr_pos (kmi->lv) == -1)      set_menu_text (menu, ID_KEYMISC_SENDRECV, _("Keyserver") );
861                      return TRUE; /* Popup only when a item was selected */      set_menu_text (menu, ID_KEYMISC_EXPORT_PRIVKEY, _("E&xport Secret Key"));
862                  do_check_cache (kmi->lv, dlg, kmi->statbar);      set_menu_text (menu, ID_KEYMISC_RECACHE, _("Re&load Key Cache"));
863                  GetCursorPos (&p);      set_menu_text (menu, ID_KEYMISC_REBUILD, _("R&everify Signatures"));
864                  hm = LoadMenu (glob_hinst, MAKEINTRESOURCE (IDR_WINPT_KEYMISC_CTX));      set_menu_text (menu, ID_KEYMISC_REFRESH_KEYS, _("Refresh &Keys (Keyserver)"));
865                  popup = GetSubMenu (hm, 0);      set_menu_text (menu, ID_KEYMISC_INFO, _("Info") );
866              #ifndef LANG_DE      set_menu_text (menu, ID_KEYMISC_HELP, _("&Help"));
867                  set_menu_text( popup, ID_KEYCTX_UID_COPY, _("Copy User ID to Clipboard") );  
868                  set_menu_text( popup, ID_KEYCTX_COPY, _("Copy Key to Clipboard") );      /* XXX: implement help code. */
869                  set_menu_text( popup, ID_KEYCTX_PASTE, _("Paste Key from Clipboard") );                  set_menu_state (menu, ID_KEYMISC_HELP, MF_GRAYED);
870                  set_menu_text( popup, ID_KEYCTX_RECVFROM, _("Refresh from Keyserver") );  
871              #endif      SetMenu (dlg, menu);
872                  idx = listview_get_curr_pos (kmi->lv);  }
873                  if (km_check_for_seckey (kmi->lv, idx, &i))  
874                      set_menu_state (popup, ID_KEYCTX_SETDEFKEY, MF_ENABLED);  
875                  if (i == 0)  /* Translate popup menu strings. */
876                      set_menu_state (popup, ID_KEYCTX_MAXTRUST, MF_ENABLED);  static void
877                  if (!km_check_for_seckey (kmi->lv, idx, NULL)) {  translate_popupmenu_strings (HMENU popup)
878                      set_menu_state( popup, ID_KEYCTX_REV, MF_DISABLED|MF_GRAYED );  {
879                      set_menu_state( popup, ID_KEYCTX_ADDKEY, MF_DISABLED|MF_GRAYED );      set_menu_text (popup, ID_KEYCTX_UID_COPY, _("Copy User ID to Clipboard"));
880                      set_menu_state( popup, ID_KEYCTX_ADDUID, MF_DISABLED|MF_GRAYED );      set_menu_text (popup, ID_KEYCTX_KEYID_COPY, _("Copy Key ID to Clipboard"));
881                      set_menu_state( popup, ID_KEYCTX_ADDREV, MF_DISABLED|MF_GRAYED );      set_menu_text (popup, ID_KEYCTX_FPR_COPY, _("Copy Fingerprint to Clipboard"));
882                      set_menu_state( popup, ID_KEYCTX_ADDPHOTO, MF_DISABLED|MF_GRAYED );      set_menu_text (popup, ID_KEYCTX_KINFO_COPY, _("Copy Key Info to Clipboard"));
883                      set_menu_state (popup, ID_KEYCTX_SETPREFKS, MF_DISABLED|MF_GRAYED);      set_menu_text (popup, ID_KEYCTX_COPY, _("Copy Key to Clipboard"));
884                  }      set_menu_text (popup, ID_KEYCTX_PASTE, _("Paste Key from Clipboard"));
885                  else if( km_check_for_seckey( kmi->lv, idx, NULL )      set_menu_text (popup, ID_KEYCTX_RECVFROM, _("Refresh from Keyserver"));
886                        && km_key_is_v3( kmi->lv, idx ) )      set_menu_text (popup, ID_KEYCTX_MAXTRUST, _("Set Implicit &Trust"));
887                  {      set_menu_text (popup, ID_KEYCTX_LISTSIGS, _("&List Signatures"));
888                      /* PGP 2 keys, version 3 have no no support for photo-id's,      set_menu_text (popup, ID_KEYCTX_PROPS, _("&Properties"));
889                         designated revokers and secondary keys. */      set_menu_text (popup, ID_KEYCTX_EDIT, _("Key Edit"));
890                      set_menu_state (popup, ID_KEYCTX_ADDKEY, MF_DISABLED|MF_GRAYED);      set_menu_text (popup, ID_KEYCTX_DEL, _("&Delete"));
891                      set_menu_state (popup, ID_KEYCTX_ADDREV, MF_DISABLED|MF_GRAYED);      set_menu_text (popup, ID_KEYCTX_REV, _("&Revoke"));
892                      set_menu_state (popup, ID_KEYCTX_ADDPHOTO, MF_DISABLED|MF_GRAYED);      set_menu_text (popup, ID_KEYCTX_SIGN, _("&Sign"));
893                  }      set_menu_text (popup, ID_KEYCTX_ENABLE, _("&Enable"));
894                  if( km_get_key_status( kmi->lv, idx ) & KM_FLAG_DISABLED )      set_menu_text (popup, ID_KEYCTX_DISABLE, _("&Disable"));
895                      set_menu_state( popup, ID_KEYCTX_DISABLE, MF_DISABLED|MF_GRAYED );      set_menu_text (popup, ID_KEYCTX_RECVFROM, _("Re&fresh from Keyserver"));
896                  else      set_menu_text (popup, ID_KEYCTX_SETPREFKS, _("Set preferred Keyserver URL"));
897                      set_menu_state( popup, ID_KEYCTX_ENABLE, MF_DISABLED|MF_GRAYED );      set_menu_text (popup, ID_KEYCTX_SENDMAIL, _("Send Key to Mail Recipient"));
898                  if (km_get_key_status (kmi->lv, idx) & KM_FLAG_REVOKED)      set_menu_text (popup, ID_KEYCTX_SETDEFKEY, _("Set as Default Key"));
899                      set_menu_state (popup, ID_KEYCTX_SIGN, MF_DISABLED|MF_GRAYED);  
900                  if (mapi_init())      set_menu_text (popup, ID_KEYCTX_ADDKEY, _("Key..."));
901                      set_menu_state (popup, ID_KEYCTX_SENDMAIL, MF_DISABLED|MF_GRAYED);      set_menu_text (popup, ID_KEYCTX_ADDUID, _("User ID..."));
902                  /* Override 'Default Keyserver' with the actual name. */      set_menu_text (popup, ID_KEYCTX_ADDPHOTO, _("Photo ID..."));
903                  host = kserver_get_hostname (0, -1, &port);      set_menu_text (popup, ID_KEYCTX_ADDREV, _("Revoker..."));
904                  set_menu_text (popup, ID_KEYCTX_KS_DEFAULT, host);  
905                  popup_gpg_readonly (dlg, popup);      /* change popup texts */
906                  TrackPopupMenu (popup, TPM_RIGHTALIGN, p.x, p.y, 0, dlg, NULL);      set_menu_text_bypos (popup, 0, _("Key Attributes"));
907                  DestroyMenu (popup);      set_menu_text_bypos (popup, 6, _("Add"));
908                  DestroyMenu (hm);      set_menu_text_bypos (popup, 19, _("Send to Keyserver"));
909                  return TRUE;  }
910              }  
911              #if 0 /* XXX */  
912              if( notify->idFrom == IDC_KEYMISC_GROUP ) {  /* Dialog box procedure for the Key Manager. */
913                  HWND tree = GetDlgItem( dlg, IDC_KEYMISC_GROUP );  BOOL CALLBACK
914                  if( TreeView_GetSelection( tree ) ) {  keymanager_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
915                      GetCursorPos( &p );  {
916                      hm = LoadMenu( glob_hinst, MAKEINTRESOURCE(IDR_WINPT_GROUP_CTX) );      struct km_info *kmi;
917                      popup = GetSubMenu( hm, 0 );      static int refresh_keys = 0;    
918                      if( km_index == -1 )      INITCOMMONCONTROLSEX icex;
919                          set_menu_state( popup, ID_GROUP_PASTE, MF_DISABLED|MF_GRAYED );      HWND kl;
920                      set_menu_text( popup, ID_GROUP_PASTE, _("Paste into this group") );      HMENU hm;
921                      set_menu_text( popup, ID_GROUP_DELETE, _("Delete") );      gpg_keycache_t c;
922                      TrackPopupMenu( popup, TPM_RIGHTALIGN, p.x, p.y, 0, dlg, NULL );      gpgme_key_t key;
923                      DestroyMenu( popup );      struct genkey_s genkey;
924                      DestroyMenu( hm );      struct winpt_key_s k = {0};
925                      return TRUE;      struct URL_ctx_s *url;
926                  }      refresh_cache_s rcs = {0};
927              }      char keyid[48], uid[128], type[32], *name;
928              #endif      const char *t, *host;
929              break;      u16 port = 0;
930        int l_idx = 0, i=0, rc;
931          case LVN_COLUMNCLICK:  
932              if (notify->idFrom == IDC_KEYMISC_KEYLIST) {      if ((msg != WM_INITDIALOG)
933                  NMLISTVIEW * p = (LPNMLISTVIEW) lparam;          && ((kmi = (struct km_info*)GetWindowLong (dlg, GWL_USERDATA)) == NULL))
934                  int sortby = 0;          return FALSE;
935                  switch (p->iSubItem) {  
936                  case 0:  sortby = KEY_SORT_USERID; break;      switch (msg) {
937                  case 1:  sortby = KEY_SORT_KEYID; break;      case WM_INITDIALOG:
938                  case 2:  sortby = KEY_SORT_IS_SECRET; break;          kmi = new struct km_info;
939                  case 3:  sortby = KEY_SORT_LEN; break;          memset (kmi, 0, sizeof (struct km_info));
940                  case 5:  sortby = KEY_SORT_VALIDITY; break;          kmi->lv_idx = -1;
941                  case 6:  sortby = KEY_SORT_OTRUST; break;          icex.dwSize = sizeof (INITCOMMONCONTROLSEX);
942                  case 7:  sortby = KEY_SORT_CREATED; break;          icex.dwICC  = ICC_BAR_CLASSES;
943                  case 8:  sortby = KEY_SORT_ALGO; break;          InitCommonControlsEx (&icex);
944                  default: return TRUE; //sortby = KEY_SORT_USERID; break;          kmi->hwnd_sep = regist_sep_wnd (dlg, kmi);
945                  }          imagelist_load (dlg);
946            translate_menu_strings (dlg);
947                  if ((kmi->keylist_sortby & ~KEYLIST_SORT_DESC) == sortby)          SetWindowText (dlg, _("Key Manager"));
948                      kmi->keylist_sortby ^= KEYLIST_SORT_DESC;  
949                  else          if (keyring_check_last_access ())
950                      kmi->keylist_sortby = sortby;              keycache_set_reload (1);
951                  keylist_sort (kmi->lv, kmi->keylist_sortby);          if (keycache_get_reload ())
952                  return TRUE;              keycache_reload (dlg);
953              }          c = keycache_get_ctx (KEYCACHE_PUB);
954              break;          if (!c)
955          }              BUG (NULL);
956          break;          kl = GetDlgItem (dlg, IDC_KEYMISC_KEYLIST);
957          }          kmi->keylist_sortby = KEY_SORT_USERID;
958            Header_SetImageList(ListView_GetHeader (kl), glob_imagelist);
959      case WM_WINDOWPOSCHANGING:          kmi->lv = keylist_load (GetDlgItem (dlg, IDC_KEYMISC_KEYLIST), c,
960          if (((WINDOWPOS*)lparam)->cx < 400)                                  NULL, KEYLIST_LIST, kmi->keylist_sortby);
961              ((WINDOWPOS*)lparam)->cx = 400;          /* init subclassing for the listview */
962          if (((WINDOWPOS*)lparam)->cy < 200)          keylist_proc.dlg = dlg;
963              ((WINDOWPOS*)lparam)->cy = 200;          keylist_proc.current = (WNDPROC)keylist_subclass_proc;
964           return TRUE;          keylist_proc.old = (WNDPROC)GetWindowLong( kl, GWL_WNDPROC );
965                    if (keylist_proc.old) {
966      case WM_SIZE:              if( !SetWindowLong (kl, GWL_WNDPROC, (LONG)keylist_proc.current)) {
967          do_resize_window (dlg, kmi);                  msg_box (dlg, _("Could not set keylist window procedure."),
968          return TRUE;                           _("Key Manager"), MB_ERR);
969                            BUG (NULL);
970      case WM_SYSCOMMAND:              }
971          if( LOWORD (wparam) == SC_CLOSE )          }
972              EndDialog( dlg, TRUE );          kmi->statbar = setup_status_bar (dlg, kmi->lv);
973          return FALSE;          SetWindowLong (dlg, GWL_USERDATA, (LONG)kmi);
974                    kmi->toolbar = load_toolbar (dlg, kmi);
975      case WM_MENUSELECT:  
976          menu_gpg_readonly (dlg, (HMENU)lparam, LOWORD (wparam));          do_center_window (dlg, kmi);
977          break;          do_resize_window (dlg, kmi);
978            update_ui_items (dlg, kmi->lv);
979      case WM_COMMAND:          restore_column_size (kmi->lv);
980          if( gnupg_access_keyring( 1 ) ) {  
981              msg_box( dlg, _("Could not access public keyring"), _("Key Manager"), MB_ERR );          SetDlgItemText (dlg, IDC_KEYMISC_GTEXT, _("Groups"));
982              return FALSE;          SetClassLong (dlg, GCL_HICON, (LONG)LoadIcon (glob_hinst,
983          }                        (LPCTSTR)IDI_WINPT));
984          do_check_cache( kmi->lv, dlg, kmi->statbar );          SetForegroundWindow (dlg);
985          switch( LOWORD( wparam ) ) {          return TRUE;
986          case ID_KEYMISC_QUIT:          
987              EndDialog( dlg, TRUE );      case WM_DESTROY:
988              return TRUE;          save_column_size (kmi->lv);
989                        if (kmi->lv) {
990          case ID_KEYMISC_MAIL:              keylist_delete (kmi->lv);
991              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_MAIL, GetDesktopWindow (),              kmi->lv = NULL;      
992                              winpt_mail_proc, NULL);          }
993              break;          imagelist_destroy ();
994            
995          case ID_KEYMISC_FIND:          ltoa (kmi->pos_x, type, 10);
996              km_find_key (dlg, kmi->lv);          set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "KM_Pos_X", type);
997              break;          ltoa (kmi->pos_y, type, 10);
998            set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "KM_Pos_Y", type);
999          case ID_KEYMISC_DELETE:          
1000              if (km_delete_keys (kmi->lv, dlg))          /* Remove runtime information. This should be the last action taken here. */
1001                  return FALSE;          delete kmi; kmi = NULL;
1002              return TRUE;          SetWindowLong (dlg, GWL_USERDATA, 0);
1003                        keycache_set_reload (refresh_keys);
1004          case ID_KEYMISC_SIGN:                  return FALSE;
1005              if ( (idx = listview_get_curr_pos( kmi->lv )) == -1 ) {  
1006                  msg_box( dlg, _("Please select a key."),  _("Key Manager"),      case WM_MOVE:
1007                           MB_ERR );          RECT r;
1008                  return FALSE;          GetWindowRect (dlg, &r);
1009              }          kmi->pos_x = r.left;
1010              if (km_check_key_status (kmi->lv, idx))          kmi->pos_y = r.top;    
1011                  return FALSE;          break;
1012              key = (gpgme_key_t)listview_get_item2 (kmi->lv, idx);          
1013              listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);  
1014              memset (&k, 0, sizeof (k));      case WM_RBUTTONUP:
1015              k.ctx = key;          do_create_minpopup (dlg);
1016              k.keyid = keyid;          break;
1017              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYSIGN, dlg,  
1018                                keysign_dlg_proc, (LPARAM)&k,      case WM_NOTIFY:            
1019                                _("Key Signing"), IDS_WINPT_KEYSIGN);          NMHDR *notify;
1020              if (k.update)          POINT p;
1021                  update_key (kmi->lv, idx, k.keyid, 0);          HMENU popup;
1022              return TRUE;          
1023                        notify = (NMHDR *)lparam;
1024          case ID_KEYMISC_REVCERT:          if (!notify)
1025              idx = listview_get_curr_pos( kmi->lv );              break;
1026              if( idx == -1 ) {          switch (notify->code) {
1027                  msg_box( dlg, _("Please select a key."), _("Key Manager"), MB_ERR );          case TBN_QUERYDELETE:
1028                  return FALSE;              SetWindowLong (dlg, DWL_MSGRESULT, TRUE);
1029              }              return TRUE;
1030              listview_get_item_text( kmi->lv, idx, 0, uid, sizeof uid -1 );          
1031              listview_get_item_text( kmi->lv, idx, 1, keyid, sizeof keyid-1 );          case TBN_QUERYINSERT:
1032              if ( !km_check_for_seckey( kmi->lv, idx, NULL ) ) {              SetWindowLong (dlg, DWL_MSGRESULT, TRUE);
1033                  msg_box( dlg, _("There is no secret key available!"), _("Key Manager"), MB_ERR );              return TRUE;
1034                  return FALSE;  
1035              }          case TBN_GETBUTTONINFO:
1036                            LPTBNOTIFY lpTbNotify;
1037              {              lpTbNotify = (LPTBNOTIFY)lparam;
1038                  char t[128];              if (lpTbNotify->iItem < (sizeof(myb) / sizeof(mybuttons))) {
1039                  listview_get_item_text( kmi->lv, idx, 5, t, sizeof t -1 );                  lpTbNotify->tbButton.iBitmap = imagelist_getindex(myb[lpTbNotify->iItem].icon);
1040                  if( strchr( t, 'R' ) ) {                  lpTbNotify->tbButton.idCommand = myb[lpTbNotify->iItem].command;
1041                      msg_box( dlg, _("Key already revoked!"), _("Key Manager"), MB_INFO );                  lpTbNotify->tbButton.fsState = TBSTATE_ENABLED;
1042                      return FALSE;                  lpTbNotify->tbButton.fsStyle = TBSTYLE_BUTTON;
1043                  }                  lpTbNotify->tbButton.iString = 0;
1044              }                  strncpy (lpTbNotify->pszText, myb[lpTbNotify->iItem].text, lpTbNotify->cchText);
1045                                SetWindowLong(dlg, DWL_MSGRESULT, TRUE);
1046              name = km_quote_uid (uid);              }
1047              memset (&k, 0, sizeof (k));              return TRUE;
1048              k.key_pair = 1;  
1049              k.keyid = keyid;          case TBN_RESET: /* Restore last saved toolbar status */
1050              k.uid = name;              TBSAVEPARAMS tbsp;
1051              k.is_protected = km_check_if_protected( kmi->lv, idx );  
1052              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_KEYREVOKE, dlg,              tbsp.hkr = HKEY_CURRENT_USER;
1053                               key_revoke_dlg_proc, (LPARAM)&k,              tbsp.pszSubKey = "Software\\WinPT";
1054                               _("Key Revocation"), IDS_WINPT_KEYREVOKE );              tbsp.pszValueName = "KM_toolbar";
1055              free_if_alloc (name);              SendMessage (notify->hwndFrom, TB_SAVERESTORE, FALSE, (LPARAM)&tbsp);
1056              return TRUE;              break;
1057                
1058          case ID_KEYMISC_TRUSTPATH:          case TBN_BEGINADJUST: /* User is about to change the toolbar. Save it */
1059              idx = listview_get_curr_pos( kmi->lv );              tbsp.hkr = HKEY_CURRENT_USER;
1060              if( idx == -1 ) {              tbsp.pszSubKey = "Software\\WinPT";
1061                  msg_box( dlg, _("Please select a key."), _("Key Manager"), MB_ERR );              tbsp.pszValueName = "KM_toolbar";
1062                  return FALSE;              SendMessage (notify->hwndFrom, TB_SAVERESTORE, TRUE, (LPARAM)&tbsp);
1063              }              break;
1064              listview_get_item_text( kmi->lv, idx, 0, uid, sizeof uid -1 );  
1065              listview_get_item_text( kmi->lv, idx, 1, keyid, sizeof keyid -1 );          case TBN_ENDADJUST: /* User has finished customizing the toolbar. Save it. */
1066              if( km_check_for_seckey( kmi->lv, idx, NULL ) ) {              tbsp.hkr = HKEY_CURRENT_USER;
1067                  msg_box( dlg, _("It does not make any sense with a key pair!"), _("Key Manager"), MB_OK );              tbsp.pszSubKey = "Software\\WinPT";
1068                  return FALSE;              tbsp.pszValueName = "KM_toolbar";
1069              }              SendMessage (notify->hwndFrom, TB_SAVERESTORE, TRUE, (LPARAM)&tbsp);
1070              memset (&k, 0, sizeof (k));              break;
1071              k.keyid = keyid;  
1072              k.uid = uid;          case TTN_GETDISPINFO:
1073              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_KEYTRUST, dlg,              LPTOOLTIPTEXT lpttt;
1074                                keytrust_dlg_proc, (LPARAM)&k,              lpttt = (LPTOOLTIPTEXT)lparam;
1075                                _("List Trust Path"), IDS_WINPT_KEYTRUST );  
1076              return TRUE;              lpttt->hinst = NULL;
1077                            switch (lpttt->hdr.idFrom) {
1078          case ID_KEYMISC_CHECKSIGS:              case ID_KEYMISC_DELETE:
1079              idx = listview_get_curr_pos (kmi->lv);                  lpttt->lpszText = (char *)_("Delete key from keyring");
1080              if( idx == -1 ) {                  break;
1081                  msg_box( dlg, _("Please select a key."), _("Key Manager"), MB_ERR );  
1082                  return FALSE;              case ID_KEYMISC_PROPS:
1083              }                  lpttt->lpszText = (char *)_("Show key properties");
1084              listview_get_item_text (kmi->lv, idx, 0, uid, DIM (uid)-1);                  break;
1085              listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);  
1086              memset (&k, 0, sizeof (k));              case ID_KEYMISC_SIGN:
1087              k.keyid = keyid;                  lpttt->lpszText = (char *)_("Sign key");
1088              k.uid = uid;                  break;
1089              k.ctx = (gpgme_key_t)listview_get_item2 (kmi->lv, idx);  
1090              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYSIG, dlg,              case ID_KEYMISC_IMPORT:
1091                                keysig_dlg_proc, (LPARAM)&k,                  lpttt->lpszText = (char *)_("Import key to keyring");
1092                                _("Key Signature List" ), IDS_WINPT_KEYSIG);                  break;
1093              return TRUE;  
1094                            case ID_KEYMISC_EXPORT:
1095          case ID_KEYMISC_PROPS:                  lpttt->lpszText = (char *)_("Export key to a file");
1096              idx = listview_get_curr_pos( kmi->lv );                  break;
1097              if( idx == -1 ) {              }
1098                  msg_box( dlg, _("Please select a key."), _("Key Manager"), MB_ERR );              return TRUE;
1099                  return FALSE;              
1100              }          case LVN_ITEMCHANGED:
1101              listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);              if (((LPNMLISTVIEW)lparam)->uNewState) { /* item selected? */
1102              listview_get_item_text (kmi->lv, idx, 2, type, DIM (type)-1);                  kmi->lv_idx = listview_get_curr_pos (kmi->lv);
1103              memset (&k, 0, sizeof (k));                  update_ui_items (dlg, kmi->lv);
1104              k.key_pair = 0;                  return TRUE;
1105              k.keyid = keyid;              }
1106              if( !strcmp( type, "pub/sec" ) || !strcmp( type, "pub/crd" ) )              break;
1107                  k.key_pair = 1;  
1108              k.callback.ctl = kmi->lv;          case NM_RCLICK:
1109              k.callback.idx = idx;              if (notify->idFrom == IDC_KEYMISC_KEYLIST) {
1110              k.is_v3 = km_key_is_v3 (kmi->lv, idx);                  l_idx =listview_get_curr_pos (kmi->lv);
1111              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_KEYPROPS, dlg,                  if (l_idx == -1)
1112                                keyprops_dlg_proc, (LPARAM)&k,                      return TRUE; /* Popup only when a item was selected */
1113                                _("Key Properties"), IDS_WINPT_KEYPROPS );                  do_check_cache (kmi->lv, dlg, kmi->statbar);
1114              if (k.callback.new_val != 0) {                  GetCursorPos (&p);
1115                  t = get_key_trust_str (k.callback.new_val);                  hm = LoadMenu (glob_hinst, MAKEINTRESOURCE (IDR_WINPT_KEYMISC_CTX));
1116                  listview_add_sub_item (kmi->lv, idx, 6, t);                  popup = GetSubMenu (hm, 0);
1117              }                  translate_popupmenu_strings (popup);
1118              return TRUE;  
1119                                if (km_check_for_seckey (kmi->lv, l_idx, &i))
1120          case ID_KEYMISC_RECACHE:                      set_menu_state (popup, ID_KEYCTX_SETDEFKEY, MF_ENABLED);
1121              /* If there is already a reload request, don't bother the user with a message. */                  if (i == 0)
1122              if( keycache_get_reload() == 1 )                      set_menu_state (popup, ID_KEYCTX_MAXTRUST, MF_ENABLED);
1123                  idx = IDYES;                  if (!km_check_for_seckey (kmi->lv, l_idx, NULL)) {
1124              else {                      set_menu_state (popup, ID_KEYCTX_REV, MF_DISABLED|MF_GRAYED);
1125                  char t[256];                      set_menu_state (popup, ID_KEYCTX_ADDKEY, MF_DISABLED|MF_GRAYED);
1126                  _snprintf( t, sizeof t -1,                      set_menu_state (popup, ID_KEYCTX_ADDUID, MF_DISABLED|MF_GRAYED);
1127                             _("This is only useful when the keyring has been "                      set_menu_state (popup, ID_KEYCTX_ADDREV, MF_DISABLED|MF_GRAYED);
1128                               "modified (sign a key...).\n"                      set_menu_state (popup, ID_KEYCTX_ADDPHOTO, MF_DISABLED|MF_GRAYED );
1129                               "Do you really want to reload the keycache?") );                      set_menu_state (popup, ID_KEYCTX_SETPREFKS, MF_DISABLED|MF_GRAYED);
1130                  idx = msg_box( dlg, t, _("Key Manager"), MB_YESNO );                  }
1131              }                  else if (km_check_for_seckey (kmi->lv, l_idx, NULL) &&
1132              if( idx == IDYES ) {                           km_key_is_v3 (kmi->lv, l_idx)) {
1133                  rcs.kr_reload = rcs.kr_update = 1;                      /* PGP 2 keys, version 3 have no no support for photo-id's,
1134                  rcs.tr_update = 0;                         designated revokers and secondary keys. */
1135                  DialogBoxParam( glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, dlg,                      set_menu_state (popup, ID_KEYCTX_ADDKEY, MF_DISABLED|MF_GRAYED);
1136                                  keycache_dlg_proc, (LPARAM)&rcs );                      set_menu_state (popup, ID_KEYCTX_ADDREV, MF_DISABLED|MF_GRAYED);
1137                  c = keycache_get_ctx( 1 );                      set_menu_state (popup, ID_KEYCTX_ADDPHOTO, MF_DISABLED|MF_GRAYED);
1138                  if( !c )                  }
1139                      BUG( dlg );                  if (km_get_key_status( kmi->lv, l_idx ) & KM_FLAG_DISABLED)
1140                  keylist_reload( kmi->lv, c, KEYLIST_LIST, KEY_SORT_USERID );                      set_menu_state (popup, ID_KEYCTX_DISABLE, MF_DISABLED|MF_GRAYED);
1141                  refresh_keys = 0;                  else
1142              }                      set_menu_state (popup, ID_KEYCTX_ENABLE, MF_DISABLED|MF_GRAYED);
1143              return TRUE;                  if (km_get_key_status (kmi->lv, l_idx) & KM_FLAG_REVOKED ||
1144                                    km_get_key_status (kmi->lv, l_idx) & KM_FLAG_EXPIRED)
1145          case ID_KEYMISC_REBUILD:                      set_menu_state (popup, ID_KEYCTX_SIGN, MF_DISABLED|MF_GRAYED);
1146              rcs.kr_reload = rcs.kr_update = 0;                  if (!clip_contains_pgpkey ())
1147              rcs.tr_update = 1;                      set_menu_state (popup, ID_KEYCTX_PASTE, MF_DISABLED|MF_GRAYED);
1148              DialogBoxParam( glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, dlg,                  if (mapi_init ())
1149                              keycache_dlg_proc, (LPARAM)&rcs );                      set_menu_state (popup, ID_KEYCTX_SENDMAIL, MF_DISABLED|MF_GRAYED);
1150              c = keycache_get_ctx( 1 );                  /* Override 'Default Keyserver' with the actual name. */
1151              if( !c )                  host = kserver_get_hostname (0, -1, &port);
1152                  BUG( dlg );                  set_menu_text (popup, ID_KEYCTX_KS_DEFAULT, host);
1153              keylist_reload( kmi->lv, c, KEYLIST_LIST, KEY_SORT_USERID );                  popup_gpg_readonly (dlg, popup);
1154              return TRUE;                  if (listview_count_items (kmi->lv, 1) > 1)
1155                                    popup_multiple (dlg, popup);
1156          case ID_KEYMISC_NEWKEY:                  TrackPopupMenu (popup, TPM_RIGHTALIGN, p.x, p.y, 0, dlg, NULL);
1157              memset (&genkey, 0, sizeof (genkey));                  DestroyMenu (popup);
1158              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYGEN, dlg,                  DestroyMenu (hm);
1159                                keygen_dlg_proc, (LPARAM)&genkey, _("Key Generation"),                  return TRUE;
1160                                IDS_WINPT_KEYGEN);              }
1161              if (genkey.newkey != NULL)              break;
1162                  keylist_add_key (kmi->lv, KEYLIST_LIST, genkey.newkey);  
1163              return TRUE;          case LVN_COLUMNCLICK:
1164                if (notify->idFrom == IDC_KEYMISC_KEYLIST) {
1165          case ID_KEYMISC_CARDNEW:                  NMLISTVIEW *nft = (LPNMLISTVIEW) lparam;
1166              if( !scard_support ) {                  int sortby = 0;
1167                  msg_box( dlg, _("Smart Card support is not available."), _("Key Manager"), MB_INFO );                  switch (nft->iSubItem) {
1168                  return FALSE;                  case 0:  sortby = KEY_SORT_USERID; break;
1169              }                  case 1:  sortby = KEY_SORT_KEYID; break;
1170              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN, dlg,                  case 2:  sortby = KEY_SORT_IS_SECRET; break;
1171                                card_keygen_dlg_proc, NULL, _("Card Key Generation"),                  case 3:  sortby = KEY_SORT_LEN; break;
1172                                IDS_WINPT_CARD_KEYGEN );                  case 5:  sortby = KEY_SORT_VALIDITY; break;
1173              /* XXX: use new code */                  case 6:  sortby = KEY_SORT_OTRUST; break;
1174              if( keycache_get_reload() )                  case 7:  sortby = KEY_SORT_CREATED; break;
1175                  send_cmd_id( dlg, ID_KEYMISC_RECACHE );                  case 8:  sortby = KEY_SORT_ALGO; break;
1176              return TRUE;                  default: return TRUE; //sortby = KEY_SORT_USERID; break;
1177                    }
1178          case ID_KEYMISC_KEYWIZARD:  
1179              memset (&genkey, 0, sizeof (genkey));                  if ((kmi->keylist_sortby & ~KEYLIST_SORT_DESC) == sortby)
1180              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD, dlg,                      kmi->keylist_sortby ^= KEYLIST_SORT_DESC;
1181                                keygen_wizard_dlg_proc, (LPARAM)&genkey, _("Key Generation Wizard"),                  else
1182                                IDS_WINPT_KEYWIZARD);                      kmi->keylist_sortby = sortby;
1183              if (genkey.newkey != NULL)                  keylist_sort (kmi->lv, kmi->keylist_sortby);
1184                  keylist_add_key (kmi->lv, KEYLIST_LIST, genkey.newkey);                  return TRUE;
1185              return TRUE;              }
1186                            break;
1187          case ID_KEYMISC_SENDRECV:          }
1188              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_KEYSERVER, dlg,          break;
1189                                keyserver_dlg_proc, NULL, _("Keyserver Access"),  
1190                                IDS_WINPT_KEYSERVER );      case WM_WINDOWPOSCHANGING:
1191              return TRUE;          if (((WINDOWPOS*)lparam)->cx < 400)
1192                            ((WINDOWPOS*)lparam)->cx = 400;
1193          case ID_KEYMISC_GPGPREFS:          if (((WINDOWPOS*)lparam)->cy < 200)
1194              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_GPGPREFS, dlg,              ((WINDOWPOS*)lparam)->cy = 200;
1195                                gpgprefs_dlg_proc, NULL, _("GnuPG Preferences"),           return TRUE;
1196                                IDS_WINPT_GPGPREFS );          
1197              return TRUE;      case WM_SIZE:
1198                        do_resize_window (dlg, kmi);
1199          case ID_KEYMISC_GPGOPT:          return TRUE;
1200              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_GPGOPT, dlg,          
1201                                gpgopt_dlg_proc, NULL, _("GnuPG Options" ),      case WM_SYSCOMMAND:
1202                                IDS_WINPT_GPGOPT );          if (LOWORD (wparam) == SC_CLOSE)
1203              return TRUE;              EndDialog (dlg, TRUE);
1204                        return FALSE;
1205          case ID_KEYMISC_IMPORT:          
1206              t = get_filename_dlg (dlg, FILE_OPEN, _("Choose Name of the Key File"), NULL, NULL);      case WM_MENUSELECT:
1207              if (t)          change_edit_menu (kmi->lv, (HMENU)lparam, LOWORD (wparam));
1208                  km_file_import (dlg, t);          change_key_menu ((HMENU)lparam, LOWORD (wparam));
1209              return TRUE;          break;
1210    
1211          case ID_KEYMISC_IMPORT_HTTP:      case WM_INITMENUPOPUP:
1212              url = (struct URL_ctx_s*)get_http_file_dlg (dlg);          if ((UINT)LOWORD (lparam) == 3) {
1213              if (url->cancel == 0)              HMENU h = (HMENU)wparam;
1214                  km_http_import (dlg, url->url);              set_menu_text_bypos (h, 0, _("New"));
1215              delete url; url=NULL;          }
1216              break;          return FALSE;
1217                
1218          case ID_KEYMISC_EXPORT:      case WM_COMMAND:
1219              idx = listview_get_curr_pos (kmi->lv);          /* Allow at least 'Exit' in such a case. */
1220              if (idx == -1) {          if (gnupg_access_keyring (1) && LOWORD (wparam) != ID_KEYMISC_QUIT) {
1221                  msg_box( dlg, _("Please select a key."), _("Key Manager"), MB_ERR );              msg_box (dlg, _("Could not access public keyring"),
1222                  return FALSE;                       _("Key Manager"), MB_ERR);
1223              }              return FALSE;
1224              if (listview_count_items (kmi->lv, 1) > 1)          }
1225                  name = m_strdup ("Exported_GPG_Keys.asc");          do_check_cache (kmi->lv, dlg, kmi->statbar);
1226              else {          switch( LOWORD (wparam)) {
1227                  listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);          case ID_KEYMISC_QUIT:
1228                  name = gen_export_filename (keyid);              EndDialog (dlg, TRUE);
1229              }              return TRUE;
1230              t = get_filename_dlg (dlg, FILE_SAVE, _("Choose Name for Key File"), NULL, name);              
1231              free_if_alloc (name);          case ID_KEYMISC_MAIL:
1232              if (t != NULL)              /* XXX
1233                  return FALSE;              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_MAIL, GetDesktopWindow (),
1234              km_file_export (dlg, kmi->lv, t);                              winpt_mail_proc, NULL);*/
1235              return TRUE;              break;
1236                        
1237          case ID_KEYMISC_EXPORT_PRIVKEY:          case ID_KEYMISC_FIND:
1238              idx = listview_get_curr_pos( kmi->lv );              km_find_key (dlg, kmi->lv);
1239              if( idx == -1 ) {              break;
1240                  msg_box( dlg, _("Please select a key."), _("Key Manager"), MB_ERR );  
1241                  return FALSE;          case ID_KEYMISC_DELETE:
1242              }          case ID_KEYMISC_DELETE2:
1243              if( !km_check_for_seckey( kmi->lv, idx, NULL ) ) {              if (!km_delete_keys (kmi->lv, dlg))
1244                  msg_box( dlg, _("There is no corresponding secret key for this key."),                  km_update_status_bar (kmi->statbar, kmi->lv);
1245                          _("Key Manager"), MB_ERR );              return TRUE;
1246                  return FALSE;              
1247              }          case ID_KEYMISC_SIGN:
1248              if( listview_count_items( kmi->lv, 1 ) > 1 ) {              if (kmi->lv_idx == -1) {
1249                  msg_box( dlg, _("You can only export one secret key."), _("Key Manager"), MB_ERR );                  msg_box (dlg, _("Please select a key."),  
1250                  return FALSE;                           _("Key Manager"), MB_ERR);
1251              }                  return TRUE;
1252              idx = msg_box( dlg,              }
1253                            _("This operation will export your *SECRET* key!\n\n"              if (km_check_key_status (kmi->lv, kmi->lv_idx))
1254                              "Never send this key to ANYONE, it should be available\n"                  return TRUE;
1255                              "ONLY on your machine and you may use this function\n"              key = (gpgme_key_t)listview_get_item2 (kmi->lv, kmi->lv_idx);
1256                              "to copy the key to a safe place.\n\n"              memset (&k, 0, sizeof (k));
1257                              "Do you really want to export the key?"),              k.ctx = key;
1258                            _("WARNING"), MB_INFO|MB_YESNO );              k.keyid = key->subkeys->keyid;
1259              if( idx == IDYES ) {              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYSIGN, dlg,
1260                  idx = listview_get_curr_pos( kmi->lv );                                keysign_dlg_proc, (LPARAM)&k,
1261                  listview_get_item_text( kmi->lv, idx, 1, keyid, sizeof (keyid)-8 );                                _("Key Signing"), IDS_WINPT_KEYSIGN);
1262                  name = gen_export_filename (keyid);              if (k.update)
1263                  t = get_filename_dlg (dlg, FILE_SAVE, _("Choose Name for Key File"), NULL, name);                  update_key (kmi->lv, kmi->lv_idx, k.keyid, 0);
1264                  if (t != NULL)                        return TRUE;
1265                      km_privkey_export (dlg, kmi->lv, t);              
1266              }          case ID_KEYMISC_REVCERT:
1267              break;              if (kmi->lv_idx == -1) {
1268                    msg_box (dlg, _("Please select a key."), _("Key Manager"), MB_ERR);
1269          case ID_KEYMISC_INFO:                  return TRUE;
1270              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_ABOUT, glob_hwnd,              }
1271                                about_winpt_dlg_proc, NULL, _("About WinPT"),              listview_get_item_text (kmi->lv, kmi->lv_idx, 0, uid, sizeof uid-1);
1272                                IDS_WINPT_ABOUT );              listview_get_item_text (kmi->lv, kmi->lv_idx, 1, keyid, sizeof keyid-1);
1273              break;              if ( !km_check_for_seckey( kmi->lv, kmi->lv_idx, NULL ) ) {
1274                    msg_box (dlg, _("There is no secret key available!"),
1275          case ID_KEYMISC_HELP:                          _("Key Manager"), MB_ERR);
1276              ShellExecute (dlg, "open", "winpt.chm", NULL, NULL, SW_SHOW);                  return TRUE;
1277              break;              }
1278                
1279          case ID_KEYMISC_OT:              {
1280              dialog_box_param( glob_hinst, (LPCTSTR)IDD_WINPT_OWNERTRUST, glob_hwnd,                  char state[64];
1281                                ownertrust_dlg_proc, NULL,                  listview_get_item_text (kmi->lv, kmi->lv_idx, 5,
1282                                _("Ownertrust"), IDS_WINPT_OWNERTRUST );                                          state, sizeof (state) -1);
1283              break;                  if( strchr (state, 'R' )) {
1284                        msg_box (dlg, _("Key already revoked!"),
1285          case ID_KEYMISC_EDITKEY:                               _("Key Manager"), MB_INFO);
1286              idx = listview_get_curr_pos (kmi->lv);                      return TRUE;
1287              if (idx == -1)                  }
1288                  break;              }
1289              listview_get_item_text (kmi->lv, idx, 1, keyid, sizeof (keyid)-1);              
1290              /* XXX: pub/crd = secret key does not work */              memset (&k, 0, sizeof (k));
1291              memset (&k, 0, sizeof (k));              k.key_pair = 1;
1292              k.is_protected = km_check_if_protected (kmi->lv, idx);              k.keyid = keyid;
1293              k.key_pair = km_check_for_seckey (kmi->lv, idx, NULL);              k.is_protected = km_check_if_protected (kmi->lv, kmi->lv_idx);
1294              k.keyid = keyid;              dialog_box_param(glob_hinst, (LPCSTR)IDD_WINPT_KEYREVOKE, dlg,
1295              k.is_v3 = km_key_is_v3 (kmi->lv, idx);                               key_revoke_dlg_proc, (LPARAM)&k,
1296              k.flags = km_get_key_status (kmi->lv, idx);                               _("Key Revocation"), IDS_WINPT_KEYREVOKE);
1297              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYEDIT, dlg,              return TRUE;
1298                                keyedit_main_dlg_proc, (LPARAM)&k,              
1299                                _("Key Edit"), IDS_KEYCTX_EDIT);          case ID_KEYMISC_TRUSTPATH:
1300              if (k.update)              if (kmi->lv_idx == -1) {
1301                  update_key (kmi->lv,  idx, keyid, 1);                  msg_box (dlg, _("Please select a key."), _("Key Manager"), MB_ERR);
1302              break;                  return TRUE;
1303                            }
1304          case ID_KEYMISC_COPY:              listview_get_item_text( kmi->lv, kmi->lv_idx, 0, uid, sizeof uid -1 );
1305              km_index = listview_get_curr_pos (kmi->lv);              listview_get_item_text( kmi->lv, kmi->lv_idx, 1, keyid, sizeof keyid -1 );
1306              km_clip_export (dlg, kmi->lv);              if( km_check_for_seckey( kmi->lv, kmi->lv_idx, NULL ) ) {
1307              break;                  msg_box( dlg, _("It does not make any sense with a key pair!"), _("Key Manager"), MB_OK );
1308                                return TRUE;
1309          case ID_KEYMISC_SELALL:              }
1310              listview_select_all (kmi->lv);              memset (&k, 0, sizeof (k));
1311              break;              k.keyid = keyid;
1312                k.uid = uid;
1313          case ID_KEYMISC_PASTE:              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_KEYTRUST, dlg,
1314              km_index = -1;                                keytrust_dlg_proc, (LPARAM)&k,
1315              km_clip_import (dlg);                                _("List Trust Path"), IDS_WINPT_KEYTRUST );
1316              break;              return TRUE;
1317                            
1318          case ID_KEYCTX_SETPREFKS:          case ID_KEYMISC_CHECKSIGS:          
1319              listview_get_item_text (kmi->lv, idx, 1, keyid, DIM(keyid)-1);              if (kmi->lv_idx == -1) {
1320              memset (&k, 0, sizeof (k));                  msg_box (dlg, _("Please select a key."), _("Key Manager"), MB_ERR);
1321              k.keyid = keyid;                  return TRUE;
1322              keyedit_set_pref_keyserver (&k, dlg);              }
1323              break;              listview_get_item_text (kmi->lv, kmi->lv_idx, 0, uid, DIM (uid)-1);
1324                listview_get_item_text (kmi->lv, kmi->lv_idx, 1, keyid, DIM (keyid)-1);
1325          case ID_KEYMISC_REFRESH_KEYS:              memset (&k, 0, sizeof (k));
1326              if (listview_count_items (kmi->lv, 1) == 0) {              k.keyid = keyid;
1327                  msg_box (dlg, _("No key was selected, select all by default."), _("Key Manager"), MB_INFO);              k.uid = uid;
1328                  listview_select_all (kmi->lv);              k.ctx = (gpgme_key_t)listview_get_item2 (kmi->lv, kmi->lv_idx);
1329              }              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYSIG, dlg,
1330              km_refresh_from_keyserver (kmi->lv, dlg);                                keysig_dlg_proc, (LPARAM)&k,
1331              break;                                _("Key Signature List" ), IDS_WINPT_KEYSIG);
1332                                        return TRUE;
1333          /** Context menu **/              
1334          case ID_KEYCTX_EDIT:          case ID_KEYMISC_PROPS:      
1335              send_cmd_id( dlg, ID_KEYMISC_EDITKEY );              if (kmi->lv_idx == -1) {
1336              break;                  msg_box( dlg, _("Please select a key."), _("Key Manager"), MB_ERR );
1337                    return TRUE;
1338          case ID_KEYCTX_PROPS:              }
1339              send_cmd_id( dlg, ID_KEYMISC_PROPS );              listview_get_item_text (kmi->lv, kmi->lv_idx, 1, keyid, DIM (keyid)-1);
1340              break;              listview_get_item_text (kmi->lv, kmi->lv_idx, 2, type, DIM (type)-1);
1341                memset (&k, 0, sizeof (k));
1342          case ID_KEYCTX_UIDS:              k.key_pair = 0;
1343              send_cmd_id( dlg, ID_KEYMISC_UID );              k.keyid = keyid;
1344              break;              if( !strcmp( type, "pub/sec" ) || !strcmp( type, "pub/crd" ) )
1345                    k.key_pair = 1;
1346          case ID_KEYCTX_SIGN:              k.callback.ctl = kmi->lv;
1347              send_cmd_id( dlg, ID_KEYMISC_SIGN );              k.callback.idx = kmi->lv_idx;
1348              break;              k.is_v3 = km_key_is_v3 (kmi->lv, kmi->lv_idx);
1349                dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_KEYPROPS, dlg,
1350          case ID_KEYCTX_DEL:                                keyprops_dlg_proc, (LPARAM)&k,
1351              send_cmd_id (dlg, ID_KEYMISC_DELETE);                                _("Key Properties"), IDS_WINPT_KEYPROPS );
1352              break;              if (k.callback.new_val != 0) {
1353                    t = get_key_trust_str (k.callback.new_val);
1354          case ID_KEYCTX_REV:                  listview_add_sub_item (kmi->lv, kmi->lv_idx, 6, t);
1355              send_cmd_id( dlg, ID_KEYMISC_REVCERT );              }
1356              break;              return TRUE;
1357                
1358          case ID_KEYCTX_SENDMAIL:          case ID_KEYMISC_RECACHE:
1359              km_send_to_mail_recipient (kmi->lv, dlg);              /* If there is already a reload request, don't bother the user with a message. */
1360              break;              if (keycache_get_reload() == 1)
1361                    l_idx = IDYES;
1362          case ID_KEYCTX_KS_DEFAULT:              else {
1363              host = kserver_get_hostname (0, -1, &port);                  char inf[256];
1364              km_send_to_keyserver (kmi->lv, dlg, host, port);                  _snprintf (inf, sizeof (inf) -1,
1365              break;                             _("This is only useful when the keyring has been "
1366                                 "modified (sign a key...).\n"
1367          case ID_KEYCTX_ADDKEY:                               "Do you really want to reload the keycache?"));
1368              idx = listview_get_curr_pos (kmi->lv);                  l_idx = msg_box (dlg, inf, _("Key Manager"), MB_YESNO);
1369              listview_get_item_text( kmi->lv, idx, 1, keyid, DIM (keyid)-1);              }
1370              memset (&k, 0, sizeof (k));              if (l_idx == IDYES) {
1371              k.key_pair = km_check_for_seckey (kmi->lv, idx, NULL);                  rcs.kr_reload = rcs.kr_update = 1;
1372              k.is_protected = km_check_if_protected (kmi->lv, idx);                  rcs.tr_update = 0;
1373              k.keyid = keyid;                  DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, dlg,
1374              keyedit_add_subkey (&k, dlg, NULL);                                  keycache_dlg_proc, (LPARAM)&rcs);
1375              if (k.update)                  c = keycache_get_ctx (1);
1376                  update_key (kmi->lv, idx, keyid, 1);                  if (!c)
1377              break;                      BUG (dlg);
1378                    keylist_reload (kmi->lv, c, KEYLIST_LIST, KEY_SORT_USERID);
1379          case ID_KEYCTX_ADDUID:                  refresh_keys = 0;
1380              idx = listview_get_curr_pos (kmi->lv);              }
1381              listview_get_item_text( kmi->lv, idx, 1, keyid, DIM (keyid)-1);              return TRUE;
1382              memset (&k, 0, sizeof (k));              
1383              k.key_pair = km_check_for_seckey (kmi->lv, idx, NULL);          case ID_KEYMISC_REBUILD:
1384              k.is_protected = km_check_if_protected (kmi->lv, idx);              name = NULL;
1385              k.keyid = keyid;              gpg_rebuild_cache (&name);
1386              keyedit_add_userid (&k, dlg, NULL);              if (name != NULL) {
1387              if (k.update)                  char *line = strchr (name, '\n');
1388                  update_key (kmi->lv, idx, keyid, 1);                  show_msg (dlg, 2000, line? name + (line-name)+1 : name);
1389              break;                  safe_free (name);
1390                }
1391          case ID_KEYCTX_ADDREV:              return TRUE;
1392              idx = listview_get_curr_pos (kmi->lv);              
1393              listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);          case ID_KEYMISC_NEWKEY:
1394              memset (&k, 0, sizeof (k));              memset (&genkey, 0, sizeof (genkey));
1395              k.keyid = keyid;              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYGEN, dlg,
1396              k.is_protected = km_check_if_protected (kmi->lv, idx);                                keygen_dlg_proc, (LPARAM)&genkey, _("Key Generation"),
1397              k.key_pair = km_check_for_seckey( kmi->lv, idx, NULL );                                IDS_WINPT_KEYGEN);
1398              keyedit_add_revoker (&k, dlg);              if (genkey.newkey != NULL) {
1399              if (k.update)                  keylist_add_key (kmi->lv, KEYLIST_LIST, genkey.newkey);
1400                  update_key (kmi->lv, idx, keyid, 1);                  keylist_sort (kmi->lv, KEY_SORT_USERID);
1401              break;              }
1402                return TRUE;
1403          case ID_KEYCTX_ADDPHOTO:  
1404              idx = listview_get_curr_pos (kmi->lv);          case ID_KEYMISC_CARDNEW:
1405              listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);              if (!scard_support) {
1406              memset (&k, 0, sizeof (k));                  msg_box (dlg, _("Smart Card support is not available."),
1407              k.keyid = keyid;                           _("Key Manager"), MB_INFO);
1408              k.is_protected = km_check_if_protected (kmi->lv, idx);                  return TRUE;
1409              k.key_pair = km_check_for_seckey (kmi->lv, idx, NULL);              }
1410              keyedit_add_photo (&k, dlg);              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN, dlg,
1411              if (k.update)                                card_keygen_dlg_proc, 0, _("Card Key Generation"),
1412                  update_key (kmi->lv, idx, keyid, 1);                                IDS_WINPT_CARD_KEYGEN);
1413              break;              /* XXX: use new code */
1414                if (keycache_get_reload ())
1415          case ID_KEYCTX_KS_NL:                  send_cmd_id (dlg, ID_KEYMISC_RECACHE);
1416          case ID_KEYCTX_KS_PL:              return TRUE;
1417          case ID_KEYCTX_KS_AT:  
1418          case ID_KEYCTX_KS_DE:          case ID_KEYMISC_KEYWIZARD:
1419          case ID_KEYCTX_KS_DK:              memset (&genkey, 0, sizeof (genkey));
1420          case ID_KEYCTX_KS_CZ:              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD, dlg,
1421          case ID_KEYCTX_KS_ES:                                keygen_wizard_dlg_proc, (LPARAM)&genkey,
1422          case ID_KEYCTX_KS_UK:                                _("Key Generation Wizard"),
1423              host = kserver_get_hostname (LOWORD (wparam) - 40107, 0, &port);                                IDS_WINPT_KEYWIZARD);
1424              km_send_to_keyserver (kmi->lv, dlg, host, port);              if (genkey.newkey != NULL) {
1425              break;                  keylist_add_key (kmi->lv, KEYLIST_LIST, genkey.newkey);
1426                    keylist_sort (kmi->lv, KEY_SORT_USERID);
1427          case ID_KEYCTX_RECVFROM:              }
1428              km_refresh_from_keyserver (kmi->lv, dlg);              return TRUE;
1429              break;              
1430            case ID_KEYMISC_SENDRECV:
1431          case ID_KEYCTX_UID_COPY:              memset (&genkey, 0, sizeof (genkey));
1432              /* XXX: add generic function to support multiple selection              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYSERVER, dlg,
1433                      with a callback */                                keyserver_dlg_proc, (LPARAM)&genkey, _("Keyserver Access"),
1434              idx = listview_get_curr_pos( kmi->lv );                                IDS_WINPT_KEYSERVER);
1435              listview_get_item_text( kmi->lv, idx, 0, uid, sizeof uid-1 );              if (genkey.newkey != NULL) {
1436              set_clip_text( NULL, uid, strlen( uid ) );                  keylist_add_key (kmi->lv, KEYLIST_LIST, genkey.newkey);
1437              break;                  keylist_sort (kmi->lv, KEY_SORT_USERID);
1438                }
1439          case ID_KEYCTX_KEYID_COPY:              return TRUE;
1440              idx = listview_get_curr_pos( kmi->lv );              
1441              listview_get_item_text( kmi->lv, idx, 1, uid, sizeof uid-1 );          case ID_KEYMISC_GPGPREFS:
1442              set_clip_text( NULL, uid, strlen( uid ) );              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_GPGPREFS, dlg,
1443              break;                                gpgprefs_dlg_proc, 0, _("GnuPG Preferences"),
1444                                  IDS_WINPT_GPGPREFS );
1445          case ID_KEYCTX_FPR_COPY:              return TRUE;
1446              idx = listview_get_curr_pos( kmi->lv );              
1447              key = (gpgme_key_t) listview_get_item2 (kmi->lv, idx);                  case ID_KEYMISC_GPGOPT:
1448              if (key) {              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_GPGOPT, dlg,
1449                  const char * s = get_key_fpr (key);                                gpgopt_dlg_proc, 0, _("GnuPG Options" ),
1450                  set_clip_text (NULL, s? s : "", s? strlen (s): 0);                                IDS_WINPT_GPGOPT );
1451              }              return TRUE;
1452              break;              
1453            case ID_KEYMISC_IMPORT:
1454          case ID_KEYCTX_KINFO_COPY:              t = get_fileopen_dlg (dlg, _("Choose Name of the Key File"), NULL, NULL);
1455              idx = listview_get_curr_pos( kmi->lv );              if (t)
1456              listview_get_item_text( kmi->lv, idx, 1, uid, sizeof uid-1 );                  km_file_import (dlg, t);
1457              km_set_clip_info( uid );                      return TRUE;
1458              break;  
1459            case ID_KEYMISC_IMPORT_HTTP:
1460          case ID_KEYCTX_COPY:              url = (struct URL_ctx_s*)get_http_file_dlg (dlg);
1461              km_index = listview_get_curr_pos (kmi->lv);              if (url->cancel == 0)
1462              km_clip_export (dlg, kmi->lv);                  km_http_import (dlg, url->url);
1463              break;              delete url; url=NULL;
1464                break;
1465          case ID_KEYCTX_PASTE:                
1466              km_index = -1;          case ID_KEYMISC_EXPORT:
1467              km_clip_import (dlg);              if (kmi->lv_idx == -1) {
1468              break;                  msg_box( dlg, _("Please select a key."), _("Key Manager"), MB_ERR );
1469                    return TRUE;
1470          case ID_KEYCTX_DISABLE:              }
1471              idx = listview_get_curr_pos (kmi->lv);              if (listview_count_items (kmi->lv, 1) > 1)
1472              km_enable_disable_key (kmi->lv, dlg, idx, 0);                  name = m_strdup ("Exported_GPG_Keys.asc");
1473              break;              else {
1474                    listview_get_item_text (kmi->lv, kmi->lv_idx, 1, keyid, DIM (keyid)-1);
1475          case ID_KEYCTX_ENABLE:                  name = gen_export_filename (keyid, 0);
1476              idx = listview_get_curr_pos (kmi->lv);              }
1477              km_enable_disable_key (kmi->lv, dlg, idx, 1);              t = get_filesave_dlg (dlg, _("Choose Name for Key File"), NULL, name);
1478              break;              free_if_alloc (name);
1479                if (t == NULL)
1480          case ID_KEYCTX_LISTSIGS:                  return TRUE;
1481              send_cmd_id (dlg, ID_KEYMISC_CHECKSIGS);              km_file_export (dlg, kmi->lv, t);
1482              break;              return TRUE;
1483                
1484          case ID_KEYCTX_MAXTRUST:          case ID_KEYMISC_EXPORT_PRIVKEY:
1485              idx = listview_get_curr_pos (kmi->lv);              if (kmi->lv_idx == -1) {
1486              listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);                  msg_box (dlg, _("Please select a key."), _("Key Manager"), MB_ERR);
1487              rc = km_set_implicit_trust (dlg, kmi->lv, idx);                  return TRUE;
1488              if (!rc)              }
1489                  update_key (kmi->lv, idx, keyid, 0);              if( !km_check_for_seckey( kmi->lv, kmi->lv_idx, NULL ) ) {
1490              break;                  msg_box (dlg, _("There is no corresponding secret key for this key."),
1491                             _("Key Manager"), MB_ERR);
1492          case ID_KEYCTX_SETDEFKEY:                  return TRUE;
1493              idx = listview_get_curr_pos (kmi->lv);              }
1494              if (!km_check_key_status (kmi->lv, idx)) {              if (listview_count_items (kmi->lv, 1) > 1) {
1495                  listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);                  msg_box (dlg, _("You can only export one secret key."),
1496                  rc = set_gnupg_default_key (keyid);                           _("Key Manager"), MB_ERR);
1497                  if (rc)                  return TRUE;
1498                      msg_box( dlg, winpt_strerror (rc), _("Key Manager"), MB_ERR);              }
1499                  km_update_default_key_str (kmi->statbar);              i = msg_box (dlg,
1500              }                            _("This operation will export your *SECRET* key!\n\n"
1501              break;                              "Never send this key to ANYONE, it should be available\n"
1502                                "ONLY on your machine and you may use this function\n"
1503          #if 0 /* XXX */                              "to copy the key to a safe place.\n\n"
1504          case ID_GROUP_NEW:                              "Do you really want to export the key?"),
1505              memset (&gcb, 0, sizeof (gcb));                            _("WARNING"), MB_INFO|MB_YESNO);
1506              gcb.gc = gc;              if( i == IDYES ) {
1507              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_GROUP, glob_hwnd,                  listview_get_item_text( kmi->lv, kmi->lv_idx, 1, keyid, sizeof (keyid)-8 );
1508                               group_manager_dlg_proc, (LPARAM)&gcb, _("New Group"),                  name = gen_export_filename (keyid, 1);
1509                               IDS_WINPT_GROUP);                  t = get_filesave_dlg (dlg, _("Choose Name for Key File"), NULL, name);
1510              if( gcb.use_name )                  if (t != NULL)          
1511                  treeview_add_item( GetDlgItem(dlg, IDC_KEYMISC_GROUP), NULL, gcb.name );                      km_privkey_export (dlg, kmi->lv, t);
1512              return TRUE;              }
1513                            return TRUE;
1514          case ID_GROUP_PASTE:  
1515              km_groups_add (gc, kmi->lv, km_index);          case ID_KEYMISC_INFO:
1516              break;              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_ABOUT, glob_hwnd,
1517                                              about_winpt_dlg_proc, 0, _("About WinPT"),
1518          case ID_GROUP_DELETE:                                IDS_WINPT_ABOUT);
1519              km_groups_del (gc);              break;
1520              break;  
1521          #endif          case ID_KEYMISC_HELP:
1522          }              ShellExecute (dlg, "open", "winpt.chm", NULL, NULL, SW_SHOW);
1523                        break;
1524          break;  
1525      }          case ID_KEYMISC_OT:
1526                    dialog_box_param( glob_hinst, (LPCTSTR)IDD_WINPT_OWNERTRUST, glob_hwnd,
1527      return FALSE;                                ownertrust_dlg_proc, 0,
1528  } /* keymanager_dlg_proc */                                _("Ownertrust"), IDS_WINPT_OWNERTRUST );
1529                break;
1530    
1531            case ID_KEYMISC_EDITKEY:          
1532                if (kmi->lv_idx == -1)
1533                    break;
1534                listview_get_item_text (kmi->lv, kmi->lv_idx, 1, keyid, sizeof (keyid)-1);
1535                /* XXX: pub/crd = secret key does not work */
1536                memset (&k, 0, sizeof (k));
1537                k.is_protected = km_check_if_protected (kmi->lv, kmi->lv_idx);
1538                k.key_pair = km_check_for_seckey (kmi->lv, kmi->lv_idx, NULL);
1539                k.keyid = keyid;
1540                k.is_v3 = km_key_is_v3 (kmi->lv, kmi->lv_idx);
1541                k.flags = km_get_key_status (kmi->lv, kmi->lv_idx);
1542                dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYEDIT, dlg,
1543                                  keyedit_main_dlg_proc, (LPARAM)&k,
1544                                  _("Key Edit"), IDS_KEYCTX_EDIT);
1545                if (k.update)
1546                    update_key (kmi->lv,  kmi->lv_idx, keyid, 1);
1547                break;
1548                
1549            case ID_KEYMISC_COPY:
1550                km_clip_export (dlg, kmi->lv);
1551                break;
1552                
1553            case ID_KEYMISC_SELALL:
1554                listview_select_all (kmi->lv);
1555                break;
1556    
1557            case ID_KEYMISC_PASTE:
1558                km_clip_import (dlg);
1559                break;
1560                
1561            case ID_KEYCTX_SETPREFKS:
1562                listview_get_item_text (kmi->lv, kmi->lv_idx, 1, keyid, DIM(keyid)-1);
1563                memset (&k, 0, sizeof (k));
1564                k.keyid = keyid;
1565                keyedit_set_pref_keyserver (&k, dlg);
1566                break;
1567    
1568            case ID_KEYMISC_REFRESH_KEYS:
1569                if (listview_count_items (kmi->lv, 1) == 0) {
1570                    msg_box (dlg, _("No key was selected, select all by default."),
1571                             _("Key Manager"), MB_INFO);
1572                    listview_select_all (kmi->lv);
1573                }
1574                km_refresh_from_keyserver (kmi->lv, dlg);
1575                break;
1576                            
1577            /** Context menu **/
1578            case ID_KEYCTX_EDIT:
1579                send_cmd_id( dlg, ID_KEYMISC_EDITKEY );
1580                break;
1581    
1582            case ID_KEYCTX_PROPS:
1583                send_cmd_id( dlg, ID_KEYMISC_PROPS );
1584                break;
1585    
1586            case ID_KEYCTX_UIDS:
1587                send_cmd_id( dlg, ID_KEYMISC_UID );
1588                break;
1589    
1590            case ID_KEYCTX_SIGN:
1591                send_cmd_id( dlg, ID_KEYMISC_SIGN );
1592                break;
1593    
1594            case ID_KEYCTX_DEL:
1595                send_cmd_id (dlg, ID_KEYMISC_DELETE);
1596                break;
1597    
1598            case ID_KEYCTX_REV:
1599                send_cmd_id( dlg, ID_KEYMISC_REVCERT );
1600                break;
1601    
1602            case ID_KEYCTX_SENDMAIL:
1603                km_send_to_mail_recipient (kmi->lv, dlg);
1604                break;
1605    
1606            case ID_KEYCTX_KS_DEFAULT:
1607                host = kserver_get_hostname (0, -1, &port);
1608                km_send_to_keyserver (kmi->lv, dlg, host, port);
1609                break;
1610    
1611            case ID_KEYCTX_ADDKEY:
1612                listview_get_item_text (kmi->lv, kmi->lv_idx, 1, keyid, DIM (keyid)-1);
1613                memset (&k, 0, sizeof (k));
1614                k.key_pair = km_check_for_seckey (kmi->lv, kmi->lv_idx, NULL);
1615                k.is_protected = km_check_if_protected (kmi->lv, kmi->lv_idx);
1616                k.keyid = keyid;
1617                keyedit_add_subkey (&k, dlg, NULL);
1618                if (k.update)
1619                    update_key (kmi->lv, kmi->lv_idx, keyid, 1);
1620                break;
1621    
1622            case ID_KEYCTX_ADDUID:
1623                listview_get_item_text( kmi->lv, kmi->lv_idx, 1, keyid, DIM (keyid)-1);
1624                memset (&k, 0, sizeof (k));
1625                k.key_pair = km_check_for_seckey (kmi->lv, kmi->lv_idx, NULL);
1626                k.is_protected = km_check_if_protected (kmi->lv, kmi->lv_idx);
1627                k.keyid = keyid;
1628                keyedit_add_userid (&k, dlg, NULL);
1629                if (k.update)
1630                    update_key (kmi->lv, kmi->lv_idx, keyid, 1);
1631                break;
1632    
1633            case ID_KEYCTX_ADDREV:
1634                listview_get_item_text (kmi->lv, kmi->lv_idx, 1, keyid, DIM (keyid)-1);
1635                memset (&k, 0, sizeof (k));
1636                k.keyid = keyid;
1637                k.is_protected = km_check_if_protected (kmi->lv, kmi->lv_idx);
1638                k.key_pair = km_check_for_seckey( kmi->lv, kmi->lv_idx, NULL );
1639                keyedit_add_revoker (&k, dlg);
1640                if (k.update)
1641                    update_key (kmi->lv, kmi->lv_idx, keyid, 1);
1642                break;
1643    
1644            case ID_KEYCTX_ADDPHOTO:
1645                listview_get_item_text (kmi->lv, kmi->lv_idx, 1, keyid, DIM (keyid)-1);
1646                memset (&k, 0, sizeof (k));
1647                k.keyid = keyid;
1648                k.is_protected = km_check_if_protected (kmi->lv, kmi->lv_idx);
1649                k.key_pair = km_check_for_seckey (kmi->lv, kmi->lv_idx, NULL);
1650                keyedit_add_photo (&k, dlg);
1651                if (k.update)
1652                    update_key (kmi->lv, kmi->lv_idx, keyid, 1);
1653                break;
1654    
1655            case ID_KEYCTX_KS_NL:
1656            case ID_KEYCTX_KS_PL:
1657            case ID_KEYCTX_KS_AT:
1658            case ID_KEYCTX_KS_DE:
1659            case ID_KEYCTX_KS_DK:
1660            case ID_KEYCTX_KS_CZ:
1661            case ID_KEYCTX_KS_ES:
1662            case ID_KEYCTX_KS_UK:
1663                host = kserver_get_hostname (LOWORD (wparam) - 40107, 0, &port);
1664                km_send_to_keyserver (kmi->lv, dlg, host, port);
1665                break;
1666    
1667            case ID_KEYCTX_RECVFROM:
1668                km_refresh_from_keyserver (kmi->lv, dlg);
1669                break;
1670    
1671            case ID_KEYCTX_UID_COPY:
1672                /* XXX: add generic function to support multiple selection
1673                        with a callback */
1674                listview_get_item_text( kmi->lv, kmi->lv_idx, 0, uid, sizeof uid-1 );
1675                set_clip_text( NULL, uid, strlen( uid ) );
1676                break;
1677    
1678            case ID_KEYCTX_KEYID_COPY:
1679                listview_get_item_text (kmi->lv, kmi->lv_idx, 1, uid, sizeof uid-1);
1680                set_clip_text (NULL, uid, strlen (uid));
1681                break;
1682    
1683            case ID_KEYCTX_FPR_COPY:
1684                key = (gpgme_key_t) listview_get_item2 (kmi->lv, kmi->lv_idx);        
1685                if (key) {
1686                    t = get_key_fpr (key);
1687                    set_clip_text (NULL, t? t : "", t? strlen (t): 0);
1688                }
1689                break;
1690    
1691            case ID_KEYCTX_KINFO_COPY:
1692                listview_get_item_text( kmi->lv, kmi->lv_idx, 1, uid, sizeof uid-1 );
1693                km_set_clip_info( uid );        
1694                break;
1695    
1696            case ID_KEYCTX_COPY:
1697                km_clip_export (dlg, kmi->lv);
1698                break;
1699    
1700            case ID_KEYCTX_PASTE:
1701                km_clip_import (dlg);
1702                break;
1703    
1704            case ID_KEYCTX_DISABLE:
1705            case ID_KEYCTX_ENABLE:
1706                i = LOWORD (wparam) == ID_KEYCTX_ENABLE? 1 : 0;
1707                listview_get_item_text (kmi->lv, kmi->lv_idx, KM_COL_KEYID,
1708                                        keyid, DIM (keyid)-1);
1709                rc = km_enable_disable_key (kmi->lv, dlg, kmi->lv_idx, i);
1710                if (!rc)
1711                    update_key (kmi->lv, kmi->lv_idx, keyid, 0);
1712                /* XXX: switching a key from disabled -> enabled. does not
1713                   change the validity field in the KM. */
1714                break;
1715    
1716            case ID_KEYCTX_LISTSIGS:
1717                send_cmd_id (dlg, ID_KEYMISC_CHECKSIGS);
1718                break;
1719    
1720            case ID_KEYCTX_MAXTRUST:
1721                listview_get_item_text (kmi->lv, kmi->lv_idx, 1, keyid, DIM (keyid)-1);
1722                rc = km_set_implicit_trust (dlg, kmi->lv, kmi->lv_idx);
1723                if (!rc)
1724                    update_key (kmi->lv, kmi->lv_idx, keyid, 0);
1725                break;
1726    
1727            case ID_KEYCTX_SETDEFKEY:
1728                if (!km_check_key_status (kmi->lv, kmi->lv_idx)) {
1729                    listview_get_item_text (kmi->lv, kmi->lv_idx, 1, keyid, DIM (keyid)-1);
1730                    rc = set_gnupg_default_key (keyid);
1731                    if (rc)
1732                        msg_box (dlg, winpt_strerror (rc), _("Key Manager"), MB_ERR);
1733                    km_update_default_key_str (kmi->statbar);
1734                }
1735                break;
1736    
1737            case ID_GROUP_NEW:
1738            case ID_GROUP_PASTE:
1739            case ID_GROUP_DELETE:
1740                /* XXX: Implement group manager. */
1741                return TRUE;
1742            }
1743            
1744            break;
1745        }
1746        
1747        return FALSE;
1748    }
Legend:
Removed from v.23  
changed lines
  Added in v.128
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26