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

Legend:
Removed from v.30  
changed lines
  Added in v.168

[email protected]
ViewVC Help
Powered by ViewVC 1.1.26