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

Diff of /trunk/Src/wptKeyManagerDlg.cpp

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

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