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

Legend:
Removed from v.28  
changed lines
  Added in v.129

[email protected]
ViewVC Help
Powered by ViewVC 1.1.26