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