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

Legend:
Removed from v.16  
changed lines
  Added in v.211

[email protected]
ViewVC Help
Powered by ViewVC 1.1.26