trunk/Src/wptCommonDlg.cpp

/* wptCommonDlg.cpp
 *      Copyright (C) 2004, 2005, 2006 Timo Schulz
 *
 * This file is part of WinPT.
 *
 * WinPT is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * WinPT is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with WinPT; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <windows.h>
#include <ctype.h>

#include "resource.h"
#include "wptTypes.h"
#include "wptW32API.h"
#include "wptVersion.h"
#include "wptGPG.h"
#include "wptCommonCtl.h"
#include "wptContext.h"
#include "wptRegistry.h"


/* check if the given buf contains a valid URL.
   for the moment we hardcode HTTP urls. */
static int
check_URL (const char *buf)
{
    size_t i;
    const char *allowed = "-./#_:~&?=";

    if (strncmp (buf, "http", 4))
        return -1;
    if (!strchr (buf, ':'))
        return -1;
    if (!strstr (buf, "//"))
        return -1;
    if (strstr (buf, " "))
        return -1;
    buf += 7;
    for (i=0; i < strlen (buf); i++) {
        if (isalpha (buf[i]) || isdigit (buf[i]))
            continue;
        if (!strchr (allowed, buf[i]))
            return -1;
    }

    return 0;
}


static BOOL CALLBACK
http_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static struct URL_ctx_s * ctx;
    int n;

    switch (msg) {
    case WM_INITDIALOG:
        ctx = (struct URL_ctx_s*)lparam;
        if (!ctx)
            BUG (0);
        if (ctx->desc != NULL)
            SetWindowText (dlg, ctx->desc);
        if (ctx->title != NULL)
            SetDlgItemText (dlg, IDC_HTTP_TITLE, ctx->title);
        SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
        SetForegroundWindow (dlg);
        break;

    case WM_COMMAND:
        switch (LOWORD (wparam)) {
        case IDOK:
            n = GetDlgItemText (dlg, IDC_HTTP_URL, ctx->url, DIM (ctx->url)-1);
            if (ctx->check && (!n || check_URL (ctx->url))) {
                msg_box (dlg, _("Please enter a valid URL."), "HTTP", MB_ERR);
                return FALSE;
            }
            ctx->cancel = 0;
            EndDialog (dlg, TRUE);
            break;

        case IDCANCEL:
            ctx->cancel = 1;
            EndDialog (dlg, FALSE);
            break;
        }
    }

    return FALSE;
}


/* Common dialog to request a URL from the user. 
   Return value is the URL context. */
void*
get_http_file_dlg (HWND root)
{
    struct URL_ctx_s *ctx;

    ctx = new URL_ctx_s;
    if (!ctx)
        BUG (0);
    memset (ctx, 0, sizeof *ctx);
    ctx->check = 1;
    ctx->desc = _("HTTP Key Import");
    ctx->title = _("Enter URL to retrieve the public key");
    DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_HTTP, root,
                    http_dlg_proc, (LPARAM)ctx);
    return ctx;
}

/* Wrapper to request a preferred keyserver from the user.
   Return value is the URL context. */
void*
get_keyserver_URL_dlg (HWND root)
{
    struct URL_ctx_s *ctx;

    ctx = new URL_ctx_s;
    if (!ctx)
        BUG (0);
    memset (ctx, 0, sizeof *ctx);
    ctx->check = 1;
    ctx->desc = _("Key Edit");
    ctx->title = _("Enter preferred keyserver URL"); 
    DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_HTTP, root,
                    http_dlg_proc, (LPARAM)ctx);
    return ctx;
}


/* Generic text input dialog. */
char*
get_input_dialog (HWND root, const char *title, const char *desc)
{
    struct URL_ctx_s ctx;

    memset (&ctx, 0, sizeof (ctx));
    ctx.title = title;
    ctx.desc = desc;
    DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_HTTP, root,
                    http_dlg_proc, (LPARAM)&ctx);
    if (ctx.cancel || strlen (ctx.url) == 0)
        return NULL;
    return m_strdup (ctx.url);
}


/* Initialize the language list based on the .mo files
   found in the dirctory @modpath. */
