trunk/MyGPGME/w32-clip.c

/* w32-clip.c - W32 API clipboard functions
 *      Copyright (C) 2001, 2002, 2003 Timo Schulz
 *
 * This file is part of MyGPGME.
 *
 * MyGPGME 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.
 *
 * MyGPGME 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 this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#include <windows.h>

#include "util.h"
#include "ops.h"
#include "context.h"


static char*
get_w32_clip_text( int *r_size )
{
    int rc, size;
    char *private_clip = NULL;
    char *clip = NULL;
    HANDLE cb;
    
    rc = OpenClipboard( NULL );
    if( !rc )
        return NULL;
    cb = GetClipboardData( CF_TEXT );
    if( !cb )
        goto leave;    
    private_clip = GlobalLock( cb );
    if( !private_clip )
        goto leave;
    size = strlen( private_clip );
    clip = malloc( size + 1 );
    if( !clip ) {
        GlobalUnlock( cb );
        goto leave;
    }
    memcpy( clip, private_clip, size );
    clip[size] = '\0';
    *r_size = size;
    GlobalUnlock( cb );
    
leave:
    CloseClipboard();
    return clip;
} /* get_w32_clip_text */


static void
set_w32_clip_text( const char *data, int size )
{
    int rc;
    HANDLE cb;
    char *private_data;
    
    rc = OpenClipboard( NULL );
    if( !rc )
        return;
    EmptyClipboard();
    cb = GlobalAlloc( GHND, size+1 );
    if( !cb )
        goto leave;
    private_data = GlobalLock( cb );
    if( !private_data )
        goto leave;
    memcpy( private_data, data, size );
    private_data[size] = '\0';
    SetClipboardData( CF_TEXT, cb );
    GlobalUnlock( cb );
    
leave:    
    CloseClipboard( );
    GlobalFree( cb );
} /* set_w32_clip_text */


gpgme_error_t
gpgme_data_new_from_clipboard (gpgme_data_t *r_dh)
{
    gpgme_error_t err = 0;
    gpgme_data_t dh;
    char *clip_text;
    int size;

    if (!r_dh)
        return mk_error (Invalid_Value);
    *r_dh = NULL;
    clip_text = get_w32_clip_text (&size);
    if (!clip_text)
        return mk_error (No_Data);
    err = gpgme_data_new_from_mem (&dh, clip_text, size, 1);
    safe_free (clip_text);
    *r_dh = dh;
    return err;
} /* gpgme_data_new_from_clipboard */


void
gpgme_data_release_and_set_clipboard (gpgme_data_t dh)
{       
    char *clip_text;
    int size = 0;
    
    if (!dh)
        return;
    clip_text = _gpgme_data_get_as_string (dh);
    if (clip_text && (size = strlen (clip_text)) > 0) {
        set_w32_clip_text (clip_text, size);
        safe_free (clip_text);
    }
    gpgme_data_release (dh);
} /* gpgme_data_release_and_set_clipboard */


