trunk/src/OEMisc.c

/* OEMisc.c - OE misc functions
 *       Copyright (C) 2006 Timo Schulz
 *
 * This file is part of GPGOE.
 *
 * GPGOE is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
 * (at your option) any later version.
 * 
 * GPGOE 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 Lesser General Public License
 * along with GPGOE; 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 <stdio.h>
#include <stdarg.h>
#include <stdlib.h>

#include "gpgme.h"
#include "GPGOE.h"


/* Convert the UTF8 string @string into the native charset. */
char*
utf8_to_native (const char *string)
{
    wchar_t *result;
    char *native;    
    int n;

    n = MultiByteToWideChar (CP_UTF8, 0, string, -1, NULL, 0);
    if (n < 0)
        return NULL;

    result = (wchar_t*)xcalloc (1, (n+1) * sizeof *result);

    n = MultiByteToWideChar (CP_UTF8, 0, string, -1, result, n);
    if (n < 0) {
        free (result);
        return NULL;
    }

    n = WideCharToMultiByte (GetACP (), 0, result, -1, NULL, 0, NULL, NULL);
    if (n < 0)
        return NULL;

    native = (char*)malloc (n+1);
    if (!native)
        abort ();

    n = WideCharToMultiByte (GetACP (), 0, result, -1, native, n, NULL, NULL);
    if (n < 0) {
        free (result);
        return NULL;
    }

    free (result);
    return native;
}


/* Return the clipboard contents as a string or NULL
   if the clipboard does not contain text. */
char*
get_clip_text (HWND hwnd)
{
    HANDLE clipmem;
    char *cliptxt, *p;  
    int len;
    
    if (OpenClipboard (hwnd) == FALSE)
        return NULL;
    clipmem = GetClipboardData (CF_TEXT);
    if (clipmem == NULL) {
        p = NULL;
        goto leave;
    }
    cliptxt = (char *) GlobalLock (clipmem);
    if (cliptxt == NULL) {
        p = NULL;
        goto leave;
    }
    
    len =  strlen (cliptxt);
    p = xcalloc (1, len+1);
    memcpy (p, cliptxt, len);
    p[len] = '\0';
    GlobalUnlock (clipmem);
    
leave:
    CloseClipboard ();
    return p;
}


/* Set @text as the new clipboard content. */
int
set_clip_text (HWND hwnd, const char *text, int nbytes)
{    
    HANDLE clipmem;
    int rc = 0;
    char *p;
    
    if (OpenClipboard (hwnd) == FALSE)  
        return -1;
    EmptyClipboard ();

    clipmem = GlobalAlloc (GHND, nbytes + 1);
    if (clipmem == NULL)
        abort ();
    p = (char *) GlobalLock (clipmem);
    if (p == NULL) {
        rc = -1;
        goto leave;     
    }
    memcpy (p, text, nbytes);
    p[nbytes] = '\0';
    
    GlobalUnlock (clipmem);
    SetClipboardData (CF_TEXT, clipmem);
    GlobalFree (clipmem);
    
leave:
    CloseClipboard ();
    return 0;
}


/* Safe wrapper for calloc. */
void*
xcalloc (size_t n, size_t m)
{
    void *p = calloc (n, m);
    if (!p)
        abort ();
    return p;
}


/* Safe wrapper for strdup. */
char*
xstrdup (const char *s)
{
    char *p = strdup (s);
    if (!p)
        abort ();
    return p;
}


