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

Diff of /trunk/Src/wptKeyManagerDlg.cpp

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

revision 28 by twoaday, Thu Oct 20 12:35:59 2005 UTC revision 447 by twoaday, Mon Apr 16 19:42:28 2012 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  void  /* Return true if the clipboard contains an OpenPGP key. */
472  update_ui_items (HWND hwnd, listview_ctrl_t lv)  static bool
473  {  clip_contains_pgpkey (void)
474      int key_selected = 0, key_has_sec = 0;  {
475      int i, key_inv = 0;      char *ctxt;
476      HWND hwnd_child;      bool val;
477      HMENU hmenu;  
478            val = false;
479      /* Get some states */      ctxt = get_clip_text (NULL);
480      key_selected = SendMessage (GetDlgItem (hwnd, IDC_KEYMISC_KEYLIST),      if (!ctxt || strlen (ctxt) < 512)
481                                             LVM_GETSELECTEDCOUNT, 0, 0)          val = false;
482                                             ? TRUE : FALSE;      else if (strstr (ctxt, "BEGIN PGP") && strstr (ctxt, "KEY BLOCK") &&
483      key_has_sec = FALSE;               strstr (ctxt, "END PGP"))
484      if (key_selected) {          val = true;
485          i = listview_get_curr_pos (lv);      free_if_alloc (ctxt);
486          key_has_sec = km_check_for_seckey( lv, i, NULL ) ? TRUE : FALSE;              return val;
487          key_inv = km_get_key_status (lv, i) & KM_FLAG_REVOKED;  }
488      }  
489    
490      /* Enable / disable toolbar buttons */  /* Show a mini popup menu to import keys. */
491      hwnd_child = GetDlgItem(hwnd, IDR_WINPT_KMTB);  static void
492      enable_button (hwnd_child, ID_KEYMISC_DELETE);  do_create_minpopup (HWND dlg)
493      enable_button (hwnd_child, ID_KEYMISC_PROPS);  {
494      enable_button (hwnd_child, ID_KEYMISC_SIGN);      HMENU hm;
495      enable_button (hwnd_child, ID_KEYMISC_EXPORT);      POINT p;
496        
497      /* Enable / disable menu items */      if (gpg_read_only || !clip_contains_pgpkey ())
498      hmenu = GetMenu (hwnd);          return;
499      set_menu_state (hmenu, ID_KEYMISC_EXPORT, key_selected ? MF_ENABLED : MF_GRAYED);      hm = CreatePopupMenu ();
500      set_menu_state (hmenu, ID_KEYMISC_EXPORT_PRIVKEY, key_has_sec ? MF_ENABLED : MF_GRAYED);      insert_menu_item (hm, 0, ID_KEYCTX_PASTE, _("Paste Key from Clipboard..."));
501      set_menu_state (hmenu, ID_KEYMISC_REVCERT, key_has_sec ? MF_ENABLED : MF_GRAYED);      GetCursorPos (&p);
502      set_menu_state (hmenu, ID_KEYMISC_DELETE, key_selected ? MF_ENABLED : MF_GRAYED);      TrackPopupMenu (hm, 0, p.x, p.y, 0, dlg, NULL);
503      set_menu_state (hmenu, ID_KEYMISC_PROPS, key_selected ? MF_ENABLED : MF_GRAYED);      DestroyMenu (hm);
504      set_menu_state (hmenu, ID_KEYMISC_SIGN, key_selected && !key_inv ? MF_ENABLED : MF_GRAYED);  }
505      set_menu_state (hmenu, ID_KEYMISC_EDITKEY, key_selected? MF_ENABLED : MF_GRAYED);  
506      set_menu_state (hmenu, ID_KEYMISC_CHECKSIGS, key_selected? MF_ENABLED : MF_GRAYED);  
507  } /* update_ui_items */  /* Update the default key entry in the status bar for dialog @dlg. */
508    void
509    update_default_key_str (HWND dlg)
510  static void  {
511  popup_gpg_readonly (HWND dlg, HMENU hm)      const char *fmt;
512  {      char *keyid;
513      int resids[] = {      char defkeyinf[128];
514          ID_KEYCTX_PASTE,  
515          ID_KEYCTX_EDIT,      keyid = get_gnupg_default_key ();
516          ID_KEYCTX_SIGN,      if (!keyid)
517          ID_KEYCTX_REV,          return;
518          ID_KEYCTX_DEL,      if ((keyid[0] >= 'A' && keyid[0] <= 'Z') ||
519          ID_KEYCTX_ENABLE,          (keyid[0] >= 'a' && keyid[0] <= 'z') ||
520          ID_KEYCTX_DISABLE,          (keyid[0] == '0' && keyid[1] == 'x'))
521          ID_KEYCTX_RECVFROM,          fmt = _("Default Key: %s");
522          ID_KEYCTX_ADDKEY,      else
523          ID_KEYCTX_ADDPHOTO,          fmt = _("Default Key: 0x%s");
524          ID_KEYCTX_ADDUID,      _snprintf (defkeyinf, sizeof (defkeyinf) - 1, fmt, keyid);
525          ID_KEYCTX_ADDREV,      SendMessage (dlg, SB_SETTEXT, 0, (LPARAM)defkeyinf);
526          0      gpg_keycache_set_default_key (keycache_get_ctx (0), keyid);
527      };      free_if_alloc (keyid);
528      int i;  }
529    
530      if (gpg_read_only == 0)  
531          return;  /* Count all keys and show from @lv results in the status bar @sb. */
532      for (i=0; resids[i] != 0; i++)  void
533          set_menu_state (hm, resids[i], MF_GRAYED);  update_status_bar (HWND sb, listview_ctrl_t lv)
534  }  {
535        char txt[256];
536        int nkeys, nsec;
537  static void  
538  menu_gpg_readonly (HWND dlg, HMENU hm, int id)      nkeys = listview_count_items (lv, 0);
539  {      _snprintf (txt, DIM (txt)-1, _("%d keys"), nkeys);
540      int key_resids[] = {      SendMessage (sb, SB_SETTEXT, 2, (LPARAM)txt);
541          ID_KEYMISC_SIGN,      
542          ID_KEYMISC_DELETE,      nsec = gpg_keycache_get_size (keycache_get_ctx (0));
543          ID_KEYMISC_REVCERT,      _snprintf (txt, DIM (txt)-1, _("%d secret keys"), nsec);    
544          ID_KEYMISC_IMPORT_HTTP,      SendMessage (sb, SB_SETTEXT, 1, (LPARAM)txt);    
545          ID_KEYMISC_IMPORT,  }
546          ID_KEYMISC_REFRESH_KEYS,  
547          ID_KEYMISC_REBUILD,  
548          ID_KEYMISC_KEYWIZARD,  long CALLBACK
549          ID_KEYMISC_CARDNEW,  separator_wnd_proc (HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam)
550          ID_KEYMISC_NEWKEY,  {
551          0,      static POINT last_mouse_pos;
552      };      PAINTSTRUCT ps;
553      int edit_resids[] = {      RECT rect;
554          ID_KEYMISC_PASTE,      HPEN hpen;
555          ID_KEYMISC_OT,  
556          ID_KEYMISC_EDITKEY,      if (msg == WM_CREATE)
557          0          SetWindowLong (hwnd, GWL_USERDATA,
558      };                         (long)(((CREATESTRUCT*)lparam)->lpCreateParams));
559      int * resids;  
560      int i;      switch (msg) {
561        case WM_PAINT:
562                GetClientRect (hwnd, &rect);
563      if (gpg_read_only == 0)          BeginPaint (hwnd, &ps);
564          return;  
565      switch (id) {          /* Background */
566      case 0: return;          FillRect (ps.hdc, &rect, (HBRUSH)(COLOR_3DFACE+1));
567      case 3: resids = key_resids; break;  
568      case 1: resids = edit_resids;break;          /* The lines from the light into the dark */
569      }          MoveToEx (ps.hdc, 0,0, NULL);
570            hpen = CreatePen (PS_SOLID, 0, GetSysColor (COLOR_3DHILIGHT));
571      for (i=0; resids[i] != 0; i++)          if (hpen != NULL) {
572          set_menu_state (hm, resids[i], MF_GRAYED);              SelectObject (ps.hdc, (LPVOID)hpen);
573  }              LineTo (ps.hdc, rect.right, 0);
574                DeleteObject (hpen);
575            }
576  static char*          MoveToEx (ps.hdc, 0, 1, NULL);
577  gen_export_filename (const char *keyid, int is_secret)          hpen = CreatePen (PS_SOLID, 0, GetSysColor (COLOR_3DLIGHT));
578  {          if (hpen != NULL) {
579      gpgme_key_t key;               SelectObject (ps.hdc, (LPVOID)hpen);
580      const char *s;               LineTo (ps.hdc, rect.right, rect.bottom);
581      char *p;               DeleteObject (hpen);
582             }
583      if (get_pubkey (keyid, &key))  
584          return m_strdup (keyid);          MoveToEx (ps.hdc, 0, rect.bottom-1, NULL);
585      s = key->uids->name;          hpen = CreatePen (PS_SOLID, 0, GetSysColor(COLOR_3DSHADOW));
586      if (!s)          if (hpen != NULL) {
587          return m_strdup (keyid);              SelectObject (ps.hdc, (LPVOID)hpen);
588      p = new char[strlen (s) + 8 + 16];              LineTo (ps.hdc, rect.right, rect.bottom-1);
589      if (!p)              DeleteObject (hpen);
590          BUG (0);          }
591      sprintf (p, "%s%s.asc", s, is_secret? "_sec" : "");          MoveToEx (ps.hdc, 0, rect.bottom, NULL);
592      for (size_t i=0; i < strlen (p); i++) {          hpen = CreatePen(PS_SOLID, 0, GetSysColor (COLOR_3DDKSHADOW));
593          if (p[i] == ' ' || p[i] == ':' || p[i] == '?' || p[i] == '|')          if (hpen != NULL) {
594              p[i] = '_';              SelectObject (ps.hdc, (LPVOID)hpen);
595      }              LineTo (ps.hdc, rect.right, rect.bottom);
596      return p;              DeleteObject (hpen);
597  }          }
598    
599            EndPaint (hwnd, &ps);
600  static void          return 0;
601  update_key (listview_ctrl_t lv, int pos, const char *keyid, int keypair)  
602  {      case WM_LBUTTONDOWN:
603      gpgme_key_t key;          last_mouse_pos.x = LOWORD (lparam);
604            last_mouse_pos.y = HIWORD (lparam);
605      keycache_update (0, keyid);          ClientToScreen (hwnd, &last_mouse_pos);
606      if (keypair)          SetCapture (hwnd);
607          keycache_update (1, keyid);          return 0;
608    
609      /* because we replaced the key item, we need to update the      case WM_LBUTTONUP:
610         address of the pointer in the ListView control. */          ReleaseCapture ();
611      get_pubkey (keyid, &key);          return 0;
612      keylist_upd_key (lv, pos, key);  
613  }      case WM_MOUSEMOVE:
614            if (wparam == MK_LBUTTON) {
615                struct km_info_s *kmi;
616  /* Setup status bar for the main window @dlg. */              POINT p;
617  static HWND  
618  setup_status_bar (HWND dlg, listview_ctrl_t lv)              kmi = (struct km_info_s *)GetWindowLong (hwnd, GWL_USERDATA);
619  {                    if (kmi == NULL)
620      HWND statbar;                      break;
621      RECT r;  
622      int partpos[3];              /* Calculate mouse movement */
623      int i;              p.x = LOWORD (lparam);
624                p.y = HIWORD (lparam);
625      GetClientRect (dlg, &r);              ClientToScreen (hwnd, &p);
626      for (i=1; i <= 3; i++)  
627          partpos[i-1] = r.right/3*i;              GetWindowRect (hwnd, &rect);
628      statbar = CreateStatusWindow (WS_CHILD | WS_VISIBLE | CCS_BOTTOM,              rect.top += (short)(p.y - last_mouse_pos.y);
629                                    "status bar", dlg, KM_SEPARATOR_ID);              rect.bottom += (short)(p.y - last_mouse_pos.y);
630    
631      ShowWindow (statbar, SW_SHOW);              last_mouse_pos.y = p.y;
632      SendMessage (statbar, SB_SETPARTS, (WPARAM)3, (LPARAM)partpos);  
633                /* Apply mouse movement to window. Beware the MoveWindow is relaive
634      km_update_default_key_str (statbar);                 to parent NOT screen */
635      km_complete_status_bar (statbar, lv);              MapWindowPoints (NULL, GetParent(hwnd), (POINT*)&rect, 2);
636                kmi->ypos_sep = rect.top;
637      return statbar;              kmi->ypercent_sep = 0; /* This forces do_resize_window to use abs. position */
638  }              do_resize_window (GetParent (hwnd), kmi);
639                return 0;
640            }
641  BOOL CALLBACK      }
642  keymanager_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)  
643  {      return DefWindowProc (hwnd, msg, wparam, lparam);
644      struct km_info *kmi;  }
645      static km_group_s *gc = NULL;  
646      static HMENU menu = NULL;  
647      static int refresh_keys = 0;      /* Register the separator window with @dlg as the parent window. */
648      INITCOMMONCONTROLSEX icex;  static HWND
649      HWND kl;  register_separator_window (HWND dlg, struct km_info_s *kmi)
650      HMENU hm;  {
651      gpg_keycache_t c;      WNDCLASS wndclass;
652      gpgme_key_t key;      HWND h;
653      /*km_group_cb_s gcb; XXX */  
654      struct genkey_s genkey;      memset (&wndclass, 0, sizeof (wndclass));
655      struct winpt_key_s k = {0};      wndclass.style         = CS_DBLCLKS | CS_HREDRAW | CS_VREDRAW;
656      struct URL_ctx_s *url;      wndclass.lpfnWndProc   = separator_wnd_proc;
657      refresh_cache_s rcs = {0};      wndclass.cbClsExtra    = 0;
658      char keyid[48], uid[128], type[32], *name;      wndclass.cbWndExtra    = sizeof (long);
659      const char *t, * host;      wndclass.hInstance     = glob_hinst;
660      u16 port = 0;      wndclass.hIcon         = NULL;
661      int idx = 0, i=0, rc;      wndclass.hCursor       = LoadCursor (NULL, IDC_SIZENS);
662      size_t size = 0;      wndclass.hbrBackground = (HBRUSH) GetStockObject (LTGRAY_BRUSH);
663        wndclass.lpszMenuName  = 0;
664      if ((msg != WM_INITDIALOG)      wndclass.lpszClassName = WINDOWCLASS_SEPARATOR_CHILD;
665          && ((kmi = (struct km_info*)GetWindowLong (dlg, GWL_USERDATA)) == NULL))      RegisterClass (&wndclass);
666          return FALSE;  
667        h = CreateWindowEx (WS_EX_WINDOWEDGE, WINDOWCLASS_SEPARATOR_CHILD, NULL,
668      switch (msg) {                          WS_CHILD | WS_CLIPCHILDREN | WS_VISIBLE,
669      case WM_INITDIALOG:                          0, 400, 2000, 5, dlg, (HMENU) 0, glob_hinst, kmi);
670          kmi = new struct km_info;      ShowWindow (h, SW_SHOW);
671          memset (kmi, 0, sizeof (struct km_info));      return h;
672          icex.dwSize = sizeof (INITCOMMONCONTROLSEX);  }
673          icex.dwICC  = ICC_BAR_CLASSES;  
674          InitCommonControlsEx (&icex);  
675          kmi->hwnd_sep = regist_sep_wnd (dlg, kmi);  #define enable_button(hwnd, cid, item_selected) \
676          imagelist_load (dlg);      SendMessage ((hwnd), TB_ENABLEBUTTON, (cid), MAKELONG ((item_selected), 0))
677    
678  #ifndef LANG_DE  
679          SetWindowText( dlg, _("Key Manager") );  /* Interactive modification of the dialog item which depend if an item
680  #endif             is selected or not and what kind of item. @lv is the list view with
681          menu = LoadMenu( glob_hinst, (LPCSTR)IDR_WINPT_KEYMISC );     the items. */
682  #ifndef LANG_DE  void
683          set_menu_text (menu, ID_KEYMISC_QUIT, _("&Quit"));  update_ui_items (HWND hwnd, keylist_ctrl_t kl)
684          set_menu_text (menu, ID_KEYMISC_UID, _("User ID"));  {
685          set_menu_text (menu, ID_KEYMISC_NEWKEY, _("&Expert"));      HWND tb_hwnd;
686          set_menu_text (menu, ID_KEYMISC_KEYWIZARD, _("&Normal"));      HMENU hmenu;
687          set_menu_text (menu, ID_KEYMISC_EDIT, _("Edit"));      listview_ctrl_t lv = kl->lv;
688          set_menu_text (menu, ID_KEYMISC_SIGN, _("&Sign"));      int mult_resids[] = {ID_KEYMISC_PROPS, ID_KEYMISC_SIGN, ID_KEYMISC_EDITKEY,
689          set_menu_text (menu, ID_KEYMISC_DELETE, _("&Delete"));                           ID_KEYMISC_CHECKSIGS, ID_KEYMISC_REVCERT, 0};
690          set_menu_text (menu, ID_KEYMISC_REVCERT, _("&Revoke"));      int key_selected;
691          set_menu_text (menu, ID_KEYMISC_CHECKSIGS, _("&List Signatures"));      int key_has_sec;
692          set_menu_text (menu, ID_KEYMISC_TRUSTPATH, _("List Trust Path"));      int key_inv = 0;
693          set_menu_text (menu, ID_KEYMISC_EXPORT, _("&Export..."));      int i, state=0;
694          set_menu_text (menu, ID_KEYMISC_IMPORT, _("&Import..."));  
695          set_menu_text (menu, ID_KEYMISC_PROPS, _("&Properties"));      /* Get some states */
696          set_menu_text (menu, ID_KEYMISC_GPGOPT, _("Options"));      key_selected = SendMessage (GetDlgItem (hwnd, IDC_KEYMISC_KEYLIST),
697          set_menu_text (menu, ID_KEYMISC_GPGPREFS, _("Preferences"));                                             LVM_GETSELECTEDCOUNT, 0, 0)
698          set_menu_text (menu, ID_KEYMISC_SENDRECV, _("Keyserver") );                                             ? TRUE : FALSE;
699          set_menu_text (menu, ID_KEYMISC_EXPORT_PRIVKEY, _("E&xport Secret Key"));      key_has_sec = FALSE;
700          set_menu_text (menu, ID_KEYMISC_RECACHE, _("Re&load Key Cache"));      if (key_selected) {
701          set_menu_text (menu, ID_KEYMISC_REBUILD, _("R&everify Signatures"));          i = listview_get_curr_pos (lv);
702          set_menu_text (menu, ID_KEYMISC_REFRESH_KEYS, _("Refresh &Keys (Keyserver)"));          key_has_sec = km_check_for_seckey (kl, i, NULL) ? TRUE : FALSE;
703          set_menu_text (menu, ID_KEYMISC_INFO, _("Info") );          key_inv = km_get_key_status (kl, i) & KM_FLAG_REVOKED ||
704          set_menu_text (menu, ID_KEYMISC_HELP, _("Help"));                    km_get_key_status (kl, i) & KM_FLAG_EXPIRED;
705  #endif      }
706          SetMenu (dlg, menu);  
707          if( keyring_check_last_access() )      /* Enable / disable toolbar buttons */
708              keycache_set_reload( 1 );      tb_hwnd = GetDlgItem (hwnd, IDR_WINPT_KMTB);
709          if( keycache_get_reload( ) )      enable_button (tb_hwnd, ID_KEYMISC_DELETE, key_selected);
710              keycache_reload( dlg );      enable_button (tb_hwnd, ID_KEYMISC_PROPS, key_selected);
711          c = keycache_get_ctx( KEYCACHE_PUB );      enable_button (tb_hwnd, ID_KEYMISC_SIGN, key_selected && !key_inv);
712          if( !c )      enable_button (tb_hwnd, ID_KEYMISC_EXPORT, key_selected);
713              BUG( NULL );      enable_button (tb_hwnd, ID_KEYCTX_COPY, key_selected);
714          kmi->keylist_sortby = KEY_SORT_USERID;      enable_button (tb_hwnd, ID_KEYCTX_PASTE, clip_contains_pgpkey ());
715          Header_SetImageList(ListView_GetHeader(GetDlgItem( dlg, IDC_KEYMISC_KEYLIST )),  
716                              glob_imagelist);      /* Enable / disable menu items */
717          kmi->lv = keylist_load( GetDlgItem( dlg, IDC_KEYMISC_KEYLIST ), c,      state = key_selected? MF_ENABLED : MF_DISABLED|MF_GRAYED;
718                                  NULL, KEYLIST_LIST, kmi->keylist_sortby );      hmenu = GetMenu (hwnd);
719          /* init subclassing for the listview */      set_menu_state (hmenu, ID_KEYMISC_EXPORT, state);
720          kl = GetDlgItem( dlg, IDC_KEYMISC_KEYLIST );      set_menu_state (hmenu, ID_KEYMISC_DELETE, state);
721          keylist_proc.dlg = dlg;      set_menu_state (hmenu, ID_KEYMISC_PROPS, state);
722          keylist_proc.current = (WNDPROC)keylist_subclass_proc;      set_menu_state (hmenu, ID_KEYMISC_EDITKEY, state);
723          keylist_proc.old = (WNDPROC)GetWindowLong( kl, GWL_WNDPROC );      set_menu_state (hmenu, ID_KEYMISC_CHECKSIGS,
724          if( keylist_proc.old ) {                      key_selected && !key_inv ? MF_ENABLED : MF_GRAYED);
725              if( !SetWindowLong( kl, GWL_WNDPROC, (LONG)keylist_proc.current) ) {      set_menu_state (hmenu, ID_KEYMISC_SIGN,
726                  msg_box( dlg, _("Could not set keylist window procedure."), _("Key Manager"), MB_ERR );                      key_selected && !key_inv ? MF_ENABLED : MF_GRAYED);
727                  BUG( NULL );      set_menu_state (hmenu, ID_KEYMISC_EXPORT_PRIVKEY,
728              }                      key_selected && key_has_sec? MF_ENABLED : MF_GRAYED);
729          }      set_menu_state (hmenu, ID_KEYMISC_REVCERT,
730          #if 0                      key_selected && key_has_sec? MF_ENABLED : MF_GRAYED);
731          km_groups_new( &gc, GetDlgItem( dlg, IDC_KEYMISC_GROUP ) );  
732          km_groups_load( gc );      /* Disable some menu items when multiple keys are selected. */
733          #endif      if (listview_count_items (lv, 1) > 1) {
734          SetClassLong (dlg, GCL_HICON, (LONG)LoadIcon (glob_hinst, (LPCTSTR)IDI_WINPT));          for (i=0; mult_resids[i] != 0; i++)
735          SetForegroundWindow (dlg);              set_menu_state (hmenu, mult_resids[i], MF_GRAYED);
736        }
737          kmi->statbar = setup_status_bar (dlg, kmi->lv);  
738        /* Disable all secret-key functions when no secret key is available. */
739          SetWindowLong (dlg, GWL_USERDATA, (LONG)kmi);      if (!secret_key_available ()) {
740          kmi->toolbar = load_toolbar (dlg, kmi);          enable_button (tb_hwnd, ID_KEYMISC_SIGN, FALSE);
741            set_menu_state (hmenu, ID_KEYMISC_SIGN, MF_GRAYED);
742          do_center_window( dlg, kmi );      }
743          do_resize_window( dlg, kmi );  }
744          update_ui_items (dlg, kmi->lv);  
745          return TRUE;  
746            /* Disable some context menu items when multiple keys are selected. */
747      case WM_DESTROY:  static void
748          if (kmi->lv) {  popup_multiple (HWND dlg, HMENU hm)
749              keylist_delete (kmi->lv);  {
750              kmi->lv = NULL;            int resids[] = {
751                    ID_KEYCTX_EDIT,
752           /*          ID_KEYCTX_SIGN,
753           if (gc) {          ID_KEYCTX_REV,
754              km_groups_release (gc);          ID_KEYCTX_ENABLE,
755              gc = NULL;          ID_KEYCTX_DISABLE,
756          }*/          ID_KEYCTX_ADDKEY,
757         imagelist_destroy ();          ID_KEYCTX_ADDPHOTO,
758            ID_KEYCTX_ADDUID,
759         char buf[32];          ID_KEYCTX_ADDREV,
760         ltoa (kmi->pos_x, buf, 10);          ID_KEYCTX_LISTSIGS,
761         set_reg_entry( HKEY_CURRENT_USER, "Software\\WinPT", "KM_Pos_X", buf );          ID_KEYCTX_MAXTRUST,
762         ltoa (kmi->pos_y, buf, 10);          ID_KEYCTX_PROPS,
763         set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "KM_Pos_Y", buf);          ID_KEYCTX_SENDMAIL,
764         /* Remove runtime information. This should be the last action taken here. */          0};
765         delete kmi; kmi = NULL;      for (int i=0; resids[i] != 0; i++)
766         SetWindowLong (dlg, GWL_USERDATA, NULL);              set_menu_state (hm, resids[i], MF_GRAYED);
767         keycache_set_reload (refresh_keys);  }
768         return FALSE;  
769    
770      case WM_MOVE:        /* The items which are shown when GPG is in read-only mode. */
771          /* kmi->pos_x = (int)(short)LOWORD(lparam);  static void
772             kmi->pos_y = (int)(short)HIWORD(lparam); */  popup_gpg_readonly (HWND dlg, HMENU hm)
773          RECT r;  {
774          GetWindowRect (dlg, &r);      int resids[] = {
775          kmi->pos_x = r.left;          ID_KEYCTX_PASTE,
776          kmi->pos_y = r.top;              ID_KEYCTX_EDIT,
777          break;          ID_KEYCTX_SIGN,
778                    ID_KEYCTX_REV,
779            ID_KEYCTX_DEL,
780      case WM_RBUTTONUP:          ID_KEYCTX_ENABLE,
781          do_create_minpopup (dlg);          ID_KEYCTX_DISABLE,
782          break;          ID_KEYCTX_RECVFROM,
783            ID_KEYCTX_ADDKEY,
784      case WM_NOTIFY:                      ID_KEYCTX_ADDPHOTO,
785          NMHDR * notify;          ID_KEYCTX_ADDUID,
786          POINT p;          ID_KEYCTX_ADDREV,
787          HMENU popup;          0
788                };
789          notify = (NMHDR *)lparam;  
790          if (notify == NULL)      if (gpg_read_only == 0)
791              break;          return;
792          switch (notify->code)      for (int i=0; resids[i] != 0; i++)
793          {          set_menu_state (hm, resids[i], MF_GRAYED);
794          case TBN_QUERYDELETE:  }
795              SetWindowLong(dlg, DWL_MSGRESULT, TRUE);  
796              return TRUE;  
797            /* Change the 'Edit' menu based on the current state. */
798          case TBN_QUERYINSERT:  static void
799              SetWindowLong(dlg, DWL_MSGRESULT, TRUE);  change_edit_menu (listview_ctrl_t lv, HMENU hm, int id)
800              return TRUE;  {
801        enum item { EDIT_MENU = 1 };
802          case TBN_GETBUTTONINFO:      int no_sel;
803              LPTBNOTIFY lpTbNotify;  
804              lpTbNotify = (LPTBNOTIFY)lparam;      if (id != EDIT_MENU)
805              if (lpTbNotify->iItem < (sizeof(myb) / sizeof(mybuttons))) {          return;
806                  lpTbNotify->tbButton.iBitmap = imagelist_getindex(myb[lpTbNotify->iItem].icon);  
807                  lpTbNotify->tbButton.idCommand = myb[lpTbNotify->iItem].command;      if (!clip_contains_pgpkey ())
808                  lpTbNotify->tbButton.fsState = TBSTATE_ENABLED;          set_menu_state (hm, ID_KEYMISC_PASTE, MF_GRAYED);
809                  lpTbNotify->tbButton.fsStyle = TBSTYLE_BUTTON;      else
810                  lpTbNotify->tbButton.iString = 0;          set_menu_state (hm, ID_KEYMISC_PASTE, MF_ENABLED);
811                  strncpy (lpTbNotify->pszText, myb[lpTbNotify->iItem].text, lpTbNotify->cchText);      no_sel = listview_get_curr_pos (lv) == -1? 1 : 0;
812                  SetWindowLong(dlg, DWL_MSGRESULT, TRUE);      set_menu_state (hm, ID_KEYMISC_DELETE2, no_sel? MF_GRAYED: MF_ENABLED);
813              }      set_menu_state (hm, ID_KEYMISC_COPY, no_sel? MF_GRAYED : MF_ENABLED);
814              return TRUE;  }
815    
816          case TBN_RESET: /* Restore last saved toolbar status */  
817              TBSAVEPARAMS tbsp;  
818    /* Show limited key menu entries when GPG is in read-only mode. */
819              tbsp.hkr = HKEY_CURRENT_USER;  static void
820              tbsp.pszSubKey = "Software\\WinPT";  change_key_menu (HMENU hm, int id)
821              tbsp.pszValueName = "KM_toolbar";  {
822              SendMessage (notify->hwndFrom, TB_SAVERESTORE, FALSE, (LPARAM)&tbsp);      int key_resids[] = {
823              break;          ID_KEYMISC_SIGN,
824            ID_KEYMISC_DELETE,
825          case TBN_BEGINADJUST: /* User is about to change the toolbar. Save it */          ID_KEYMISC_REVCERT,
826              tbsp.hkr = HKEY_CURRENT_USER;          ID_KEYMISC_IMPORT_HTTP,
827              tbsp.pszSubKey = "Software\\WinPT";          ID_KEYMISC_IMPORT,
828              tbsp.pszValueName = "KM_toolbar";          ID_KEYMISC_REFRESH_KEYS,
829              SendMessage (notify->hwndFrom, TB_SAVERESTORE, TRUE, (LPARAM)&tbsp);          ID_KEYMISC_REBUILD,
830              break;          ID_KEYMISC_KEYWIZARD,
831            ID_KEYMISC_CARDNEW,
832          case TBN_ENDADJUST: /* User has finished customizing the toolbar. Save it. */          ID_KEYMISC_NEWKEY,
833              tbsp.hkr = HKEY_CURRENT_USER;          0,
834              tbsp.pszSubKey = "Software\\WinPT";      };
835              tbsp.pszValueName = "KM_toolbar";      int edit_resids[] = {
836              SendMessage (notify->hwndFrom, TB_SAVERESTORE, TRUE, (LPARAM)&tbsp);          ID_KEYMISC_PASTE,
837              break;          ID_KEYMISC_OT,
838            ID_KEYMISC_EDITKEY,
839          case TTN_GETDISPINFO:          0
840              LPTOOLTIPTEXT lpttt;      };
841              lpttt = (LPTOOLTIPTEXT)lparam;      int *resids;
842    
843              lpttt->hinst = NULL;      
844              switch (lpttt->hdr.idFrom) {      if (gpg_read_only == 0)
845              case ID_KEYMISC_DELETE:          return;
846                  lpttt->lpszText = (char *)_("Delete key from keyring");      switch (id) {
847                  break;      case 0: return;
848        case 3: resids = key_resids; break;
849              case ID_KEYMISC_PROPS:      case 1: resids = edit_resids;break;
850                  lpttt->lpszText = (char *)_("Show key properties");      default:resids = edit_resids; break;
851                  break;      }
852    
853              case ID_KEYMISC_SIGN:      for (int i=0; resids[i] != 0; i++)
854                  lpttt->lpszText = (char *)_("Sign key");          set_menu_state (hm, resids[i], MF_GRAYED);
855                  break;  }
856    
857              case ID_KEYMISC_IMPORT:  
858                  lpttt->lpszText = (char *)_("Import key to keyring");  /* Reload a single key in the cache. */
859                  break;  static void
860    update_key (keylist_ctrl_t kl, int pos, const char *keyid, int keypair)
861              case ID_KEYMISC_EXPORT:  {
862                  lpttt->lpszText = (char *)_("Export key to a file");      struct winpt_key_s key;
863                  break;  
864              }      keycache_update (0, keyid);
865              return TRUE;      if (keypair)
866                        keycache_update (1, keyid);
867          case LVN_ITEMCHANGED:  
868              if (((LPNMLISTVIEW)lparam)->uNewState) /* item selected? */      memset (&key, 0, sizeof (key));
869              {      if (winpt_get_pubkey (keyid, &key))
870                  update_ui_items (dlg, kmi->lv);          BUG (0);
871                  return TRUE;      keylist_upd_key (kl, pos, key.ext, key.ctx);
872              }      keyring_check_last_access ();
873              break;  }
874    
875          case NM_RCLICK:  
876              if (notify->idFrom == IDC_KEYMISC_KEYLIST) {  /* Setup status bar for the main window @dlg. */
877                  if (listview_get_curr_pos (kmi->lv) == -1)  static HWND
878                      return TRUE; /* Popup only when a item was selected */  setup_status_bar (HWND dlg, listview_ctrl_t lv)
879                  do_check_cache (kmi->lv, dlg, kmi->statbar);  {      
880                  GetCursorPos (&p);      HWND statbar;
881                  hm = LoadMenu (glob_hinst, MAKEINTRESOURCE (IDR_WINPT_KEYMISC_CTX));      RECT r;
882                  popup = GetSubMenu (hm, 0);      int partpos[3];
883              #ifndef LANG_DE      int i;
884                  set_menu_text (popup, ID_KEYCTX_UID_COPY, _("Copy User ID to Clipboard"));  
885                  set_menu_text (popup, ID_KEYCTX_COPY, _("Copy Key to Clipboard"));      GetClientRect (dlg, &r);
886                  set_menu_text (popup, ID_KEYCTX_PASTE, _("Paste Key from Clipboard"));      for (i=1; i <= 3; i++)
887                  set_menu_text (popup, ID_KEYCTX_RECVFROM, _("Refresh from Keyserver"));          partpos[i-1] = r.right/3*i;
888                  set_menu_text (popup, ID_KEYCTX_MAXTRUST, _("Set Implicit &Trust"));      statbar = CreateStatusWindow (WS_CHILD | WS_VISIBLE | CCS_BOTTOM,
889                  set_menu_text (popup, ID_KEYCTX_LISTSIGS, _("&List Signatures"));                                    "WinPT_Status_Bar", dlg, KM_SEPARATOR_ID);
890                  set_menu_text (popup, ID_KEYCTX_PROPS, _("&Key Properties"));      if (!statbar)
891                  set_menu_text (popup, ID_KEYCTX_EDIT, _("Key Edit"));          BUG (NULL);
892                  set_menu_text (popup, ID_KEYCTX_DEL, _("&Delete"));      ShowWindow (statbar, SW_SHOW);
893                  set_menu_text (popup, ID_KEYCTX_REV, _("&Revoke"));      SendMessage (statbar, SB_SETPARTS, (WPARAM)3, (LPARAM)partpos);
894                  set_menu_text (popup, ID_KEYCTX_SIGN, _("&Sign"));  
895                  set_menu_text (popup, ID_KEYCTX_ENABLE, _("&Enable"));      update_default_key_str (statbar);
896                  set_menu_text (popup, ID_KEYCTX_DISABLE, _("&Disable"));      update_status_bar (statbar, lv);
897                  set_menu_text (popup, ID_KEYCTX_RECVFROM, _("Re&fresh from Keyserver"));      return statbar;
898                  set_menu_text (popup, ID_KEYCTX_SETPREFKS, _("Set preferred Keyserver URL"));  }
899              #endif  
900                  idx = listview_get_curr_pos (kmi->lv);  
901                  if (km_check_for_seckey (kmi->lv, idx, &i))  /* Remove or add columns which depends on the state of @checked. */
902                      set_menu_state (popup, ID_KEYCTX_SETDEFKEY, MF_ENABLED);  void
903                  if (i == 0)  modify_listview_columns (km_info_s *kmi, UINT m_uid, BOOL checked)
904                      set_menu_state (popup, ID_KEYCTX_MAXTRUST, MF_ENABLED);  {
905                  if (!km_check_for_seckey (kmi->lv, idx, NULL)) {      UINT resids[] = {
906                      set_menu_state( popup, ID_KEYCTX_REV, MF_DISABLED|MF_GRAYED );          0,
907                      set_menu_state( popup, ID_KEYCTX_ADDKEY, MF_DISABLED|MF_GRAYED );          ID_KEYMISC_VIEWKEYID,
908                      set_menu_state( popup, ID_KEYCTX_ADDUID, MF_DISABLED|MF_GRAYED );          ID_KEYMISC_VIEWTYPE,
909                      set_menu_state( popup, ID_KEYCTX_ADDREV, MF_DISABLED|MF_GRAYED );          0,
910                      set_menu_state( popup, ID_KEYCTX_ADDPHOTO, MF_DISABLED|MF_GRAYED );          ID_KEYMISC_VIEWCIPHER,
911                      set_menu_state (popup, ID_KEYCTX_SETPREFKS, MF_DISABLED|MF_GRAYED);          0,
912                  }          0,
913                  else if( km_check_for_seckey (kmi->lv, idx, NULL)          ID_KEYMISC_VIEWCREAT,
914                        && km_key_is_v3 (kmi->lv, idx)) {          ID_KEYMISC_VIEWUID,
915                      /* PGP 2 keys, version 3 have no no support for photo-id's,          0xFFFFFF
916                         designated revokers and secondary keys. */      };
917                      set_menu_state (popup, ID_KEYCTX_ADDKEY, MF_DISABLED|MF_GRAYED);      listview_ctrl_t lv = kmi->kl->lv;
918                      set_menu_state (popup, ID_KEYCTX_ADDREV, MF_DISABLED|MF_GRAYED);      listview_column_s cols[] = {
919                      set_menu_state (popup, ID_KEYCTX_ADDPHOTO, MF_DISABLED|MF_GRAYED);      {0, 240, (char *)_("User ID")},
920                  }      {1, 78, (char *)_("Key ID")},
921                  if( km_get_key_status( kmi->lv, idx ) & KM_FLAG_DISABLED )      {2, 52, (char *)_("Type")},    
922                      set_menu_state( popup, ID_KEYCTX_DISABLE, MF_DISABLED|MF_GRAYED );      {3, 66, (char *)_("Size")},
923                  else      {4, 60, (char *)_("Cipher")},
924                      set_menu_state( popup, ID_KEYCTX_ENABLE, MF_DISABLED|MF_GRAYED );      {5, 66, (char *)_("Validity")},
925                  if (km_get_key_status (kmi->lv, idx) & KM_FLAG_REVOKED)      {6, 58, (char *)_("Trust")},
926                      set_menu_state (popup, ID_KEYCTX_SIGN, MF_DISABLED|MF_GRAYED);      {7, 72, (char *)_("Creation")},
927                  if (mapi_init())      {8, 160,(char *)_("Description")},
928                      set_menu_state (popup, ID_KEYCTX_SENDMAIL, MF_DISABLED|MF_GRAYED);      {0, 0, NULL}
929                  /* Override 'Default Keyserver' with the actual name. */      };
930                  host = kserver_get_hostname (0, -1, &port);      UINT pos;
931                  set_menu_text (popup, ID_KEYCTX_KS_DEFAULT, host);  
932                  popup_gpg_readonly (dlg, popup);      for (pos=0; resids[pos] != 0xFFFFFF; pos++) {
933                  TrackPopupMenu (popup, TPM_RIGHTALIGN, p.x, p.y, 0, dlg, NULL);          if (m_uid == resids[pos])
934                  DestroyMenu (popup);              break;
935                  DestroyMenu (hm);      }
936                  return TRUE;      if (!checked)
937              }          listview_del_column (lv, (int)pos);
938              #if 0 /* XXX */      else {      
939              if( notify->idFrom == IDC_KEYMISC_GROUP ) {          listview_add_column (lv, &cols[pos]);
940                  HWND tree = GetDlgItem( dlg, IDC_KEYMISC_GROUP );          keylist_upd_col (kmi->kl, pos);
941                  if( TreeView_GetSelection( tree ) ) {      }
942                      GetCursorPos( &p );  }
943                      hm = LoadMenu( glob_hinst, MAKEINTRESOURCE(IDR_WINPT_GROUP_CTX) );  
944                      popup = GetSubMenu( hm, 0 );  
945                      if( km_index == -1 )  /* Helper to handle the help file. If @check is 1
946                          set_menu_state( popup, ID_GROUP_PASTE, MF_DISABLED|MF_GRAYED );     the existence of the file is checked.
947                      set_menu_text( popup, ID_GROUP_PASTE, _("Paste into this group") );     Otherwise the help file will be loaded. */
948                      set_menu_text( popup, ID_GROUP_DELETE, _("Delete") );  static bool
949                      TrackPopupMenu( popup, TPM_RIGHTALIGN, p.x, p.y, 0, dlg, NULL );  start_help (HWND dlg, int check)
950                      DestroyMenu( popup );  {
951                      DestroyMenu( hm );      DWORD n;
952                      return TRUE;      char path[MAX_PATH+1+32];
953                  }  
954              }      n = GetModuleFileName (NULL, path, sizeof (path)-1-32);
955              #endif      if (!n)
956              break;          return false;
957        path[n] = 0;
958          case LVN_COLUMNCLICK:      while (n-- && path[n] != '\\')
959              if (notify->idFrom == IDC_KEYMISC_KEYLIST) {          ;
960                  NMLISTVIEW * p = (LPNMLISTVIEW) lparam;      path[n+1] = 0;
961                  int sortby = 0;      strcat (path, "winpt.chm");
962                  switch (p->iSubItem) {      if (!check)
963                  case 0:  sortby = KEY_SORT_USERID; break;          ShellExecute (dlg, "open", path, NULL, NULL, SW_SHOW);
964                  case 1:  sortby = KEY_SORT_KEYID; break;      return file_exist_check (path) == 0? true : false;
965                  case 2:  sortby = KEY_SORT_IS_SECRET; break;  }
966                  case 3:  sortby = KEY_SORT_LEN; break;  
967                  case 5:  sortby = KEY_SORT_VALIDITY; break;  
968                  case 6:  sortby = KEY_SORT_OTRUST; break;  /* Translate all menu strings. */
969                  case 7:  sortby = KEY_SORT_CREATED; break;  static void
970                  case 8:  sortby = KEY_SORT_ALGO; break;  translate_menu_strings (HWND dlg)
971                  default: return TRUE; //sortby = KEY_SORT_USERID; break;  {
972                  }      HMENU menu;
973    
974                  if ((kmi->keylist_sortby & ~KEYLIST_SORT_DESC) == sortby)      menu = LoadMenu (glob_hinst, (LPCSTR)IDR_WINPT_KEYMISC);
975                      kmi->keylist_sortby ^= KEYLIST_SORT_DESC;      set_menu_text_bypos (menu, 0, _("File"));
976                  else      set_menu_text_bypos (menu, 1, _("Edit"));
977                      kmi->keylist_sortby = sortby;      set_menu_text_bypos (menu, 2, _("View"));
978                  keylist_sort (kmi->lv, kmi->keylist_sortby);      set_menu_text_bypos (menu, 3, _("Key"));
979                  return TRUE;  
980              }      set_menu_text (menu, ID_KEYMISC_EDITKEY, _("Edit..."));
981              break;      set_menu_text (menu, ID_KEYMISC_MAIL, _("Send Mail..."));
982          }      set_menu_text (menu, ID_KEYMISC_OT, _("Ownertrust...")); /* XXX */
983          break;      set_menu_text (menu, ID_KEYMISC_COPY, _("&Copy\tCtrl+C"));
984          }      set_menu_text (menu, ID_KEYMISC_PASTE, _("&Paste\tCtrl+V"));
985        set_menu_text (menu, ID_KEYMISC_FIND, _("Search...\tCtrl+F"));
986      case WM_WINDOWPOSCHANGING:      set_menu_text (menu, ID_KEYMISC_SELALL, _("Select All\tCtrl+A"));
987          if (((WINDOWPOS*)lparam)->cx < 400)      set_menu_text (menu, ID_KEYMISC_QUIT, _("&Quit"));
988              ((WINDOWPOS*)lparam)->cx = 400;      set_menu_text (menu, ID_KEYMISC_UID, _("User ID"));
989          if (((WINDOWPOS*)lparam)->cy < 200)      set_menu_text (menu, ID_KEYMISC_NEWKEY, _("&Expert..."));
990              ((WINDOWPOS*)lparam)->cy = 200;      set_menu_text (menu, ID_KEYMISC_KEYWIZARD, _("&Normal..."));
991           return TRUE;      set_menu_text (menu, ID_KEYMISC_EDIT, _("Edit..."));
992                set_menu_text (menu, ID_KEYMISC_SIGN, _("&Sign..."));
993      case WM_SIZE:      set_menu_text (menu, ID_KEYMISC_DELETE, _("&Delete"));
994          do_resize_window (dlg, kmi);      set_menu_text (menu, ID_KEYMISC_DELETE2, _("&Delete"));
995          return TRUE;      set_menu_text (menu, ID_KEYMISC_REVCERT, _("&Revoke Cert..."));
996                set_menu_text (menu, ID_KEYMISC_CHECKSIGS, _("&List Signatures..."));
997      case WM_SYSCOMMAND:      set_menu_text (menu, ID_KEYMISC_TRUSTPATH, _("List Trust Path..."));
998          if( LOWORD (wparam) == SC_CLOSE )      set_menu_text (menu, ID_KEYMISC_EXPORT, _("&Export..."));
999              EndDialog( dlg, TRUE );      set_menu_text (menu, ID_KEYMISC_IMPORT, _("&Import..."));
1000          return FALSE;      set_menu_text (menu, ID_KEYMISC_PROPS, _("&Properties..."));
1001                set_menu_text (menu, ID_KEYMISC_GPGOPT, _("GPG &Options..."));
1002      case WM_MENUSELECT:      set_menu_text (menu, ID_KEYMISC_GPGPREFS, _("&GPG Preferences..."));
1003          menu_gpg_readonly (dlg, (HMENU)lparam, LOWORD (wparam));      set_menu_text (menu, ID_KEYMISC_WINPTPREFS, _("&WinPT Preferences..."));
1004          break;      set_menu_text (menu, ID_KEYMISC_SENDRECV, _("Keyserver") );
1005        set_menu_text (menu, ID_KEYMISC_EXPORT_PRIVKEY, _("E&xport Secret Key"));
1006      case WM_COMMAND:      set_menu_text (menu, ID_KEYMISC_RECACHE, _("Re&load Key Cache"));
1007          if( gnupg_access_keyring( 1 ) ) {      set_menu_text (menu, ID_KEYMISC_REBUILD, _("R&everify Signatures"));
1008              msg_box( dlg, _("Could not access public keyring"), _("Key Manager"), MB_ERR );      set_menu_text (menu, ID_KEYMISC_REFRESH_KEYS, _("Refresh &Keys (Keyserver)"));
1009              return FALSE;      set_menu_text (menu, ID_KEYMISC_INFO, _("Info"));
1010          }      set_menu_text (menu, ID_KEYMISC_HELP, _("&Help"));
1011          do_check_cache( kmi->lv, dlg, kmi->statbar );      set_menu_text (menu, ID_KEYMISC_DEVWWW, _("&Developer Website"));
1012          switch( LOWORD( wparam ) ) {      set_menu_text (menu, ID_KEYMISC_WEBSITE, _("WinPT &Website"));
1013          case ID_KEYMISC_QUIT:  
1014              EndDialog( dlg, TRUE );      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 ID_KEYMISC_MAIL:      set_menu_text (menu, ID_KEYMISC_VIEWCREAT, _("Creation"));
1018              /* XXX      set_menu_text (menu, ID_KEYMISC_VIEWUID, _("User ID"));
1019              DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_MAIL, GetDesktopWindow (),  
1020                              winpt_mail_proc, NULL);*/      if (!start_help (NULL, 1))
1021              break;          set_menu_state (menu, ID_KEYMISC_HELP, MF_GRAYED);
1022            
1023          case ID_KEYMISC_FIND:      SetMenu (dlg, menu);
1024              km_find_key (dlg, kmi->lv);  }
1025              break;  
1026    
1027          case ID_KEYMISC_DELETE:  /* Translate popup menu strings. */
1028              km_delete_keys (kmi->lv, dlg);  static void
1029              return TRUE;  translate_popupmenu_strings (HMENU popup)
1030                {
1031          case ID_KEYMISC_SIGN:              set_menu_text (popup, ID_KEYCTX_UID_COPY, _("Copy User ID to Clipboard"));
1032              if ( (idx = listview_get_curr_pos( kmi->lv )) == -1 ) {      set_menu_text (popup, ID_KEYCTX_KEYID_COPY, _("Copy Key ID to Clipboard"));
1033                  msg_box( dlg, _("Please select a key."),  _("Key Manager"),      set_menu_text (popup, ID_KEYCTX_FPR_COPY, _("Copy Fingerprint to Clipboard"));
1034                           MB_ERR );      set_menu_text (popup, ID_KEYCTX_KINFO_COPY, _("Copy Key Info to Clipboard"));
1035                  return TRUE;;      set_menu_text (popup, ID_KEYCTX_EMAIL_COPY, _("Copy E-Mail to Clipboard"));
1036              }      set_menu_text (popup, ID_KEYCTX_COPY, _("Copy Key to Clipboard"));
1037              if (km_check_key_status (kmi->lv, idx))      set_menu_text (popup, ID_KEYCTX_PASTE, _("Paste Key from Clipboard..."));
1038                  return TRUE;      set_menu_text (popup, ID_KEYCTX_RECVFROM, _("Refresh from Keyserver"));
1039              key = (gpgme_key_t)listview_get_item2 (kmi->lv, idx);      set_menu_text (popup, ID_KEYCTX_MAXTRUST, _("Set Implicit &Trust"));
1040              listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);      set_menu_text (popup, ID_KEYCTX_LISTSIGS, _("&List Signatures..."));
1041              memset (&k, 0, sizeof (k));      set_menu_text (popup, ID_KEYCTX_PROPS, _("&Properties..."));
1042              k.ctx = key;      set_menu_text (popup, ID_KEYCTX_EDIT, _("Edit..."));
1043              k.keyid = keyid;      set_menu_text (popup, ID_KEYCTX_DEL, _("&Delete"));
1044              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYSIGN, dlg,      set_menu_text (popup, ID_KEYCTX_REV, _("&Revoke Cert..."));
1045                                keysign_dlg_proc, (LPARAM)&k,      set_menu_text (popup, ID_KEYCTX_SIGN, _("&Sign..."));
1046                                _("Key Signing"), IDS_WINPT_KEYSIGN);      set_menu_text (popup, ID_KEYCTX_ENABLE, _("&Enable"));
1047              if (k.update)      set_menu_text (popup, ID_KEYCTX_DISABLE, _("&Disable"));
1048                  update_key (kmi->lv, idx, k.keyid, 0);      set_menu_text (popup, ID_KEYCTX_RECVFROM, _("Re&fresh from Keyserver"));
1049              return TRUE;      set_menu_text (popup, ID_KEYCTX_SETPREFKS, _("Set preferred Keyserver..."));
1050                    set_menu_text (popup, ID_KEYCTX_SENDMAIL, _("Send Key to Mail Recipient..."));
1051          case ID_KEYMISC_REVCERT:      set_menu_text (popup, ID_KEYCTX_SETDEFKEY, _("Set as Default Signing Key"));
1052              idx = listview_get_curr_pos( kmi->lv );  
1053              if( idx == -1 ) {      set_menu_text (popup, ID_KEYCTX_ADDKEY, _("Key..."));
1054                  msg_box( dlg, _("Please select a key."), _("Key Manager"), MB_ERR );      set_menu_text (popup, ID_KEYCTX_ADDUID, _("User ID..."));
1055                  return TRUE;      set_menu_text (popup, ID_KEYCTX_ADDPHOTO, _("Photo ID..."));
1056              }      set_menu_text (popup, ID_KEYCTX_ADDREV, _("Revoker..."));
1057              listview_get_item_text( kmi->lv, idx, 0, uid, sizeof uid -1 );  
1058              listview_get_item_text( kmi->lv, idx, 1, keyid, sizeof keyid-1 );      /* change popup texts */
1059              if ( !km_check_for_seckey( kmi->lv, idx, NULL ) ) {      set_menu_text_bypos (popup, 0, _("Attributes"));
1060                  msg_box( dlg, _("There is no secret key available!"), _("Key Manager"), MB_ERR );      set_menu_text_bypos (popup, 7, _("Add"));
1061                  return TRUE;      set_menu_text_bypos (popup, 15, _("Send to Keyserver"));
1062              }  }
1063                
1064              {  
1065                  char t[128];  static int
1066                  listview_get_item_text( kmi->lv, idx, 5, t, sizeof t -1 );  km_gui_adjust_column_images (struct km_info_s *kmi, int sortby)
1067                  if( strchr( t, 'R' ) ) {  {
1068                      msg_box( dlg, _("Key already revoked!"), _("Key Manager"), MB_INFO );      HWND hheader;
1069                      return TRUE;      HDITEM hdi;
1070                  }      listview_ctrl_t ctx = kmi->kl->lv;
1071              }      int idx, sort_desc = 0;  
1072                
1073              memset (&k, 0, sizeof (k));      hheader = ListView_GetHeader (ctx->ctrl);
1074              k.key_pair = 1;      if (!hheader)
1075              k.keyid = keyid;          return 0;
1076              k.is_protected = km_check_if_protected (kmi->lv, idx);  
1077              dialog_box_param(glob_hinst, (LPCSTR)IDD_WINPT_KEYREVOKE, dlg,      /* Remove image from all header fields */
1078                               key_revoke_dlg_proc, (LPARAM)&k,      memset (&hdi, 0, sizeof(hdi));
1079                               _("Key Revocation"), IDS_WINPT_KEYREVOKE);  
1080              return TRUE;      for (int i=0; i < 7; i++) {
1081                        hdi.mask = HDI_FORMAT;
1082          case ID_KEYMISC_TRUSTPATH:          Header_GetItem (hheader, i, &hdi);
1083              idx = listview_get_curr_pos( kmi->lv );          hdi.fmt &= ~HDF_IMAGE;
1084              if( idx == -1 ) {          Header_SetItem (hheader, i, &hdi);
1085                  msg_box( dlg, _("Please select a key."), _("Key Manager"), MB_ERR );      }
1086                  return TRUE;  
1087              }      switch (sortby & ~KEYLIST_SORT_DESC) {
1088              listview_get_item_text( kmi->lv, idx, 0, uid, sizeof uid -1 );      case KEY_SORT_USERID:    idx = 0; break;
1089              listview_get_item_text( kmi->lv, idx, 1, keyid, sizeof keyid -1 );      case KEY_SORT_KEYID:     idx = 1; break;
1090              if( km_check_for_seckey( kmi->lv, idx, NULL ) ) {      case KEY_SORT_IS_SECRET: idx = 2; break;
1091                  msg_box( dlg, _("It does not make any sense with a key pair!"), _("Key Manager"), MB_OK );      case KEY_SORT_LEN:       idx = 3; break;
1092                  return FALSE;      case KEY_SORT_VALIDITY:  idx = 5; break;
1093              }      case KEY_SORT_OTRUST:    idx = 6; break;
1094              memset (&k, 0, sizeof (k));      case KEY_SORT_CREATED:   idx = 7; break;
1095              k.keyid = keyid;      case KEY_SORT_ALGO:      idx = 8; break;
1096              k.uid = uid;      default:                 idx = 0; break;
1097              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_KEYTRUST, dlg,      }
1098                                keytrust_dlg_proc, (LPARAM)&k,  
1099                                _("List Trust Path"), IDS_WINPT_KEYTRUST );      sort_desc = sortby & KEYLIST_SORT_DESC;
1100              return TRUE;      /* Set image to currently sorted field */
1101                    memset (&hdi, 0, sizeof(hdi));
1102          case ID_KEYMISC_CHECKSIGS:      hdi.mask = HDI_IMAGE | HDI_FORMAT;
1103              idx = listview_get_curr_pos (kmi->lv);      Header_GetItem (hheader, idx, &hdi);  
1104              if( idx == -1 ) {      hdi.fmt |= HDF_IMAGE | HDF_BITMAP_ON_RIGHT;
1105                  msg_box( dlg, _("Please select a key."), _("Key Manager"), MB_ERR );      if (!ctx->ext_chkbox)
1106                  return FALSE;          hdi.iImage = km_imagelist_getindex (kmi->iconlist,
1107              }                                              sort_desc? IMI_SORT_DOWNARROW :
1108              listview_get_item_text (kmi->lv, idx, 0, uid, DIM (uid)-1);                                                         IMI_SORT_UPARROW);
1109              listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);      else
1110              memset (&k, 0, sizeof (k));          hdi.iImage = sort_desc? KEY_IMG_SORT_DOWN : KEY_IMG_SORT_UP;
1111              k.keyid = keyid;      Header_SetItem (hheader, idx, &hdi);
1112              k.uid = uid;      return 0;
1113              k.ctx = (gpgme_key_t)listview_get_item2 (kmi->lv, idx);  }
1114              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYSIG, dlg,  
1115                                keysig_dlg_proc, (LPARAM)&k,  
1116                                _("Key Signature List" ), IDS_WINPT_KEYSIG);  /* Return true if the cache contain marked keys. */
1117              return TRUE;  static bool
1118                updated_keys_avail (void)
1119          case ID_KEYMISC_PROPS:  {
1120              idx = listview_get_curr_pos( kmi->lv );      gpg_keycache_t kc = keycache_get_ctx (1);
1121              if( idx == -1 ) {      struct keycache_s *k;
1122                  msg_box( dlg, _("Please select a key."), _("Key Manager"), MB_ERR );  
1123                  return FALSE;      for (k = kc->item; k; k = k->next) {
1124              }          if (k->flags)
1125              listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);              return true;
1126              listview_get_item_text (kmi->lv, idx, 2, type, DIM (type)-1);      }
1127              memset (&k, 0, sizeof (k));      return false;
1128              k.key_pair = 0;  }
1129              k.keyid = keyid;  
1130              if( !strcmp( type, "pub/sec" ) || !strcmp( type, "pub/crd" ) )  
1131                  k.key_pair = 1;  /* Find the index of the key identified by @key. */
1132              k.callback.ctl = kmi->lv;  static int
1133              k.callback.idx = idx;  find_keypos (listview_ctrl_t lv, gpgme_key_t key)
1134              k.is_v3 = km_key_is_v3 (kmi->lv, idx);  {
1135              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_KEYPROPS, dlg,      char keyid[32+1];
1136                                keyprops_dlg_proc, (LPARAM)&k,  
1137                                _("Key Properties"), IDS_WINPT_KEYPROPS );      for (int i=0; i < listview_count_items (lv, 0); i++) {
1138              if (k.callback.new_val != 0) {          listview_get_item_text (lv, i, KM_COL_KEYID, keyid, sizeof (keyid)-1);
1139                  t = get_key_trust_str (k.callback.new_val);          if (!strcmp (key->subkeys->keyid+8, keyid+2))
1140                  listview_add_sub_item (kmi->lv, idx, 6, t);              return i;
1141              }      }
1142              return TRUE;      return -1;
1143                }
1144          case ID_KEYMISC_RECACHE:  
1145              /* If there is already a reload request, don't bother the user with a message. */  
1146              if( keycache_get_reload() == 1 )  /* Add all recently updated keys in the cache to the list
1147                  idx = IDYES;     and refresh all GUI elements. */
1148              else {  static void
1149                  char t[256];  refresh_keylist (struct km_info_s *kmi)
1150                  _snprintf( t, sizeof t -1,  {
1151                             _("This is only useful when the keyring has been "      struct keycache_s *ctx;
1152                               "modified (sign a key...).\n"      gpg_keycache_t kc;
1153                               "Do you really want to reload the keycache?") );      int nadded = 0;
1154                  idx = msg_box( dlg, t, _("Key Manager"), MB_YESNO );      int status=0, pos;
1155              }  
1156              if( idx == IDYES ) {      kc = keycache_get_ctx (1);
1157                  rcs.kr_reload = rcs.kr_update = 1;      while (!gpg_keycache_next_updated_key (kc, &ctx, &status)) {
1158                  rcs.tr_update = 0;          if (status == KC_FLAG_ADD) {
1159                  DialogBoxParam( glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, dlg,              keylist_add_key (kmi->kl, KEYLIST_LIST, ctx, ctx->key);
1160                                  keycache_dlg_proc, (LPARAM)&rcs );              nadded++;
1161                  c = keycache_get_ctx( 1 );          }
1162                  if( !c )          else {
1163                      BUG( dlg );              pos = find_keypos (kmi->kl->lv, ctx->key);
1164                  keylist_reload( kmi->lv, c, KEYLIST_LIST, KEY_SORT_USERID );              if (pos != -1)
1165                  refresh_keys = 0;                  keylist_upd_key (kmi->kl, pos, ctx, ctx->key);
1166              }          }
1167              return TRUE;      }
1168                    /* if keys were added, we need to sync the key array. */
1169          case ID_KEYMISC_REBUILD:      
1170              name=NULL;      kmi->enable_redraw = 0;
1171              gpg_rebuild_cache (&name);      if (nadded > 0)
1172              if (name) {          keylist_sync (kmi->kl);
1173                  char *p = strchr (name, '\n');      keylist_sort (kmi->kl, kmi->keylist_sortby);
1174                  show_msg (dlg, 2000, p? name + (p-name)+1 : name);      km_gui_adjust_column_images (kmi, kmi->keylist_sortby);
1175                  free (name);      update_status_bar (kmi->statbar, kmi->kl->lv);
1176              }      keyring_check_last_access ();
1177              return TRUE;      SetForegroundWindow (kmi->dlg);
1178                    if (nadded > 0)
1179          case ID_KEYMISC_NEWKEY:          redraw_keylist (kmi);
1180              memset (&genkey, 0, sizeof (genkey));  }
1181              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYGEN, dlg,  
1182                                keygen_dlg_proc, (LPARAM)&genkey, _("Key Generation"),  
1183                                IDS_WINPT_KEYGEN);  /* Reload the key cache. */
1184              if (genkey.newkey != NULL)  static void
1185                  keylist_add_key (kmi->lv, KEYLIST_LIST, genkey.newkey);  keycache_reload (HWND dlg)
1186              return TRUE;  {      
1187        refresh_cache_s rcs;
1188          case ID_KEYMISC_CARDNEW:  
1189              if( !scard_support ) {      memset (&rcs, 0, sizeof rcs);
1190                  msg_box( dlg, _("Smart Card support is not available."), _("Key Manager"), MB_INFO );      rcs.kring_update = 1;
1191                  return TRUE;      DialogBoxParam (glob_hinst, (LPCSTR)IDD_WINPT_KEYCACHE, dlg,
1192              }                      keycache_dlg_proc, (LPARAM)&rcs);
1193              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_CARD_KEYGEN, dlg,  }
1194                                card_keygen_dlg_proc, NULL, _("Card Key Generation"),  
1195                                IDS_WINPT_CARD_KEYGEN );  
1196              /* XXX: use new code */  /* Check if the secret keyring contains at least one
1197              if( keycache_get_reload() )     key with ultimate trust.
1198                  send_cmd_id( dlg, ID_KEYMISC_RECACHE );     Return value: 0 on success. */
1199              return TRUE;  int
1200    check_ultimate_trusted_key (gpg_keycache_t _sec)
1201          case ID_KEYMISC_KEYWIZARD:  {
1202              memset (&genkey, 0, sizeof (genkey));      struct keycache_s *n;
1203              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_KEYWIZARD, dlg,      int nkeys = 0;
1204                                keygen_wizard_dlg_proc, (LPARAM)&genkey, _("Key Generation Wizard"),  
1205                                IDS_WINPT_KEYWIZARD);      for (n = _sec->item; n; n = n->next) {
1206              if (genkey.newkey != NULL)          if (n->pubpart &&
1207                  keylist_add_key (kmi->lv, KEYLIST_LIST, genkey.newkey);              n->pubpart->key->owner_trust == GPGME_VALIDITY_ULTIMATE)
1208              return TRUE;              return 0;
1209                        nkeys++;
1210          case ID_KEYMISC_SENDRECV:      }
1211              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_KEYSERVER, dlg,  
1212                                keyserver_dlg_proc, NULL, _("Keyserver Access"),      /* if we do not have any secret keys, it does not make sense
1213                                IDS_WINPT_KEYSERVER );         to return an error. */
1214              return TRUE;      if (nkeys == 0)
1215                        return 0;
1216          case ID_KEYMISC_GPGPREFS:      return -1;
1217              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_GPGPREFS, dlg,  }
1218                                gpgprefs_dlg_proc, NULL, _("GnuPG Preferences"),  
1219                                IDS_WINPT_GPGPREFS );  
1220              return TRUE;  /* Reload the entire key cache and update the listview. */
1221                static void
1222          case ID_KEYMISC_GPGOPT:  reload_keycache (struct km_info_s *kmi)
1223              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_GPGOPT, dlg,  {
1224                                gpgopt_dlg_proc, NULL, _("GnuPG Options" ),      gpg_keycache_t cache;
1225                                IDS_WINPT_GPGOPT );  
1226              return TRUE;      kmi->enable_redraw = 0;
1227                    keycache_reload (kmi->dlg);
1228          case ID_KEYMISC_IMPORT:      cache = keycache_get_ctx (KEYCACHE_PUB);
1229              t = get_filename_dlg (dlg, FILE_OPEN, _("Choose Name of the Key File"), NULL, NULL);      keylist_reload (kmi->kl, cache, KEYLIST_LIST, kmi->keylist_sortby);
1230              if (t)      update_status_bar (kmi->statbar, kmi->kl->lv);
1231                  km_file_import (dlg, t);      keyring_check_last_access ();
1232              return TRUE;      redraw_keylist (kmi);
1233        SetForegroundWindow (kmi->dlg);    
1234          case ID_KEYMISC_IMPORT_HTTP:  }
1235              url = (struct URL_ctx_s*)get_http_file_dlg (dlg);  
1236              if (url->cancel == 0)  
1237                  km_http_import (dlg, url->url);  /* Handle all import request. */
1238              delete url; url=NULL;  static void
1239              break;  km_gui_import (struct km_info_s *kmi, int cmd_id, void *param)
1240                {
1241          case ID_KEYMISC_EXPORT:      int newkeys = 0, newsks = 0;
1242              idx = listview_get_curr_pos (kmi->lv);      int err = 0;
1243              if (idx == -1) {  
1244                  msg_box( dlg, _("Please select a key."), _("Key Manager"), MB_ERR );      switch (cmd_id) {
1245                  return TRUE;      case ID_KEYMISC_PASTE:
1246              }          err = km_clip_import (kmi->dlg, &newkeys, &newsks);
1247              if (listview_count_items (kmi->lv, 1) > 1)          break;
1248                  name = m_strdup ("Exported_GPG_Keys.asc");  
1249              else {      case ID_KEYMISC_IMPORT:
1250                  listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);          err = km_file_import (kmi->dlg, NULL, &newkeys, &newsks);
1251                  name = gen_export_filename (keyid, 0);          break;
1252              }  
1253              t = get_filename_dlg (dlg, FILE_SAVE, _("Choose Name for Key File"), NULL, name);      case WM_DROPFILES:
1254              free_if_alloc (name);          err = km_dropped_file_import (kmi->dlg, (HDROP)param,
1255              if (t == NULL)                                        &newkeys, &newsks);
1256                  return TRUE;          break;
1257              km_file_export (dlg, kmi->lv, t);  
1258              return TRUE;      default:
1259                        err = 1;
1260          case ID_KEYMISC_EXPORT_PRIVKEY:          break;
1261              idx = listview_get_curr_pos( kmi->lv );      }
1262              if( idx == -1 ) {  
1263                  msg_box( dlg, _("Please select a key."), _("Key Manager"), MB_ERR );      if (!err && !newsks && (newkeys > 0 && newkeys < KM_PRELOAD_KEYS))
1264                  return TRUE;          refresh_keylist (kmi);
1265              }      else if (!err) /* avoid to spawn too much processes. */
1266              if( !km_check_for_seckey( kmi->lv, idx, NULL ) ) {          reload_keycache (kmi);  
1267                  msg_box( dlg, _("There is no corresponding secret key for this key."),      SetForegroundWindow (kmi->dlg);
1268                          _("Key Manager"), MB_ERR );  }
1269                  return TRUE;  
1270              }  
1271              if( listview_count_items( kmi->lv, 1 ) > 1 ) {  /* Copy the requested key information (@what) to the clipboard.
1272                  msg_box( dlg, _("You can only export one secret key."), _("Key Manager"), MB_ERR );     If multiple items were selected, each key info is copied to
1273                  return TRUE;     the clipboard. The data is separated by \r\n. */
1274              }  static void
1275              idx = msg_box( dlg,  copy_key_info (int what, struct km_info_s *kmi)
1276                            _("This operation will export your *SECRET* key!\n\n"  {
1277                              "Never send this key to ANYONE, it should be available\n"      gpgme_data_t out;
1278                              "ONLY on your machine and you may use this function\n"      gpgme_key_t key;
1279                              "to copy the key to a safe place.\n\n"      struct keycache_s *kci = NULL;
1280                              "Do you really want to export the key?"),      size_t n=0;
1281                            _("WARNING"), MB_INFO|MB_YESNO );      char *p, tmp[256];
1282              if( idx == IDYES ) {      int i=0, end = listview_count_items (kmi->kl->lv, 0);
1283                  idx = listview_get_curr_pos( kmi->lv );      bool single = false;
1284                  listview_get_item_text( kmi->lv, idx, 1, keyid, sizeof (keyid)-8 );  
1285                  name = gen_export_filename (keyid, 1);      /* Do not iterate over the entire list if just one item is selected. */
1286                  t = get_filename_dlg (dlg, FILE_SAVE, _("Choose Name for Key File"), NULL, name);      n = listview_count_items (kmi->kl->lv, 1);
1287                  if (t != NULL)                if (n == 1) {
1288                      km_privkey_export (dlg, kmi->lv, t);          i = kmi->lv_idx;
1289              }          end = i+1;
1290              break;          single = true;
1291        }
1292          case ID_KEYMISC_INFO:  
1293              dialog_box_param( glob_hinst, (LPCSTR)IDD_WINPT_ABOUT, glob_hwnd,      gpgme_data_new (&out);
1294                                about_winpt_dlg_proc, NULL, _("About WinPT"),      for (; i < end; i++) {
1295                                IDS_WINPT_ABOUT );          if (!listview_get_item_state (kmi->kl->lv, i))
1296              break;              continue;
1297            switch (what) {
1298          case ID_KEYMISC_HELP:  
1299              ShellExecute (dlg, "open", "winpt.chm", NULL, NULL, SW_SHOW);          case ID_KEYCTX_EMAIL_COPY:
1300              break;              key = km_get_key_ptr (kmi->kl, i, NULL);
1301                gpgme_data_write (out, key->uids->email, strlen (key->uids->email));
1302          case ID_KEYMISC_OT:              if (!single) gpgme_data_write (out, "\r\n", 2);
1303              dialog_box_param( glob_hinst, (LPCTSTR)IDD_WINPT_OWNERTRUST, glob_hwnd,              break;
1304                                ownertrust_dlg_proc, NULL,  
1305                                _("Ownertrust"), IDS_WINPT_OWNERTRUST );          case ID_KEYCTX_UID_COPY:
1306              break;              key = km_get_key_ptr (kmi->kl, i, &kci);
1307                gpgme_data_write (out, kci->uids->uid, strlen (kci->uids->uid));
1308          case ID_KEYMISC_EDITKEY:              if (!single) gpgme_data_write (out, "\r\n", 2);
1309              idx = listview_get_curr_pos (kmi->lv);              break;
1310              if (idx == -1)  
1311                  break;          case ID_KEYCTX_KEYID_COPY:
1312              listview_get_item_text (kmi->lv, idx, 1, keyid, sizeof (keyid)-1);              key = km_get_key_ptr (kmi->kl, i, NULL);
1313              /* XXX: pub/crd = secret key does not work */              gpgme_data_write (out, "0x", 2);
1314              memset (&k, 0, sizeof (k));              gpgme_data_write (out, key->subkeys->keyid+8, 8);
1315              k.is_protected = km_check_if_protected (kmi->lv, idx);              if (!single) gpgme_data_write (out, "\r\n", 2);
1316              k.key_pair = km_check_for_seckey (kmi->lv, idx, NULL);              break;
1317              k.keyid = keyid;  
1318              k.is_v3 = km_key_is_v3 (kmi->lv, idx);          case ID_KEYCTX_FPR_COPY:
1319              k.flags = km_get_key_status (kmi->lv, idx);              key = km_get_key_ptr (kmi->kl, i, NULL);
1320              dialog_box_param (glob_hinst, (LPCTSTR)IDD_WINPT_KEYEDIT, dlg,              gpgme_data_write (out, key->subkeys->fpr, strlen (key->subkeys->fpr));
1321                                keyedit_main_dlg_proc, (LPARAM)&k,              if (!single) gpgme_data_write (out, "\r\n", 2);
1322                                _("Key Edit"), IDS_KEYCTX_EDIT);              break;
1323              if (k.update)  
1324                  update_key (kmi->lv,  idx, keyid, 1);          case ID_KEYCTX_KINFO_COPY:
1325              break;              key = km_get_key_ptr (kmi->kl, i, NULL);
1326                            key_get_clip_info (key->subkeys->keyid+8, tmp, sizeof (tmp)-1);
1327          case ID_KEYMISC_COPY:              gpgme_data_write (out, tmp, strlen (tmp));
1328              km_index = listview_get_curr_pos (kmi->lv);              if (!single) gpgme_data_write (out, "\r\n", 2);
1329              km_clip_export (dlg, kmi->lv);              break;
1330              break;          }
1331                    }
1332          case ID_KEYMISC_SELALL:      gpgme_data_write (out, "\0", 1);
1333              listview_select_all (kmi->lv);      p = gpgme_data_release_and_get_mem (out, &n);
1334              break;      set_clip_text (NULL, p, n);
1335        gpgme_free (p);
1336          case ID_KEYMISC_PASTE:  }
1337              km_index = -1;  
1338              km_clip_import (dlg);  /* Dialog box procedure for the Key Manager. */
1339              break;  BOOL CALLBACK
1340                keymanager_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
1341          case ID_KEYCTX_SETPREFKS:  {
1342              listview_get_item_text (kmi->lv, idx, 1, keyid, DIM(keyid)-1);      HWND kl;
1343              memset (&k, 0, sizeof (k));      HMENU hm;
1344              k.keyid = keyid;      RECT r;
1345              keyedit_set_pref_keyserver (&k, dlg);      gpg_keycache_t c;
1346              break;      gpgme_key_t key;
1347        km_info_t kmi = NULL;    
1348          case ID_KEYMISC_REFRESH_KEYS:      struct genkey_s genkey;
1349              if (listview_count_items (kmi->lv, 1) == 0) {      struct winpt_key_s k = {0};
1350                  msg_box (dlg, _("No key was selected, select all by default."), _("Key Manager"), MB_INFO);      struct URL_ctx_s *url;
1351                  listview_select_all (kmi->lv);      char type[32];
1352              }      char *name;
1353              km_refresh_from_keyserver (kmi->lv, dlg);      const char *t, *host;
1354              break;      WORD port = 0;
1355                                int l_idx = 0, i=0, rc;
1356          /** Context menu **/  
1357          case ID_KEYCTX_EDIT:      if ((msg != WM_INITDIALOG)
1358              send_cmd_id( dlg, ID_KEYMISC_EDITKEY );          && ((kmi = (km_info_t)GetWindowLong (dlg, GWL_USERDATA)) == NULL))
1359              break;          return FALSE;
1360        
1361          case ID_KEYCTX_PROPS:      /* handle dynamic popup items in the keyserver menu. */
1362              send_cmd_id( dlg, ID_KEYMISC_PROPS );      if (msg == WM_COMMAND && LOWORD (wparam) >= WM_APP &&
1363              break;                               LOWORD (wparam) <= WM_APP+MAX_KEYSERVERS) {
1364            l_idx = LOWORD (wparam)-WM_APP;
1365          case ID_KEYCTX_UIDS:          if (l_idx < 0)
1366              send_cmd_id( dlg, ID_KEYMISC_UID );              return TRUE;
1367              break;          host = kserver_get_hostname (l_idx, 0, &port);
1368            if (host != NULL)
1369          case ID_KEYCTX_SIGN:              km_send_to_keyserver (kmi->kl, dlg, host, port);
1370              send_cmd_id( dlg, ID_KEYMISC_SIGN );          return TRUE;
1371              break;      }
1372    
1373          case ID_KEYCTX_DEL:      switch (msg) {    
1374              send_cmd_id (dlg, ID_KEYMISC_DELETE);      case WM_HELP:        
1375              break;          if (GetForegroundWindow () != dlg) {
1376                char buf[258];
1377          case ID_KEYCTX_REV:              GetWindowText (GetForegroundWindow (), buf, 255);
1378              send_cmd_id( dlg, ID_KEYMISC_REVCERT );              if (strstr (buf, _("Key Generation Wizard")))
1379              break;                  html_help_show (28);
1380                else
1381          case ID_KEYCTX_SENDMAIL:                  html_help_show (32);
1382              km_send_to_mail_recipient (kmi->lv, dlg);          }
1383              break;          else {
1384                name = get_locale_name("winpt.chm");
1385          case ID_KEYCTX_KS_DEFAULT:              ShellExecute (dlg, "open", name, NULL, NULL, SW_SHOW);
1386              host = kserver_get_hostname (0, -1, &port);              free_if_alloc (name);
1387              km_send_to_keyserver (kmi->lv, dlg, host, port);          }
1388              break;          break;
1389            
1390          case ID_KEYCTX_ADDKEY:      case WM_INITDIALOG:
1391              idx = listview_get_curr_pos (kmi->lv);          kmi = new struct km_info_s;
1392              listview_get_item_text( kmi->lv, idx, 1, keyid, DIM (keyid)-1);          memset (kmi, 0, sizeof (struct km_info_s));
1393              memset (&k, 0, sizeof (k));          kmi->lv_idx = -1;
1394              k.key_pair = km_check_for_seckey (kmi->lv, idx, NULL);          kmi->hwnd_sep = register_separator_window (dlg, kmi);
1395              k.is_protected = km_check_if_protected (kmi->lv, idx);          km_imagelist_load (dlg, &kmi->iconlist);
1396              k.keyid = keyid;          translate_menu_strings (dlg);
1397              keyedit_add_subkey (&k, dlg, NULL);          SetWindowText (dlg, _("Key Manager"));
1398              if (k.update)  
1399                  update_key (kmi->lv, idx, keyid, 1);          c = keycache_get_ctx (KEYCACHE_PUB);
1400              break;          kl = GetDlgItem (dlg, IDC_KEYMISC_KEYLIST);
1401            kmi->keylist_sortby = KEY_SORT_USERID;
1402          case ID_KEYCTX_ADDUID:          (void)Header_SetImageList(ListView_GetHeader (kl), kmi->iconlist);
1403              idx = listview_get_curr_pos (kmi->lv);          kmi->kl = keylist_load (kl, c, NULL, KEYLIST_LIST,
1404              listview_get_item_text( kmi->lv, idx, 1, keyid, DIM (keyid)-1);                                  kmi->keylist_sortby);
1405              memset (&k, 0, sizeof (k));          kmi->lv = kmi->kl->lv;
1406              k.key_pair = km_check_for_seckey (kmi->lv, idx, NULL);          if (check_ultimate_trusted_key (keycache_get_ctx (0))) {            
1407              k.is_protected = km_check_if_protected (kmi->lv, idx);              msg_box (dlg, _("No ultimately trusted key found.\n"
1408              k.keyid = keyid;                              "Please set at least one secret key to ultimate trust."),
1409              keyedit_add_userid (&k, dlg, NULL);                              _("Key Manager"), MB_WARN);
1410              if (k.update)          }
1411                  update_key (kmi->lv, idx, keyid, 1);          /* init subclassing for the listview */
1412              break;          keylist_proc.opaque = kmi;
1413            keylist_proc.dlg = dlg;
1414          case ID_KEYCTX_ADDREV:          keylist_proc.current = (WNDPROC)keylist_subclass_proc;
1415              idx = listview_get_curr_pos (kmi->lv);          keylist_proc.old = (WNDPROC)GetWindowLong(kl, GWL_WNDPROC);
1416              listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);          if (keylist_proc.old) {
1417              memset (&k, 0, sizeof (k));              if (!SetWindowLong (kl, GWL_WNDPROC, (LONG)keylist_proc.current)) {
1418              k.keyid = keyid;                  msg_box (dlg, "Could not set keylist window procedure.",
1419              k.is_protected = km_check_if_protected (kmi->lv, idx);                           _("Key Manager"), MB_ERR);
1420              k.key_pair = km_check_for_seckey( kmi->lv, idx, NULL );                  BUG (NULL);
1421              keyedit_add_revoker (&k, dlg);              }
1422              if (k.update)          }
1423                  update_key (kmi->lv, idx, keyid, 1);          kmi->statbar = setup_status_bar (dlg, kmi->lv);
1424              break;          SetWindowLong (dlg, GWL_USERDATA, (LONG)kmi);
1425            kmi->toolbar = create_toolbar (dlg, kmi);
1426          case ID_KEYCTX_ADDPHOTO:          kmi->dlg = dlg;
1427              idx = listview_get_curr_pos (kmi->lv);          
1428              listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);          do_center_window (dlg, kmi);
1429              memset (&k, 0, sizeof (k));          do_resize_window (dlg, kmi);
1430              k.keyid = keyid;          restore_window_size (dlg, kmi);
1431              k.is_protected = km_check_if_protected (kmi->lv, idx);          update_ui_items (dlg, kmi->kl);
1432              k.key_pair = km_check_for_seckey (kmi->lv, idx, NULL);          restore_column_info (kmi);
1433              keyedit_add_photo (&k, dlg);          keylist_sort (kmi->kl, kmi->keylist_sortby);
1434              if (k.update)          km_gui_adjust_column_images (kmi, kmi->keylist_sortby);
1435                  update_key (kmi->lv, idx, keyid, 1);  
1436              break;          // force a redraw of the keylist view
1437            redraw_keylist (kmi);
1438          case ID_KEYCTX_KS_NL:  
1439          case ID_KEYCTX_KS_PL:          SendMessage (dlg, WM_SETICON, (WPARAM)ICON_SMALL,
1440          case ID_KEYCTX_KS_AT:                       (LPARAM)LoadIcon (glob_hinst, (LPCTSTR)IDI_WINPT));
1441          case ID_KEYCTX_KS_DE:          SetForegroundWindow (dlg);
1442          case ID_KEYCTX_KS_DK:          kmi->magic = SetTimer (dlg, 1, 1000, NULL);
1443          case ID_KEYCTX_KS_CZ:          return TRUE;  
1444          case ID_KEYCTX_KS_ES:  
1445          case ID_KEYCTX_KS_UK:      case WM_TIMER:
1446              host = kserver_get_hostname (LOWORD (wparam) - 40107, 0, &port);          KillTimer (dlg, kmi->magic);
1447              km_send_to_keyserver (kmi->lv, dlg, host, port);          SetForegroundWindow (dlg);
1448              break;          break;
1449            
1450          case ID_KEYCTX_RECVFROM:      case WM_DESTROY:
1451              km_refresh_from_keyserver (kmi->lv, dlg);          save_column_info (kmi);
1452              break;          km_imagelist_destroy (kmi->iconlist);
1453            if (kmi->kl) {
1454          case ID_KEYCTX_UID_COPY:              keylist_delete (kmi->kl);
1455              /* XXX: add generic function to support multiple selection              kmi->kl = NULL;      
1456                      with a callback */          }
1457              idx = listview_get_curr_pos( kmi->lv );  
1458              listview_get_item_text( kmi->lv, idx, 0, uid, sizeof uid-1 );          ltoa (kmi->pos_x, type, 10);
1459              set_clip_text( NULL, uid, strlen( uid ) );          set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "KM_Pos_X", type);
1460              break;          ltoa (kmi->pos_y, type, 10);
1461            set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "KM_Pos_Y", type);
1462          case ID_KEYCTX_KEYID_COPY:  
1463              idx = listview_get_curr_pos( kmi->lv );          GetWindowRect (dlg, &r);
1464              listview_get_item_text( kmi->lv, idx, 1, uid, sizeof uid-1 );          sprintf (type, "%d", (int)(r.bottom-r.top));
1465              set_clip_text( NULL, uid, strlen( uid ) );          set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "KM_Size_Width",
1466              break;                             type);
1467            sprintf (type, "%d", (int)(r.right-r.left));
1468          case ID_KEYCTX_FPR_COPY:          set_reg_entry (HKEY_CURRENT_USER, "Software\\WinPT", "KM_Size_Height",
1469              idx = listview_get_curr_pos( kmi->lv );                          type);
1470              key = (gpgme_key_t) listview_get_item2 (kmi->lv, idx);          
1471              if (key) {          /* Remove runtime information.
1472                  const char * s = get_key_fpr (key);             This should be the last action taken here. */
1473                  set_clip_text (NULL, s? s : "", s? strlen (s): 0);          delete kmi;
1474              }          kmi = NULL;
1475              break;          SetWindowLong (dlg, GWL_USERDATA, 0);
1476            return FALSE;
1477          case ID_KEYCTX_KINFO_COPY:  
1478              idx = listview_get_curr_pos( kmi->lv );      case WM_MOVE:
1479              listview_get_item_text( kmi->lv, idx, 1, uid, sizeof uid-1 );          GetWindowRect (dlg, &r);
1480              km_set_clip_info( uid );                  kmi->pos_x = r.left;
1481              break;          kmi->pos_y = r.top;    
1482            break;
1483          case ID_KEYCTX_COPY:          
1484              km_index = listview_get_curr_pos (kmi->lv);  
1485              km_clip_export (dlg, kmi->lv);      case WM_RBUTTONUP:
1486              break;          do_create_minpopup (dlg);
1487            break;
1488          case ID_KEYCTX_PASTE:    
1489              km_index = -1;      case WM_NOTIFY:            
1490              km_clip_import (dlg);          NMHDR *notify;        
1491              break;          
1492            notify = (NMHDR *)lparam;
1493          case ID_KEYCTX_DISABLE:          if (!notify)
1494              idx = listview_get_curr_pos (kmi->lv);              break;
1495              km_enable_disable_key (kmi->lv, dlg, idx, 0);          
1496              break;          if (kmi->enable_redraw) {
1497                int n;
1498          case ID_KEYCTX_ENABLE:              n = keylist_listview_notify (dlg, kmi->kl->keys, IDC_KEYMISC_KEYLIST,
1499              idx = listview_get_curr_pos (kmi->lv);                                           lparam);
1500              km_enable_disable_key (kmi->lv, dlg, idx, 1);              if (n != 0) {
1501              break;                  SetWindowLong (dlg, DWL_MSGRESULT, n);
1502                    return TRUE;
1503          case ID_KEYCTX_LISTSIGS:              }
1504              send_cmd_id (dlg, ID_KEYMISC_CHECKSIGS);          }
1505              break;          
1506            switch (notify->code) {
1507          case ID_KEYCTX_MAXTRUST:          case TBN_QUERYDELETE:
1508              idx = listview_get_curr_pos (kmi->lv);              SetWindowLong (dlg, DWL_MSGRESULT, TRUE);
1509              listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);              return TRUE;
1510              rc = km_set_implicit_trust (dlg, kmi->lv, idx);          
1511              if (!rc)          case TBN_QUERYINSERT:
1512                  update_key (kmi->lv, idx, keyid, 0);              SetWindowLong (dlg, DWL_MSGRESULT, TRUE);
1513              break;              return TRUE;
1514    
1515          case ID_KEYCTX_SETDEFKEY:          case TBN_GETBUTTONINFO:
1516              idx = listview_get_curr_pos (kmi->lv);              LPTBNOTIFY lpTbNotify;
1517              if (!km_check_key_status (kmi->lv, idx)) {              lpTbNotify = (LPTBNOTIFY)lparam;
1518                  listview_get_item_text (kmi->lv, idx, 1, keyid, DIM (keyid)-1);              if (lpTbNotify->iItem < (sizeof (tbb) / sizeof (tb_button_s))) {
1519                  rc = set_gnupg_default_key (keyid);                  lpTbNotify->tbButton.iBitmap = km_imagelist_getindex (kmi->iconlist,
1520                  if (rc)                                                                        tbb[lpTbNotify->iItem].icon);
1521                      msg_box( dlg, winpt_strerror (rc), _("Key Manager"), MB_ERR);                  lpTbNotify->tbButton.idCommand = tbb[lpTbNotify->iItem].command;
1522                  km_update_default_key_str (kmi->statbar);                  lpTbNotify->tbButton.fsState = TBSTATE_ENABLED;
1523              }                  lpTbNotify->tbButton.fsStyle = TBSTYLE_BUTTON;
1524              break;                  lpTbNotify->tbButton.iString = 0;
1525                    strncpy (lpTbNotify->pszText, tbb[lpTbNotify->iItem].text,
1526          #if 0 /* XXX */                           lpTbNotify->cchText);
1527          case ID_GROUP_NEW:                  SetWindowLong (dlg, DWL_MSGRESULT, TRUE);
1528              memset (&gcb, 0, sizeof (gcb));              }
1529              gcb.gc = gc;              return TRUE;
1530              dialog_box_param (glob_hinst, (LPCSTR)IDD_WINPT_GROUP, glob_hwnd,  
1531                               group_manager_dlg_proc, (LPARAM)&gcb, _("New Group"),          case TBN_RESET: /* Restore last saved toolbar status */
1532                               IDS_WINPT_GROUP);              TBSAVEPARAMS tbsp;
1533              if( gcb.use_name )  
1534                  treeview_add_item( GetDlgItem(dlg, IDC_KEYMISC_GROUP), NULL, gcb.name );              tbsp.hkr = HKEY_CURRENT_USER;
1535              return TRUE;              tbsp.pszSubKey = "Software\\WinPT";
1536                            tbsp.pszValueName = "KM_toolbar";
1537          case ID_GROUP_PASTE:              SendMessage (notify->hwndFrom, TB_SAVERESTORE, FALSE, (LPARAM)&tbsp);
1538              km_groups_add (gc, kmi->lv, km_index);              break;
1539              break;  
1540                        case TBN_BEGINADJUST: /* User is about to change the toolbar. Save it */
1541          case ID_GROUP_DELETE:              tbsp.hkr = HKEY_CURRENT_USER;
1542              km_groups_del (gc);              tbsp.pszSubKey = "Software\\WinPT";
1543              break;              tbsp.pszValueName = "KM_toolbar";
1544          #endif              SendMessage (notify->hwndFrom, TB_SAVERESTORE, TRUE, (LPARAM)&tbsp);
1545          }              break;
1546            
1547          break;          case TBN_ENDADJUST: /* User has finished customizing the toolbar. Save it. */
1548      }              tbsp.hkr = HKEY_CURRENT_USER;
1549                    tbsp.pszSubKey = "Software\\WinPT";
1550      return FALSE;              tbsp.pszValueName = "KM_toolbar";
1551  }              SendMessage (notify->hwndFrom, TB_SAVERESTORE, TRUE, (LPARAM)&tbsp);
1552                break;
1553    
1554            case TTN_GETDISPINFO:
1555                LPTOOLTIPTEXT lpttt;
1556                lpttt = (LPTOOLTIPTEXT)lparam;
1557    
1558                lpttt->hinst = NULL;
1559                switch (lpttt->hdr.idFrom) {
1560                case ID_KEYMISC_KEYWIZARD:
1561                    lpttt->lpszText = (char*)_("Generate new key pair");
1562                    break;
1563    
1564                case ID_KEYMISC_SENDRECV:
1565                    lpttt->lpszText = (char*)_("Search for a specific key");
1566                    break;
1567    
1568                case ID_KEYMISC_DELETE:
1569                    lpttt->lpszText = (char *)_("Delete key from keyring");
1570                    break;
1571    
1572                case ID_KEYMISC_PROPS:
1573                    lpttt->lpszText = (char *)_("Show key properties");
1574                    break;
1575    
1576                case ID_KEYMISC_SIGN:
1577                    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.28  
changed lines
  Added in v.447
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26