static int
nls_load_langlist (HWND dlg, const char *modpath)
{
    WIN32_FIND_DATA fnd;
    HWND cb;
    HANDLE hd;
    char *pattern = NULL;    
    int i;

    cb = GetDlgItem (dlg, IDC_LANGUAGE_LIST);
    combox_add_string (cb, lang_list[0].name);
    SendMessage (cb, CB_SETCURSEL, 0, 0);
    
    memset (&fnd, 0, sizeof (fnd));
    pattern = make_filename (modpath, "*.mo", NULL);
    hd = FindFirstFile (pattern, &fnd);
    if (hd == INVALID_HANDLE_VALUE) {
        free_if_alloc (pattern);
        return -1;
    }

    do {
        for (i=0; lang_list[i].id != NULL; i++) {
            if (!strnicmp (fnd.cFileName, lang_list[i].id, 2))
                combox_add_string (cb, lang_list[i].name);
        }
        memset (&fnd, 0, sizeof (fnd));
    } while (FindNextFile (hd, &fnd) != FALSE);
    FindClose (hd);
    free_if_alloc (pattern);
    return 0;
}


/* Set the default language for the program.
   The $lang.mo file is copied either to the selected
   folder or the directory specified by @modpath.
   The output name of the file is winpt.mo (example: de.mo -> winpt.mo). */
static int
nls_set_language (HWND dlg, const char *modpath)
{
    HWND cb = GetDlgItem (dlg, IDC_LANGUAGE_LIST);
    int pos = SendMessage (cb, CB_GETCURSEL, 0, 0);
    const char *folder;
    char *src, *dst;

    /* default langauge is English. */
    if (pos == 0 || pos == CB_ERR)
        return 0;

    folder = get_folder_dlg (dlg, _("Choose Locale Directory"), modpath);
    if (!folder)
        return 0;

    src = make_filename (modpath, lang_list[pos].id, "mo");
    dst = make_filename (folder, "winpt", "mo");

    if (!CopyFile (src, dst, FALSE)) {
        msg_box (dlg, _("Could not create winpt.mo file"), 
                 _("WinPT Error"), MB_ERR);
        pos = -1;
    }
    else
        set_reg_entry_mo (folder);
    free_if_alloc (src);
    free_if_alloc (dst);
    return pos;
}


static BOOL CALLBACK
nls_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
{
    static char modpath[MAX_PATH+1];
    int langid = 0, n;

    switch (msg) {
    case WM_INITDIALOG:
        if ((n=GetModuleFileName (NULL, modpath, MAX_PATH-1)) > 0) {
            while (n-- > 0) {
                if (modpath[n] == '\\') {
                    modpath[n] = 0;
                    break;
                }
            }
        }
        n = nls_load_langlist (dlg, modpath);
        if (n == -1)
            EndDialog (dlg, -1);
        SetWindowText (dlg, _("Native Language Support"));
        SetDlgItemText (dlg, IDC_LANGUAGE_INFO, _("Please select a language"));
        SetDlgItemText (dlg, IDOK, _("&OK"));
        SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
        center_window (dlg, NULL);
        SetForegroundWindow (dlg);
        break;

    case WM_COMMAND:
        switch (LOWORD (wparam)) {
        case IDOK:
            langid = nls_set_language (dlg, modpath);
            EndDialog (dlg, langid);
            break;

        case IDCANCEL:
            EndDialog (dlg, -1);
            break;
        }
        break;
    }

    return FALSE;
}


int
select_language (void)
{
    DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_LANGUAGE, GetDesktopWindow (),
                    nls_dlg_proc, 0);
    return 0;
}

