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