/* printf style message box. */
void
show_error (HWND hwnd, const char *caption, UINT type, const char *fmt, ...)
{
    char buffer[1024];
    va_list ptr;

    va_start (ptr, fmt);
    _vsnprintf (buffer, sizeof (buffer)-1, fmt, ptr);
    va_end (ptr);
    MessageBox (hwnd, buffer, caption, type);
}
1	twoaday	1	/* OEMisc.c - OE misc functions
2			* Copyright (C) 2006 Timo Schulz
3			*
4			* This file is part of GPGOE.
5			*
6			* GPGOE is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU Lesser General Public License as published by
8			* the Free Software Foundation; either version 2.1 of the License, or
9			* (at your option) any later version.
10			*
11			* GPGOE 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 Lesser General Public License
17			* along with GPGOE; if not, write to the Free Software Foundation,
18			* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19			*/
20
21			#ifdef HAVE_CONFIG_H
22			#include <config.h>
23			#endif
24			#include <windows.h>
25			#include <stdio.h>
26			#include <stdarg.h>
27			#include <stdlib.h>
28
29			#include "gpgme.h"
30			#include "GPGOE.h"
31
32
33			/* Convert the UTF8 string @string into the native charset. */
34			char*
35			utf8_to_native (const char *string)
36			{
37			wchar_t *result;
38			char *native;
39			int n;
40
41			n = MultiByteToWideChar (CP_UTF8, 0, string, -1, NULL, 0);
42			if (n < 0)
43			return NULL;
44
45	twoaday	10	result = (wchar_t)xcalloc (1, (n+1) sizeof *result);
46	twoaday	1
47			n = MultiByteToWideChar (CP_UTF8, 0, string, -1, result, n);
48			if (n < 0) {
49			free (result);
50			return NULL;
51			}
52
53			n = WideCharToMultiByte (GetACP (), 0, result, -1, NULL, 0, NULL, NULL);
54			if (n < 0)
55			return NULL;
56
57			native = (char*)malloc (n+1);
58			if (!native)
59			abort ();
60
61			n = WideCharToMultiByte (GetACP (), 0, result, -1, native, n, NULL, NULL);
62			if (n < 0) {
63			free (result);
64			return NULL;
65			}
66
67			free (result);
68			return native;
69			}
70
71
72			/* Return the clipboard contents as a string or NULL
73			if the clipboard does not contain text. */
74			char*
75			get_clip_text (HWND hwnd)
76			{
77			HANDLE clipmem;
78			char cliptxt, p;
79			int len;
80
81			if (OpenClipboard (hwnd) == FALSE)
82			return NULL;
83			clipmem = GetClipboardData (CF_TEXT);
84			if (clipmem == NULL) {
85			p = NULL;
86			goto leave;
87			}
88			cliptxt = (char *) GlobalLock (clipmem);
89			if (cliptxt == NULL) {
90			p = NULL;
91			goto leave;
92			}
93
94			len = strlen (cliptxt);
95			p = xcalloc (1, len+1);
96			memcpy (p, cliptxt, len);
97			p[len] = '\0';
98			GlobalUnlock (clipmem);
99
100			leave:
101			CloseClipboard ();
102			return p;
103			}
104
105
106			/* Set @text as the new clipboard content. */
107			int
108			set_clip_text (HWND hwnd, const char *text, int nbytes)
109			{
110			HANDLE clipmem;
111			int rc = 0;
112			char *p;
113
114			if (OpenClipboard (hwnd) == FALSE)
115			return -1;
116			EmptyClipboard ();
117
118			clipmem = GlobalAlloc (GHND, nbytes + 1);
119			if (clipmem == NULL)
120			abort ();
121			p = (char *) GlobalLock (clipmem);
122			if (p == NULL) {
123			rc = -1;
124			goto leave;
125			}
126			memcpy (p, text, nbytes);
127			p[nbytes] = '\0';
128
129			GlobalUnlock (clipmem);
130			SetClipboardData (CF_TEXT, clipmem);
131			GlobalFree (clipmem);
132
133			leave:
134			CloseClipboard ();
135			return 0;
136			}
137
138
139			/* Safe wrapper for calloc. */
140			void*
141			xcalloc (size_t n, size_t m)
142			{
143			void *p = calloc (n, m);
144			if (!p)
145			abort ();
146			return p;
147			}
148
149
150			/* Safe wrapper for strdup. */
151			char*
152			xstrdup (const char *s)
153			{
154			char *p = strdup (s);
155			if (!p)
156			abort ();
157			return p;
158			}
159
160
161			/* printf style message box. */
162			void
163			show_error (HWND hwnd, const char caption, UINT type, const char fmt, ...)
164			{
165			char buffer[1024];
166			va_list ptr;
167
168			va_start (ptr, fmt);
169			_vsnprintf (buffer, sizeof (buffer)-1, fmt, ptr);
170			va_end (ptr);
171			MessageBox (hwnd, buffer, caption, type);
172			}