gpgme_error_t
gpgme_data_fix_clipboard( gpgme_data_t dh )
{
    const char *packets[] = {   
        "-----BEGIN PGP MESSAGE-----"       
        "-----BEGIN PGP PRIVATE KEY-----",
        "-----BEGIN PGP PUBLIC KEY-----",
        "-----BEGIN PGP SIGNED MESSAGE-----"
    };
    const char *headers[] = {
        "Comment"
        "Hash",
        "Version"
    };
    char *p;
    int idx;

    p = _gpgme_data_get_as_string( dh );
    if( p == NULL )
        return mk_error( Invalid_Value );
    for( idx = 0; idx < 4; idx++ ) {
        if( strstr( p, packets[idx] ) )
            break;
    }
    safe_free( p );

    return 1;
} /* gpgme_data_fix_clipboard */
1	twoaday	2	/* w32-clip.c - W32 API clipboard functions
2			* Copyright (C) 2001, 2002, 2003 Timo Schulz
3			*
4			* This file is part of MyGPGME.
5			*
6			* MyGPGME 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			* MyGPGME 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 this program; if not, write to the Free Software
18			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19			*/
20
21			#include <windows.h>
22
23			#include "util.h"
24			#include "ops.h"
25			#include "context.h"
26
27
28			static char*
29			get_w32_clip_text( int *r_size )
30			{
31			int rc, size;
32			char *private_clip = NULL;
33			char *clip = NULL;
34			HANDLE cb;
35
36			rc = OpenClipboard( NULL );
37			if( !rc )
38			return NULL;
39			cb = GetClipboardData( CF_TEXT );
40			if( !cb )
41			goto leave;
42			private_clip = GlobalLock( cb );
43			if( !private_clip )
44			goto leave;
45			size = strlen( private_clip );
46			clip = malloc( size + 1 );
47			if( !clip ) {
48			GlobalUnlock( cb );
49			goto leave;
50			}
51			memcpy( clip, private_clip, size );
52			clip[size] = '\0';
53			*r_size = size;
54			GlobalUnlock( cb );
55
56			leave:
57			CloseClipboard();
58			return clip;
59			} /* get_w32_clip_text */
60
61
62			static void
63			set_w32_clip_text( const char *data, int size )
64			{
65			int rc;
66			HANDLE cb;
67			char *private_data;
68
69			rc = OpenClipboard( NULL );
70			if( !rc )
71			return;
72			EmptyClipboard();
73			cb = GlobalAlloc( GHND, size+1 );
74			if( !cb )
75			goto leave;
76			private_data = GlobalLock( cb );
77			if( !private_data )
78			goto leave;
79			memcpy( private_data, data, size );
80			private_data[size] = '\0';
81			SetClipboardData( CF_TEXT, cb );
82			GlobalUnlock( cb );
83
84			leave:
85			CloseClipboard( );
86			GlobalFree( cb );
87			} /* set_w32_clip_text */
88
89
90			gpgme_error_t
91			gpgme_data_new_from_clipboard (gpgme_data_t *r_dh)
92			{
93			gpgme_error_t err = 0;
94			gpgme_data_t dh;
95			char *clip_text;
96			int size;
97
98			if (!r_dh)
99			return mk_error (Invalid_Value);
100			*r_dh = NULL;
101			clip_text = get_w32_clip_text (&size);
102			if (!clip_text)
103			return mk_error (No_Data);
104			err = gpgme_data_new_from_mem (&dh, clip_text, size, 1);
105			safe_free (clip_text);
106			*r_dh = dh;
107			return err;
108			} /* gpgme_data_new_from_clipboard */
109
110
111			void
112			gpgme_data_release_and_set_clipboard (gpgme_data_t dh)
113			{
114			char *clip_text;
115			int size = 0;
116
117			if (!dh)
118			return;
119			clip_text = _gpgme_data_get_as_string (dh);
120	twoaday	17	if (clip_text && (size = strlen (clip_text)) > 0) {
121	twoaday	2	set_w32_clip_text (clip_text, size);
122			safe_free (clip_text);
123			}
124			gpgme_data_release (dh);
125			} /* gpgme_data_release_and_set_clipboard */
126
127
128			gpgme_error_t
129			gpgme_data_fix_clipboard( gpgme_data_t dh )
130			{
131			const char *packets[] = {
132			"-----BEGIN PGP MESSAGE-----"
133			"-----BEGIN PGP PRIVATE KEY-----",
134			"-----BEGIN PGP PUBLIC KEY-----",
135			"-----BEGIN PGP SIGNED MESSAGE-----"
136			};
137			const char *headers[] = {
138			"Comment"
139			"Hash",
140			"Version"
141			};
142			char *p;
143			int idx;
144
145			p = _gpgme_data_get_as_string( dh );
146			if( p == NULL )
147			return mk_error( Invalid_Value );
148			for( idx = 0; idx < 4; idx++ ) {
149			if( strstr( p, packets[idx] ) )
150			break;
151			}
152			safe_free( p );
153
154			return 1;
155			} /* gpgme_data_fix_clipboard */