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

Legend:
Removed from v.25  
changed lines
  Added in v.104

[email protected]
ViewVC Help
Powered by ViewVC 1.1.26