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

Contents of /trunk/Src/wptFileManagerDlg.cpp

Parent Directory Parent Directory | Revision Log Revision Log

Revision 32 - (show annotations)
Mon Oct 24 08:03:48 2005 UTC (19 years, 4 months ago) by twoaday
File size: 25916 byte(s) 
2005-10-23  Timo Schulz  <twoaday@g10code.com>
 
        * wptFileManager.cpp (fm_get_file_type): Detect detached sigs.
        * wptKeyList.cpp (keylist_cmp_cb): Take care of expired/revoked keys.
        (get_ext_validity): New.
        * wptFileVerifyDlg.cpp (file_verify_dlg_proc): Several cleanups.
        * wptClipEditDlg.cpp (load_clipboard): Factored out some code into
        this function.
        (load_clipboard_from_file): Likewise.
        (save_clipboard_to_file): New.
        * wptKeyManagerDlg.cpp (keyprops_dlg_proc): Fix stack overflow.

For complete details, see the ChangeLog files.
1 /* wptFileMangerDlg.cpp - File Manager
2 * Copyright (C) 2001-2005 Timo Schulz
3 *
4 * This file is part of WinPT.
5 *
6 * WinPT is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * WinPT is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with WinPT; if not, write to the Free Software Foundation,
18 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19 */
20
21 #include <windows.h>
22 #include <commctrl.h>
23 #include <sys/stat.h>
24
25 #include "../resource.h"
26 #include "wptCommonCtl.h"
27 #include "wptGPG.h"
28 #include "wptW32API.h"
29 #include "wptKeylist.h"
30 #include "wptErrors.h"
31 #include "wptContext.h" /* for passphrase_s */
32 #include "wptDlgs.h"
33 #include "wptTypes.h"
34 #include "wptNLS.h"
35 #include "wptVersion.h"
36 #include "wptFileManager.h"
37 #include "wptRegistry.h"
38
39 #define FM_SEPARATOR_ID 10001
40
41 #define send_cmd_id(hwnd, id) \
42 PostMessage ((hwnd), WM_COMMAND, MAKEWPARAM( (id), 0), 0)
43
44 static subclass_s filelist_proc;
45
46 struct thread_ctx_s {
47 HWND dlg;
48 HANDLE fd;
49 char *drive;
50 };
51 typedef struct thread_ctx_s *thread_ctx_t;
52
53
54 /* Dialog procedure for selecting recipients for encryption. */
55 BOOL CALLBACK
56 file_encrypt_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
57 {
58 static listview_ctrl_t lv = NULL;
59 static fm_state_t c;
60 static int req_signer = 0;
61 static keylist_t list = NULL;
62 gpg_keycache_t kc;
63 gpgme_ctx_t ctx;
64 int force_trust = 0, count = 0;
65
66 switch (msg) {
67 case WM_INITDIALOG:
68 req_signer = 0;
69 c = (fm_state_t)lparam;
70 if (!c)
71 dlg_fatal_error( dlg, "Could not get dialog state!" );
72 kc = keycache_get_ctx (KEYCACHE_PUB);
73 if (!kc)
74 BUG (dlg);
75 #ifndef LANG_DE
76 SetWindowText( dlg, _("File Encrypt") );
77 SetDlgItemText( dlg, IDC_ENCRYPT_ARMOR, _("&Text Output") );
78 SetDlgItemText( dlg, IDC_ENCRYPT_WIPE, _("&Wipe Original") );
79 #endif
80 if (c->req_signer) {
81 EnableWindow (GetDlgItem (dlg, IDC_ENCRYPT_SIGN), TRUE);
82 seclist_init (dlg, IDC_ENCRYPT_SECLIST, KEYLIST_FLAG_SHORT, &list);
83 }
84 lv = keylist_load (GetDlgItem (dlg, IDC_ENCRYPT_LIST), kc, NULL,
85 KEYLIST_ENCRYPT|KEYLIST_FLAG_FILE, KEY_SORT_USERID);
86 SetForegroundWindow (dlg);
87 return TRUE;
88
89 case WM_DESTROY:
90 seclist_destroy (&list);
91 if (lv) {
92 keylist_delete (lv);
93 lv = NULL;
94 }
95 return FALSE;
96
97 case WM_NOTIFY:
98 NMHDR *notify;
99 notify = (NMHDR *)lparam;
100 if( notify && notify->code == LVN_COLUMNCLICK
101 && notify->idFrom == IDC_ENCRYPT_LIST ) {
102 NMLISTVIEW *p = (LPNMLISTVIEW) lparam;
103 int sortby = 0;
104
105 switch( p->iSubItem ) {
106 case 0: sortby = KEY_SORT_USERID; break;
107 case 1: sortby = KEY_SORT_KEYID; break;
108 case 2: sortby = KEY_SORT_LEN; break;
109 case 4: sortby = KEY_SORT_VALIDITY; break;
110 default:sortby = KEY_SORT_USERID; break;
111 }
112 keylist_sort( lv, sortby );
113 }
114
115 case WM_SYSCOMMAND:
116 if( LOWORD( wparam ) == SC_CLOSE ) {
117 c->cancel = 1;
118 EndDialog( dlg, TRUE );
119 }
120 return FALSE;
121
122 case WM_COMMAND:
123 if (HIWORD (wparam) == BN_CLICKED
124 && LOWORD (wparam) == IDC_ENCRYPT_SIGN) {
125 req_signer ^= 1;
126 EnableWindow (GetDlgItem (dlg, IDC_ENCRYPT_SECLIST),
127 req_signer? TRUE : FALSE);
128 }
129 switch( LOWORD( wparam ) ) {
130 case IDOK:
131 ctx = c->ctx;
132 if (c->recp)
133 free (c->recp);
134 c->recp = keylist_get_recipients (lv, &force_trust, &c->n_recp);
135 if (!c->n_recp) {
136 msg_box (dlg, _("Please select at least one recipient."),
137 _("File Encrypt"), MB_ERR);
138 free (c->recp);
139 c->recp = NULL;
140 c->cancel = 1;
141 return TRUE;
142 }
143 if (IsDlgButtonChecked (dlg, IDC_ENCRYPT_SIGN)) {
144 gpgme_key_t key;
145
146 if (seclist_select_key (dlg, IDC_ENCRYPT_SECLIST, &key))
147 return TRUE;
148 else
149 gpgme_signers_add (c->ctx, key);
150 }
151
152 if (IsDlgButtonChecked (dlg, IDC_ENCRYPT_ARMOR))
153 gpgme_set_armor (ctx, 1);
154 if (IsDlgButtonChecked (dlg, IDC_ENCRYPT_WIPE))
155 c->wipe = 1;
156 /* XXX: implement this
157 if (IsDlgButtonChecked (dlg, IDC_ENCRYPT_ANON))
158 ;
159 */
160 c->cancel = 0;
161 EndDialog (dlg, TRUE);
162 return TRUE;
163
164 case IDCANCEL:
165 c->cancel = 1;
166 EndDialog (dlg, FALSE);
167 return TRUE;
168 }
169 return TRUE;
170 }
171
172 return FALSE;
173 } /* file_encrypt_dlg_proc */
174
175
176 BOOL CALLBACK
177 file_import_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
178 {
179 static listview_ctrl_t lv = NULL;
180 static fm_state_t c;
181 static int is_revcert = 0, has_seckeys = 0;
182
183 switch( msg ) {
184 case WM_INITDIALOG:
185 c = (fm_state_s *)lparam;
186 if (!c)
187 dlg_fatal_error( dlg, "Could not get dialog param!" );
188 #ifndef LANG_DE
189 SetWindowText (dlg, _("Key Import"));
190 #endif
191 ShowWindow( GetDlgItem( dlg, IDC_IMPORT_KEYMNGT ), WS_DISABLED );
192 /* XXX: use the new code */
193 implist_build (&lv, GetDlgItem (dlg, IDC_IMPORT_KEYLIST));
194 implist_load (lv, c->opaque, &is_revcert, &has_seckeys);
195 if (!listview_count_items (lv, 0)) {
196 msg_box (dlg, _("No valid OpenPGP data found."), _("Key Import"), MB_ERR);
197 c->cancel = 1;
198 EndDialog (dlg, FALSE);
199 }
200 else {
201 const char *s = "File contain(s) %d key(s).";
202 char *p = new char[strlen (s) + 32];
203 if (!p)
204 BUG (0);
205 sprintf (p, s, listview_count_items (lv, 0));
206 SetDlgItemText (dlg, IDC_IMPORT_INFO, p);
207 free_if_alloc (p);
208 }
209 SetForegroundWindow (dlg);
210 return TRUE;
211
212 case WM_DESTROY:
213 if (lv) {
214 listview_release (lv);
215 lv = NULL;
216 }
217 return FALSE;
218
219 case WM_SYSCOMMAND:
220 if (LOWORD (wparam) == SC_CLOSE) {
221 c->cancel = 1;
222 EndDialog (dlg, FALSE);
223 }
224 return FALSE;
225
226 case WM_COMMAND:
227 switch (LOWORD (wparam)) {
228 case IDC_IMPORT_DOIT:
229 c->cancel = 0;
230 c->import.revcert = is_revcert? 1 : 0;
231 c->import.has_seckey = has_seckeys? 1 : 0;
232 EndDialog (dlg, TRUE);
233 return TRUE;
234
235 case IDCANCEL:
236 c->cancel = 1;
237 EndDialog (dlg, FALSE);
238 return FALSE;
239 }
240 break;
241 }
242
243 return FALSE;
244 } /* file_import_dlg_proc */
245
246
247 BOOL CALLBACK
248 file_sign_dlg_proc( HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam )
249 {
250 static fm_state_t c;
251 static listview_ctrl_t lv;
252 gpg_keycache_t kc, sec_kc;
253 gpgme_key_t key;
254 int lv_idx;
255 char signer[32];
256
257 switch( msg ) {
258 case WM_INITDIALOG:
259 c = (fm_state_s *)lparam;
260 if( c == NULL )
261 dlg_fatal_error( dlg, "Could not get dialog state!" );
262 #ifndef LANG_DE
263 SetWindowText (dlg, _("File Sign"));
264 SetDlgItemText (dlg, IDC_FILE_SIG_ARMOR, _("&Text Output") );
265 SetDlgItemText (dlg, IDC_FILE_SIG_NORMAL, _("&Normal Signature"));
266 SetDlgItemText (dlg, IDC_FILE_SIG_DETACH, _("&Detached Signature"));
267 SetDlgItemText (dlg, IDC_FILE_SIG_CLEAR, _("&Cleartext Signature"));
268 #endif
269 CheckDlgButton (dlg, IDC_FILE_SIG_DETACH, BST_CHECKED);
270 kc = keycache_get_ctx (KEYCACHE_PUB);
271 if (!kc)
272 BUG (dlg);
273 sec_kc = keycache_get_ctx (KEYCACHE_PRV);
274 if (!sec_kc)
275 BUG( dlg );
276 lv = keylist_load( GetDlgItem(dlg, IDC_FILE_SIG_LIST), kc, sec_kc,
277 KEYLIST_SIGN, KEY_SORT_USERID );
278 SetForegroundWindow( dlg );
279 return TRUE;
280
281 case WM_DESTROY:
282 if( lv ) {
283 listview_release( lv );
284 lv = NULL;
285 }
286 return FALSE;
287
288 case WM_SYSCOMMAND:
289 if( LOWORD (wparam) == SC_CLOSE )
290 EndDialog( dlg, TRUE );
291 return FALSE;
292
293 case WM_COMMAND:
294 switch( LOWORD( wparam ) ) {
295 case IDOK:
296 if( IsDlgButtonChecked( dlg, IDC_FILE_SIG_ARMOR ) )
297 gpgme_set_armor (c->ctx, 1);
298 if( IsDlgButtonChecked( dlg, IDC_FILE_SIG_NORMAL ) )
299 c->sigmode = GPGME_SIG_MODE_NORMAL;
300 else if( IsDlgButtonChecked( dlg, IDC_FILE_SIG_DETACH ) )
301 c->sigmode = GPGME_SIG_MODE_DETACH;
302 else if( IsDlgButtonChecked( dlg, IDC_FILE_SIG_CLEAR ) )
303 c->sigmode = GPGME_SIG_MODE_CLEAR;
304 else {
305 /* default is to produce detached signatures */
306 c->sigmode = GPGME_SIG_MODE_DETACH;
307 }
308 lv_idx = listview_get_curr_pos( lv );
309 if (lv_idx == -1) {
310 if (listview_count_items (lv, 0) == 1)
311 lv_idx = 0;
312 else {
313 msg_box (dlg, _("Please select a key."), _("Sign"), MB_ERR);
314 return FALSE;
315 }
316 }
317 listview_get_item_text( lv, lv_idx, 1, signer, sizeof signer-1 );
318 if( get_seckey( signer, &key ) )
319 BUG( NULL );
320 gpgme_signers_clear (c->ctx);
321 gpgme_signers_add (c->ctx, key);
322 free_if_alloc (c->opaque);
323 c->opaque = m_strdup (signer); /* store for later use */
324 c->cancel = 0;
325 if (!c->opaque)
326 BUG (0);
327 EndDialog (dlg, TRUE);
328 return TRUE;
329
330 case IDCANCEL:
331 c->cancel = 1;
332 EndDialog (dlg, FALSE);
333 return FALSE;
334 }
335 break;
336 }
337
338 return FALSE;
339 } /* file_sign_dlg_proc */
340
341
342
343 /* Setup status bar for the main window @dlg. */
344 static HWND
345 setup_status_bar (HWND dlg)
346 {
347 HWND statbar;
348 RECT r;
349 int partpos[3];
350 int i;
351
352 GetClientRect (dlg, &r);
353 for (i=1; i <= 3; i++)
354 partpos[i-1] = r.right/3*i;
355
356 statbar = CreateStatusWindow (WS_CHILD | WS_VISIBLE | CCS_BOTTOM,
357 "", dlg, FM_SEPARATOR_ID);
358 ShowWindow (statbar, SW_SHOW);
359 SendMessage (statbar, SB_SETPARTS, (WPARAM)3, (LPARAM)partpos);
360 return statbar;
361 }
362
363
364 /* Refresh the status bar text with the selected item from @lv. */
365 static void
366 update_status_bar (HWND statbar, listview_ctrl_t lv)
367 {
368 struct stat st;
369 char buf[128];
370 int n;
371
372 if (!lv) { /* flush */
373 SendMessage (statbar, SB_SETTEXT, 1, (LPARAM)"0 KB");
374 SendMessage (statbar, SB_SETTEXT, 0, (LPARAM)"0 Objects marked");
375 return;
376 }
377 n = listview_count_items (lv, 1);
378 _snprintf (buf, sizeof (buf)-1, "%d Object(s) marked", n);
379 SendMessage (statbar, SB_SETTEXT, 0, (LPARAM)buf);
380 listview_get_item_text (lv, listview_get_curr_pos (lv), 1, buf, 127);
381 if (stat (buf, &st) == 0) {
382 _snprintf (buf, sizeof (buf)-1, "%d KB", st.st_size/1024);
383 SendMessage (statbar, SB_SETTEXT, 1, (LPARAM)buf);
384 }
385 else
386 SendMessage (statbar, SB_SETTEXT, 1, (LPARAM)"0 KB");
387 }
388
389
390 static BOOL CALLBACK
391 filelist_subclass_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
392 {
393 switch (msg) {
394 case WM_KEYUP:
395 int virt_key = (int)wparam;
396 if (virt_key == VK_DELETE)
397 send_cmd_id (filelist_proc.dlg, ID_FILEMISC_WIPE);
398 break;
399 }
400 return CallWindowProc (filelist_proc.old, dlg, msg, wparam, lparam);
401 }
402
403
404 BOOL CALLBACK
405 file_manager_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
406 {
407 static HWND statbar;
408 static listview_ctrl_t lv = NULL;
409 static HMENU menu = NULL;
410 static int always_ontop = 1;
411 HWND fl;
412
413 switch (msg) {
414 case WM_INITDIALOG:
415 always_ontop = 1;
416 menu = LoadMenu (glob_hinst, (LPCSTR)IDR_WINPT_FILEMISC);
417 SetWindowText (dlg, _("File Manager (use drag & drop to add files)"));
418 set_menu_text (menu, ID_FILEMISC_OPEN, _("&Open...") );
419 set_menu_text (menu, ID_FILEMISC_ENCRYPT, _("&Encrypt") );
420 set_menu_text (menu, ID_FILEMISC_DECRYPT, _("&Decrypt") );
421 set_menu_text (menu, ID_FILEMISC_SIGN, _("&Sign") );
422 set_menu_text (menu, ID_FILEMISC_SIGNENC, _("Sign && Encrypt") );
423 set_menu_text (menu, ID_FILEMISC_VERIFY, _("&Verify") );
424 set_menu_text (menu, ID_FILEMISC_SYMENC, _("S&ymmetric") );
425 set_menu_text (menu, ID_FILEMISC_IMPORT, _("&Import") );
426 set_menu_text (menu, ID_FILEMISC_EXPORT, _("E&xport") );
427 set_menu_text (menu, ID_FILEMISC_QUIT, _("Exit"));
428 set_menu_text (menu, ID_FILEMISC_CLEAR, _("&Reset") );
429 set_menu_text (menu, ID_FILEMISC_ONTOP, _("Always on Top"));
430 set_menu_text (menu, ID_FILEMISC_PASTE, _("&Paste"));
431 set_menu_text (menu, ID_FILEMISC_SELALL, _("&Select All"));
432 set_menu_text (menu, ID_FILEMISC_PREFS, _("&Preferences"));
433 set_menu_text (menu, ID_FILEMISC_SEND, _("Send as Mail"));
434 set_menu_text (menu, ID_FILEMISC_LIST, _("&List Packets"));
435 set_menu_text (menu, ID_FILEMISC_WIPE_FREES, _("Wipe Free Space"));
436 set_menu_text (menu, ID_FILEMISC_WIPE, _("&Wipe"));
437
438 fl = GetDlgItem (dlg, IDC_FILE_LIST);
439 filelist_proc.dlg = dlg;
440 filelist_proc.current = (WNDPROC)filelist_subclass_proc;
441 filelist_proc.old = (WNDPROC)GetWindowLong (fl, GWL_WNDPROC);
442 if (filelist_proc.old) {
443 if (!SetWindowLong (fl, GWL_WNDPROC, (LONG)filelist_proc.current)) {
444 msg_box (dlg, _("Could not set filelist window procedure."), _("Key Manager"), MB_ERR);
445 BUG (NULL);
446 }
447 }
448 SetMenu (dlg, menu);
449 fm_build (&lv, GetDlgItem (dlg, IDC_FILE_LIST));
450 center_window2 (dlg, NULL, HWND_TOPMOST);
451 center_window (dlg, NULL);
452 SetForegroundWindow (dlg);
453 statbar = setup_status_bar (dlg);
454 filelist_proc.opaque = (void*)statbar;
455 return TRUE;
456
457 case WM_DESTROY:
458 if (lv) {
459 fm_delete (lv);
460 lv = NULL;
461 }
462 if (menu) {
463 DestroyMenu (menu);
464 menu = NULL;
465 }
466 return FALSE;
467
468 case WM_DROPFILES:
469 fm_add_dropped_files (lv, (HDROP)wparam);
470 return TRUE;
471
472 case WM_NOTIFY:
473 NMHDR *notify;
474 int pos;
475 HMENU hm;
476
477 notify = (NMHDR *)lparam;
478 if (notify && notify->code == NM_CLICK &&
479 notify->idFrom == IDC_FILE_LIST)
480 update_status_bar (statbar, lv);
481 if (notify && notify->code == NM_RCLICK
482 && notify->idFrom == IDC_FILE_LIST) {
483 POINT p;
484 HMENU popup;
485
486 GetCursorPos (&p);
487 hm = LoadMenu (glob_hinst, MAKEINTRESOURCE (IDR_WINPT_FILEMISC_CTX));
488 popup = GetSubMenu (hm, 0);
489 set_menu_text (popup, ID_FILECTX_ENCRYPT, _("Encrypt"));
490 set_menu_text (popup, ID_FILECTX_DECRYPT, _("Decrypt"));
491 set_menu_text (popup, ID_FILECTX_SIGN, _("Sign"));
492 set_menu_text (popup, ID_FILECTX_SIGNENC, _("Sign && Encrypt"));
493 set_menu_text (popup, ID_FILECTX_VERIFY, _("Verify"));
494 set_menu_text (popup, ID_FILECTX_WIPE, _("Wipe"));
495 set_menu_text (popup, ID_FILECTX_SEND, _("Send as Mail"));
496 pos = listview_get_curr_pos (lv);
497 if (fm_check_file_type (lv, pos, FM_DECRYPT))
498 set_menu_state (popup, ID_FILECTX_SEND, MF_ENABLED);
499 if (fm_check_file_type (lv, pos, FM_ENCRYPT)) {
500 set_menu_state (popup, ID_FILECTX_DECRYPT, MF_GRAYED|MF_DISABLED);
501 set_menu_state (popup, ID_FILECTX_VERIFY, MF_GRAYED|MF_DISABLED);
502 }
503 if (fm_check_file_type (lv, pos, FM_DECRYPT)) {
504 set_menu_state (popup, ID_FILECTX_ENCRYPT, MF_GRAYED|MF_DISABLED);
505 set_menu_state (popup, ID_FILECTX_SIGN, MF_GRAYED|MF_DISABLED);
506 set_menu_state (popup, ID_FILECTX_SIGNENC, MF_GRAYED|MF_DISABLED);
507 }
508 if (fm_check_file_type (lv, pos, FM_VERIFY)) {
509 set_menu_state (popup, ID_FILECTX_VERIFY, MF_ENABLED);
510 set_menu_state (popup, ID_FILECTX_SIGN, MF_GRAYED|MF_DISABLED);
511 set_menu_state (popup, ID_FILECTX_SIGNENC, MF_GRAYED|MF_DISABLED);
512 }
513
514 TrackPopupMenu(popup, TPM_RIGHTALIGN, p.x, p.y, 0, dlg, NULL);
515 DestroyMenu (popup);
516 DestroyMenu (hm);
517 }
518 if (notify && notify->code == NM_CLICK
519 && notify->idFrom == IDC_FILE_LIST) {
520 hm = GetMenu (dlg);
521 pos = listview_get_curr_pos (lv);
522 if (!fm_check_file_type (lv, pos, FM_DECRYPT))
523 set_menu_state (hm, ID_FILEMISC_SEND, MF_GRAYED|MF_DISABLED);
524 else
525 set_menu_state (hm, ID_FILEMISC_SEND, MF_ENABLED);
526 }
527 return TRUE;
528
529 case WM_SYSCOMMAND:
530 if( LOWORD( wparam ) == SC_CLOSE )
531 EndDialog( dlg, TRUE );
532 return FALSE;
533
534 case WM_INITMENUPOPUP:
535 if ((UINT)LOWORD (lparam) == 0) {
536 HMENU hm = (HMENU)wparam;
537 set_menu_text_bypos (hm, 2, _("&Calc Digest"));
538 }
539 return FALSE;
540
541 case WM_COMMAND:
542 switch( LOWORD( wparam ) ) {
543 case ID_FILEMISC_QUIT:
544 EndDialog (dlg, TRUE);
545 return TRUE;
546
547 case ID_FILEMISC_WIPE_FREES:
548 DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_SPACE_SECDEL, dlg,
549 space_wipefrees_dlg_proc, NULL);
550 break;
551
552 case ID_FILEMISC_SELALL:
553 listview_select_all (lv);
554 break;
555
556 case ID_FILEMISC_PASTE:
557 fm_verify_pasted_detsig (lv, dlg);
558 break;
559
560 case ID_FILEMISC_ONTOP:
561 always_ontop ^= 1;
562 set_menu_state (menu, ID_FILEMISC_ONTOP,
563 always_ontop == 0? MFS_UNCHECKED : MFS_CHECKED);
564 center_window2 (dlg, NULL, always_ontop == 0? HWND_NOTOPMOST : HWND_TOPMOST);
565 break;
566
567 case ID_FILEMISC_SEND:
568 fm_send_file (lv);
569 break;
570
571 case ID_FILEMISC_PREFS:
572 DialogBoxParam (glob_hinst, (LPCTSTR)IDD_FILE_PREFS, dlg,
573 file_preferences_dlg_proc, NULL);
574 break;
575
576 case ID_FILEMISC_LIST:
577 case ID_FILEMISC_ENCRYPT:
578 case ID_FILEMISC_SYMENC:
579 case ID_FILEMISC_DECRYPT:
580 case ID_FILEMISC_SIGN:
581 case ID_FILEMISC_SIGNENC:
582 case ID_FILEMISC_VERIFY:
583 case ID_FILEMISC_WIPE:
584 fm_parse_files (lv, dlg, LOWORD (wparam));
585 SetForegroundWindow (dlg);
586 return TRUE;
587
588 case ID_FILEMISC_MD_MD5:
589 case ID_FILEMISC_MD_SHA1:
590 case ID_FILEMISC_MD_RMD160:
591 case ID_FILEMISC_MD_SHA256:
592 int algo;
593
594 switch (LOWORD (wparam)) {
595 case ID_FILEMISC_MD_MD5: algo = GPGME_MD_MD5; break;
596 case ID_FILEMISC_MD_SHA1: algo = GPGME_MD_SHA1; break;
597 case ID_FILEMISC_MD_RMD160: algo = GPGME_MD_RMD160; break;
598 case ID_FILEMISC_MD_SHA256:algo = GPGME_MD_SHA256; break;
599 }
600 fm_print_md (lv, dlg, algo);
601 SetForegroundWindow (dlg);
602 return TRUE;
603
604 case ID_FILEMISC_CLEAR:
605 listview_del_all( lv );
606 return TRUE;
607
608 case ID_FILEMISC_OPEN:
609 fm_add_opened_files( lv, dlg );
610 return TRUE;
611
612 /* context menu entries */
613 case ID_FILECTX_ENCRYPT: send_cmd_id( dlg, ID_FILEMISC_ENCRYPT); break;
614 case ID_FILECTX_DECRYPT: send_cmd_id( dlg, ID_FILEMISC_DECRYPT );break;
615 case ID_FILECTX_SIGN: send_cmd_id( dlg, ID_FILEMISC_SIGN ); break;
616 case ID_FILECTX_SIGNENC: send_cmd_id( dlg, ID_FILEMISC_SIGNENC );break;
617 case ID_FILECTX_VERIFY: send_cmd_id( dlg, ID_FILEMISC_VERIFY ); break;
618 case ID_FILECTX_WIPE: send_cmd_id( dlg, ID_FILEMISC_WIPE ); break;
619 case ID_FILECTX_LIST: send_cmd_id( dlg, ID_FILEMISC_LIST ); break;
620 case ID_FILECTX_SEND: send_cmd_id( dlg, ID_FILEMISC_SEND ); break;
621 }
622 break;
623 }
624
625 return FALSE;
626 } /* file_manager_dlg_proc */
627
628
629 BOOL CALLBACK
630 file_preferences_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
631 {
632 switch (msg) {
633 case WM_INITDIALOG:
634 CheckDlgButton (dlg, IDC_FPREFS_PROGRESS, reg_prefs.fm.progress? BST_CHECKED : BST_UNCHECKED);
635 SetForegroundWindow (dlg);
636 center_window (dlg, NULL);
637 break;
638
639 case WM_COMMAND:
640 switch (LOWORD (wparam)) {
641 case IDOK:
642 reg_prefs.fm.progress = IsDlgButtonChecked (dlg, IDC_FPREFS_PROGRESS)? 1 : 0;
643 set_reg_winpt_prefs (&reg_prefs);
644 EndDialog (dlg, TRUE);
645 break;
646
647 case IDCANCEL:
648 EndDialog (dlg, FALSE);
649 break;
650 }
651 break;
652 }
653
654 return FALSE;
655 } /* file_preferences_dlg_proc */
656
657
658 static void
659 add_files_from_lv (HWND dlg, listview_ctrl_t lv)
660 {
661 char fname[384+1];
662 int i;
663
664 for (i = 0; i < listview_count_items (lv, 0); i++) {
665 if (!listview_get_item_state (lv, i))
666 continue;
667 listview_get_item_text (lv, i, 1, fname, sizeof (fname)-1);
668 SendDlgItemMessage (dlg, IDC_SECDEL_FILES, LB_ADDSTRING,
669 NULL, (WPARAM)(char *)fname);
670 }
671 }
672
673
674 /* Dialog box procedure to confirm that files shall be deleted. */
675 BOOL CALLBACK
676 file_secdel_confirm_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
677 {
678 static secdel_confirm_s * ctx;
679
680 switch (msg) {
681 case WM_INITDIALOG:
682 ctx = (struct secdel_confirm_s *)lparam;
683 if (!ctx)
684 BUG (NULL);
685 add_files_from_lv (dlg, ctx->lv_files);
686 SetWindowText (dlg, _("Are you sure you want to secure delete these files?"));
687 SetDlgItemText (dlg, IDYES, _("&Yes"));
688 SetDlgItemText (dlg, IDNO, _("&No"));
689 break;
690
691 case WM_COMMAND:
692 switch (LOWORD (wparam)) {
693 case IDYES:
694 ctx->yes = 1;
695 EndDialog (dlg, TRUE);
696 break;
697
698 case IDNO:
699 ctx->yes = 0;
700 EndDialog (dlg, FALSE);
701 break;
702 }
703 break;
704 }
705
706 return FALSE;
707 }
708
709
710 /* Wipe callback. @ctx is a window handle @off is the current offset
711 and @n is the total size. */
712 static void
713 wipe_cb (void *ctx, ui64 off, ui64 n)
714 {
715 SendDlgItemMessage ((HWND)ctx, IDC_SPACE_PROGRESS, PBM_SETPOS,
716 (WPARAM) (off*100/n), 0);
717 SetDlgItemInt ((HWND)ctx, IDC_SPACE_OFF, (UINT)(off/1024), FALSE);
718 SetDlgItemInt ((HWND)ctx, IDC_SPACE_N, (UINT)(n/1024), FALSE);
719 }
720
721
722 /* Call the wipe free space method asynchron. */
723 static DWORD WINAPI
724 wipe_thread (void *ctx)
725 {
726 thread_ctx_t a = (thread_ctx_t)ctx;
727 int rc;
728
729 rc = wipe_freespace (a->drive, &a->fd, wipe_cb, a->dlg);
730 SetDlgItemText (a->dlg, IDC_SPACE_INFO,
731 rc? _("Operation Status: Error") :
732 _("Operation Status: Done."));
733 if (rc)
734 msg_box (a->dlg, winpt_strerror (rc), _("Wipe Free Space"), MB_ERR);
735 else
736 MessageBeep (MB_OK);
737 ExitThread (0);
738 return 0;
739 }
740
741
742 static void
743 fill_drive_combobox (HWND dlg)
744 {
745 char buf[384], p[16];
746 int n, i, j = 0;
747
748 n = GetLogicalDriveStrings (DIM (buf)-1, buf);
749 while (j < n) {
750 for (i = 0; buf[j] != '\0'; i++, j++)
751 p[i] = buf[j];
752 p[i] = '\0';
753 j++;
754 if (GetDriveType (p) != DRIVE_CDROM)
755 SendDlgItemMessage (dlg, IDC_SPACE_DRIVES, CB_ADDSTRING,
756 0, (LPARAM)(const char *)p);
757 }
758 SendDlgItemMessage (dlg, IDC_SPACE_DRIVES, CB_SETCURSEL, 0, 0);
759 } /* fill_drive_combobox */
760
761
762 static void
763 update_disc_stats (HWND dlg)
764 {
765 ULARGE_INTEGER caller = {0}, total = {0}, free = {0};
766 char buf[128], drive[32], a_total[64] = {0}, a_free[64] = {0};
767 int idx;
768
769 idx = SendDlgItemMessage (dlg, IDC_SPACE_DRIVES, CB_GETCURSEL, 0, 0);
770 GetDlgItemText (dlg, IDC_SPACE_DRIVES, drive, DIM (drive)-1);
771 if (GetDiskFreeSpaceEx (drive, &caller, &total, &free)) {
772 _ui64toa (total.QuadPart/1024, a_total, 10);
773 _ui64toa (free.QuadPart/1024, a_free, 10);
774 }
775 _snprintf (buf, DIM (buf)-1, _("Total Capacity: %12sk\n"
776 "Free Space : %12sk"), a_total, a_free);
777 SetDlgItemText(dlg, IDC_SPACE_DISC_INFO, buf);
778 SetDlgItemInt (dlg, IDC_SPACE_OFF, 0, FALSE);
779 SetDlgItemInt (dlg, IDC_SPACE_N, 0, FALSE);
780 } /* update_disc_stats */
781
782
783 BOOL CALLBACK
784 space_wipefrees_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
785 {
786 static HANDLE thread_hd = NULL;
787 static thread_ctx_s ctx;
788 char drive[32], * p;
789 int idx;
790 DWORD tid;
791
792 switch (msg) {
793 case WM_INITDIALOG:
794 fill_drive_combobox (dlg);
795 update_disc_stats (dlg);
796 center_window (dlg, NULL);
797 SetForegroundWindow (dlg);
798 break;
799
800 case WM_DESTROY:
801 thread_hd = NULL;
802 free_if_alloc (ctx.drive);
803 memset (&ctx, 0, sizeof ctx);
804 break;
805
806 case WM_COMMAND:
807 if (HIWORD (wparam) == CBN_SELCHANGE)
808 update_disc_stats (dlg);
809 switch (LOWORD (wparam)) {
810 case IDOK:
811 idx = SendDlgItemMessage (dlg, IDC_SPACE_DRIVES, CB_GETCURSEL, 0, 0);
812 if (idx != CB_ERR && !thread_hd) {
813 GetDlgItemText (dlg, IDC_SPACE_DRIVES, drive, DIM (drive)-1);
814 ctx.dlg = dlg;
815 ctx.drive = m_strdup (drive);
816 ctx.fd = NULL;
817 thread_hd = CreateThread (NULL, 0, wipe_thread, &ctx, 0, &tid);
818 }
819 if (WaitForSingleObject (thread_hd, 0) == WAIT_OBJECT_0) {
820 CloseHandle (thread_hd);
821 thread_hd = NULL;
822 EndDialog (dlg, TRUE);
823 }
824 break;
825
826 case IDCANCEL:
827 if (thread_hd) {
828 WaitForSingleObject (thread_hd, 2000);
829 TerminateThread (thread_hd, 1);
830 CloseHandle (thread_hd);
831 CloseHandle (ctx.fd);
832 p = make_filename (ctx.drive, "temp_winpt.tmp", NULL);
833 if (p && !file_exist_check (p))
834 unlink (p);
835 free_if_alloc (p);
836 }
837 EndDialog( dlg, FALSE );
838 break;
839 }
840 break;
841 }
842
843 return FALSE;
844 } /* space_wipefrees_dlg_proc */
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26