1	werner	36	/* wptCommonDlg.cpp
2	twoaday	181	* Copyright (C) 2004, 2005, 2006 Timo Schulz
3	werner	36	*
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			#ifdef HAVE_CONFIG_H
21			#include <config.h>
22			#endif
23	twoaday	262
24			#include <windows.h>
25	twoaday	211	#include <ctype.h>
26	werner	36
27	werner	47	#include "resource.h"
28	werner	36	#include "wptTypes.h"
29			#include "wptW32API.h"
30			#include "wptVersion.h"
31			#include "wptGPG.h"
32			#include "wptCommonCtl.h"
33			#include "wptContext.h"
34	twoaday	193	#include "wptRegistry.h"
35	werner	36
36
37	twoaday	262	/* check if the given buf contains a valid URL.
38			for the moment we hardcode HTTP urls. */
39	werner	36	static int
40			check_URL (const char *buf)
41			{
42	twoaday	181	size_t i;
43	twoaday	211	const char *allowed = "-./#_:~&?=";
44	twoaday	181
45	twoaday	262	if (strncmp (buf, "http", 4))
46			return -1;
47	werner	36	if (!strchr (buf, ':'))
48			return -1;
49			if (!strstr (buf, "//"))
50			return -1;
51	twoaday	181	if (strstr (buf, " "))
52			return -1;
53			buf += 7;
54			for (i=0; i < strlen (buf); i++) {
55			if (isalpha (buf[i]) \|\| isdigit (buf[i]))
56			continue;
57			if (!strchr (allowed, buf[i]))
58			return -1;
59			}
60
61	werner	36	return 0;
62			}
63
64
65			static BOOL CALLBACK
66			http_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
67			{
68			static struct URL_ctx_s * ctx;
69			int n;
70
71			switch (msg) {
72			case WM_INITDIALOG:
73			ctx = (struct URL_ctx_s*)lparam;
74			if (!ctx)
75			BUG (0);
76			if (ctx->desc != NULL)
77			SetWindowText (dlg, ctx->desc);
78			if (ctx->title != NULL)
79			SetDlgItemText (dlg, IDC_HTTP_TITLE, ctx->title);
80	twoaday	123	SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
81	werner	36	SetForegroundWindow (dlg);
82			break;
83
84			case WM_COMMAND:
85			switch (LOWORD (wparam)) {
86			case IDOK:
87			n = GetDlgItemText (dlg, IDC_HTTP_URL, ctx->url, DIM (ctx->url)-1);
88			if (ctx->check && (!n \|\| check_URL (ctx->url))) {
89			msg_box (dlg, _("Please enter a valid URL."), "HTTP", MB_ERR);
90			return FALSE;
91			}
92			ctx->cancel = 0;
93			EndDialog (dlg, TRUE);
94			break;
95
96			case IDCANCEL:
97			ctx->cancel = 1;
98			EndDialog (dlg, FALSE);
99			break;
100			}
101			}
102
103			return FALSE;
104			}
105
106
107			/* Common dialog to request a URL from the user.
108			Return value is the URL context. */
109			void*
110			get_http_file_dlg (HWND root)
111			{
112			struct URL_ctx_s *ctx;
113
114			ctx = new URL_ctx_s;
115			if (!ctx)
116			BUG (0);
117			memset (ctx, 0, sizeof *ctx);
118	twoaday	181	ctx->check = 1;
119			ctx->desc = _("HTTP Key Import");
120			ctx->title = _("Enter URL to retrieve the public key");
121	werner	36	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_HTTP, root,
122			http_dlg_proc, (LPARAM)ctx);
123			return ctx;
124			}
125
126			/* Wrapper to request a preferred keyserver from the user.
127			Return value is the URL context. */
128			void*
129			get_keyserver_URL_dlg (HWND root)
130			{
131			struct URL_ctx_s *ctx;
132
133			ctx = new URL_ctx_s;
134			if (!ctx)
135			BUG (0);
136			memset (ctx, 0, sizeof *ctx);
137			ctx->check = 1;
138			ctx->desc = _("Key Edit");
139			ctx->title = _("Enter preferred keyserver URL");
140			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_HTTP, root,
141			http_dlg_proc, (LPARAM)ctx);
142			return ctx;
143			}
144
145
146			/* Generic text input dialog. */
147			char*
148			get_input_dialog (HWND root, const char title, const char desc)
149			{
150			struct URL_ctx_s ctx;
151
152			memset (&ctx, 0, sizeof (ctx));
153			ctx.title = title;
154			ctx.desc = desc;
155			DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_HTTP, root,
156			http_dlg_proc, (LPARAM)&ctx);
157			if (ctx.cancel \|\| strlen (ctx.url) == 0)
158			return NULL;
159			return m_strdup (ctx.url);
160			}
161	twoaday	150
162
163	twoaday	193	/* Initialize the language list based on the .mo files
164			found in the dirctory @modpath. */
165			static int
166			nls_load_langlist (HWND dlg, const char *modpath)
167			{
168			WIN32_FIND_DATA fnd;
169			HWND cb;
170			HANDLE hd;
171			char *pattern = NULL;
172			int i;
173
174			cb = GetDlgItem (dlg, IDC_LANGUAGE_LIST);
175			combox_add_string (cb, lang_list[0].name);
176			SendMessage (cb, CB_SETCURSEL, 0, 0);
177
178			memset (&fnd, 0, sizeof (fnd));
179			pattern = make_filename (modpath, "*.mo", NULL);
180			hd = FindFirstFile (pattern, &fnd);
181			if (hd == INVALID_HANDLE_VALUE) {
182			free_if_alloc (pattern);
183			return -1;
184			}
185
186			do {
187			for (i=0; lang_list[i].id != NULL; i++) {
188			if (!strnicmp (fnd.cFileName, lang_list[i].id, 2))
189			combox_add_string (cb, lang_list[i].name);
190			}
191			memset (&fnd, 0, sizeof (fnd));
192			} while (FindNextFile (hd, &fnd) != FALSE);
193			FindClose (hd);
194			free_if_alloc (pattern);
195			return 0;
196			}
197
198
199			/* Set the default language for the program.
200			The $lang.mo file is copied either to the selected
201			folder or the directory specified by @modpath.
202			The output name of the file is winpt.mo (example: de.mo -> winpt.mo). */
203			static int
204			nls_set_language (HWND dlg, const char *modpath)
205			{
206			HWND cb = GetDlgItem (dlg, IDC_LANGUAGE_LIST);
207			int pos = SendMessage (cb, CB_GETCURSEL, 0, 0);
208			const char *folder;
209			char src, dst;
210
211			/* default langauge is English. */
212			if (pos == 0 \|\| pos == CB_ERR)
213			return 0;
214
215			folder = get_folder_dlg (dlg, _("Choose Locale Directory"), modpath);
216			if (!folder)
217			return 0;
218
219			src = make_filename (modpath, lang_list[pos].id, "mo");
220			dst = make_filename (folder, "winpt", "mo");
221
222			if (!CopyFile (src, dst, FALSE)) {
223			msg_box (dlg, _("Could not create winpt.mo file"),
224			_("WinPT Error"), MB_ERR);
225			pos = -1;
226			}
227			else
228			set_reg_entry_mo (folder);
229			free_if_alloc (src);
230			free_if_alloc (dst);
231			return pos;
232			}
233
234
235	twoaday	150	static BOOL CALLBACK
236	twoaday	193	nls_dlg_proc (HWND dlg, UINT msg, WPARAM wparam, LPARAM lparam)
237	twoaday	150	{
238	twoaday	193	static char modpath[MAX_PATH+1];
239			int langid = 0, n;
240	twoaday	150
241			switch (msg) {
242			case WM_INITDIALOG:
243	twoaday	193	if ((n=GetModuleFileName (NULL, modpath, MAX_PATH-1)) > 0) {
244			while (n-- > 0) {
245			if (modpath[n] == '\\') {
246			modpath[n] = 0;
247			break;
248			}
249			}
250	twoaday	150	}
251	twoaday	193	n = nls_load_langlist (dlg, modpath);
252			if (n == -1)
253			EndDialog (dlg, -1);
254			SetWindowText (dlg, _("Native Language Support"));
255			SetDlgItemText (dlg, IDC_LANGUAGE_INFO, _("Please select a language"));
256			SetDlgItemText (dlg, IDOK, _("&OK"));
257			SetDlgItemText (dlg, IDCANCEL, _("&Cancel"));
258			center_window (dlg, NULL);
259	twoaday	150	SetForegroundWindow (dlg);
260	twoaday	193	break;
261	twoaday	150
262			case WM_COMMAND:
263			switch (LOWORD (wparam)) {
264			case IDOK:
265	twoaday	193	langid = nls_set_language (dlg, modpath);
266			EndDialog (dlg, langid);
267	twoaday	150	break;
268
269			case IDCANCEL:
270	twoaday	193	EndDialog (dlg, -1);
271	twoaday	150	break;
272			}
273			break;
274			}
275	twoaday	193
276	twoaday	150	return FALSE;
277			}
278
279
280			int
281	twoaday	193	select_language (void)
282	twoaday	150	{
283	twoaday	193	DialogBoxParam (glob_hinst, (LPCTSTR)IDD_WINPT_LANGUAGE, GetDesktopWindow (),
284			nls_dlg_proc, 0);
285			return 0;
286	twoaday	150	}
287