From 01309c8bd0a9ac4476952ec5063499ec980a7b12 Mon Sep 17 00:00:00 2001 From: erihel Date: Thu, 11 Apr 2013 13:37:15 +0200 Subject: * Added clipboard support (issue #60) * Fixed keyboard shortcuts while code editing in game --- lib/clipboard/CMakeLists.txt | 17 + lib/clipboard/COPYING.README | 72 ++++ lib/clipboard/include/clipboard/clipboard.h | 55 +++ lib/clipboard/include/clipboard/types.h | 100 +++++ lib/clipboard/include/clipboard/utf.h | 115 ++++++ lib/clipboard/include/clipboard/wzglobal.h | 614 ++++++++++++++++++++++++++++ lib/clipboard/readme.txt | 1 + lib/clipboard/src/clipboardWin32.c | 160 ++++++++ lib/clipboard/src/clipboardX11.c | 293 +++++++++++++ lib/clipboard/src/utf.c | 530 ++++++++++++++++++++++++ 10 files changed, 1957 insertions(+) create mode 100644 lib/clipboard/CMakeLists.txt create mode 100644 lib/clipboard/COPYING.README create mode 100644 lib/clipboard/include/clipboard/clipboard.h create mode 100644 lib/clipboard/include/clipboard/types.h create mode 100644 lib/clipboard/include/clipboard/utf.h create mode 100644 lib/clipboard/include/clipboard/wzglobal.h create mode 100644 lib/clipboard/readme.txt create mode 100644 lib/clipboard/src/clipboardWin32.c create mode 100644 lib/clipboard/src/clipboardX11.c create mode 100644 lib/clipboard/src/utf.c (limited to 'lib') diff --git a/lib/clipboard/CMakeLists.txt b/lib/clipboard/CMakeLists.txt new file mode 100644 index 0000000..4e83ce3 --- /dev/null +++ b/lib/clipboard/CMakeLists.txt @@ -0,0 +1,17 @@ +cmake_minimum_required(VERSION 2.8) + +include_directories(. include/clipboard) + +add_definitions(-DLIB_COMPILE=1) + + +if (${PLATFORM_WINDOWS}) + set(CLIPBOARD_SRC src/clipboardWin32.c) +elseif (${PLATFORM_LINUX}) + set(CLIPBOARD_SRC src/clipboardX11.c) +else() + set(CLIPBOARD_SRC src/clipboardX11.c) +endif() + +include_directories(${SDL_INCLUDE_DIR}) +add_library(clipboard STATIC src/utf.c ${CLIPBOARD_SRC}) diff --git a/lib/clipboard/COPYING.README b/lib/clipboard/COPYING.README new file mode 100644 index 0000000..2f8aad8 --- /dev/null +++ b/lib/clipboard/COPYING.README @@ -0,0 +1,72 @@ +Warzone 2100 Source & Data +-------------------------- + +This document replaces the file "readme.txt" as present in the Warzone 2100 GPL + release of December 6th 2004. + +1) These source and data files are provided as is with no guarantees: + - No assistance or support will be offered or given. + - Everything you will require to make a build of the game should be here. If + it isn't, you'll have to improvise. + - None of us here at Pivotal Games are in a position to be able to offer any + help with making this work. + +2) Everything included (source code and data), as well as the not included + videos and music, is released under the terms of the GNU General Public + License, version 2 or (at your option) any later version. + Please be sure to read the entirety of this license, but the summary is that + you're free to do what you want with the source subject to making the full + source code freely available in the event of the distribution of new + binaries. + +3) Following exception to the GPL is granted: + ------ + Linking Warzone 2100 statically or dynamically with other modules is making + a combined work based on Warzone 2100. Thus, the terms and conditions of + the GNU General Public License cover the whole combination. + + In addition, as a special exception, the copyright holders of Warzone 2100 + give you permission to combine Warzone 2100 with code included in the + standard release of libraries that are accessible, redistributable and + linkable free of charge. You may copy and distribute such a system + following the terms of the GNU GPL for Warzone 2100 and the licenses of the + other code concerned. + + Note that people who make modified versions of Warzone 2100 are not + obligated to grant this special exception for their modified versions; it + is their choice whether to do so. The GNU General Public License gives + permission to release a modified version without this exception; this + exception also makes it possible to release a modified version which + carries forward this exception. + ------ + +4) Permission is granted to use the name "Warzone 2100", the logos, stories, + texts and related materials. + +5) Permission is granted to copy and distribute unaltered copies and/or images + of the original game discs in any medium, provided that they are distributed + free of charge and retain their original copyright and trademark notices. + +Finally, the primary motivation for this release is for entertainment and + educational purposes. On the subject of the latter, don't be surprised to see + some pretty gnarly old-school C code in here; the game was a classic, but large + areas of the code aren't pretty; OO design and C++ evangelists beware! We + haven't spent any time cleaning the code or making it pretty - what you see is + what you're getting, warts n' all. + +Thank you to Jonathan Kemp of Eidos Europe for permitting the release. Thanks to + Martin Severn for allowing to use his soundtrack. Thanks to Jason Walker for + helping to facilitate the release of the movies and sound tracks, as well as + clarifying the meaning of this license. Thanks also to Frank Lamboy for + assistance with the release and for campaigning along with many many others + over the years for the source to be made available. +The correspondence, online petitions and persistence made this possible. We were + constantly amazed at the community support for Warzone even after all this + time; it's nice to be able to give something back, assuming you can get it to + compile... ;-) + +Original - 6th December 2004 +Alex M - ex Pumpkin Studios (Eidos) + +Amended - 10th June 2008 +Jason W - Eidos diff --git a/lib/clipboard/include/clipboard/clipboard.h b/lib/clipboard/include/clipboard/clipboard.h new file mode 100644 index 0000000..dcee2ea --- /dev/null +++ b/lib/clipboard/include/clipboard/clipboard.h @@ -0,0 +1,55 @@ +/* + This file is part of Warzone 2100. + Copyright (C) 2008 Freddie Witherden + Copyright (C) 2008-2009 Warzone Resurrection Project + + Warzone 2100 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. + + Warzone 2100 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 Warzone 2100; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#ifndef CLIPBOARD_H_ +#define CLIPBOARD_H_ + +#include + +#ifdef __cplusplus + extern "C" { +#endif + +/** + * Returns a copy of the text in the systems clipboard. Should the clipboard be + * empty, or populated with non-textual data NULL is returned. The character set + * of the returned is guaranteed to be UTF-8. + * + * It remains the responsibility of the caller to free() the string when + * finished with it. + * + * @return The textual contents of the clipboard (if any), otherwise NULL. + */ +char *widgetGetClipboardText(void); + +/** + * Attempts to set the contents of the systems clipboard to text. The character + * set of text must be UTF-8. + * + * @param text The UTF-8 text to set the clipboard to. + * @return True if the contents were successfully set, false otherwise. + */ +bool widgetSetClipboardText(const char *text); + +#ifdef __cplusplus +} +#endif + +#endif /*CLIPBOARD_H_*/ diff --git a/lib/clipboard/include/clipboard/types.h b/lib/clipboard/include/clipboard/types.h new file mode 100644 index 0000000..ff7ca68 --- /dev/null +++ b/lib/clipboard/include/clipboard/types.h @@ -0,0 +1,100 @@ +/* + This file is part of Warzone 2100. + Copyright (C) 1999-2004 Eidos Interactive + Copyright (C) 2005-2009 Warzone Resurrection Project + + Warzone 2100 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. + + Warzone 2100 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 Warzone 2100; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +/*! \file + * \brief Simple type definitions. + */ + +#ifndef __INCLUDED_LIB_FRAMEWORK_TYPES_H__ +#define __INCLUDED_LIB_FRAMEWORK_TYPES_H__ + +#include "wzglobal.h" + +#ifdef HAVE_INTTYPES_H // defined WZ_C99 +/* Compilers that have support for C99 have all values below defined in stdint.h */ +# include +#else +// Defines C99 types for C99 incompatible compilers (e.g. MSVC) +#include +#ifndef WZ_CC_MINGW +# define INT8_MIN (-128) +# define INT16_MIN (-32767-1) +# define INT32_MIN (-2147483647-1) +# define INT8_MAX (127) +# define INT16_MAX (32767) +# define INT32_MAX (2147483647) +# define UINT8_MAX (255) +# define UINT16_MAX (65535) +# define UINT32_MAX (4294967295U) +#endif +#ifdef WZ_CC_MSVC +# define PRIu32 "u" +# define PRIu64 "I64u" +typedef SSIZE_T ssize_t; +#endif +#endif // WZ_C99 + +#include +#include + +/* Basic numeric types */ +typedef uint8_t UBYTE; +typedef int8_t SBYTE; +typedef uint16_t UWORD; +typedef int16_t SWORD; +typedef uint32_t UDWORD; +typedef int32_t SDWORD; + +/* Numeric size defines */ +#define UBYTE_MAX UINT8_MAX +#define SBYTE_MIN INT8_MIN +#define SBYTE_MAX INT8_MAX +#define UWORD_MAX UINT16_MAX +#define SWORD_MIN INT16_MIN +#define SWORD_MAX INT16_MAX +#define UDWORD_MAX UINT32_MAX +#define SDWORD_MIN INT32_MIN +#define SDWORD_MAX INT32_MAX + +// If we are C99 compatible, the "bool" macro will be defined in (as _Bool) +// C++ comes with an integrated bool type +#if defined(WZ_CXX98) +#elif defined(WZ_C99) +# include +#else +// Pretend we are C99 compatible (well, for the bool type then) +# ifndef bool +# define bool BOOL +# endif +# ifndef true +# define true (1) +# endif +# ifndef false +# define false (0) +# endif +# ifndef __bool_true_false_are_defined +# define __bool_true_false_are_defined (1) +# endif +#endif /* WZ_C99 */ + +#if !defined(WZ_OS_WIN) +typedef int BOOL; +#endif // WZ_OS_WIN + +#endif // __INCLUDED_LIB_FRAMEWORK_TYPES_H__ diff --git a/lib/clipboard/include/clipboard/utf.h b/lib/clipboard/include/clipboard/utf.h new file mode 100644 index 0000000..eadc3b3 --- /dev/null +++ b/lib/clipboard/include/clipboard/utf.h @@ -0,0 +1,115 @@ +/* + This file is part of Warzone 2100. + Copyright (C) 2007 Giel van Schijndel + Copyright (C) 2007-2009 Warzone Resurrection Project + + Warzone 2100 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. + + Warzone 2100 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 Warzone 2100; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + $Revision: 9336 $ + $Id: utf.h 9336 2010-01-18 19:10:17Z cypr $ + $HeadURL: https://warzone2100.svn.sourceforge.net/svnroot/warzone2100/trunk/lib/framework/utf.h $ +*/ + +#ifndef __INCLUDE_LIB_FRAMEWORK_UTF8_H__ +#define __INCLUDE_LIB_FRAMEWORK_UTF8_H__ + +/* Allow frame header files to be singly included */ +#define FRAME_LIB_INCLUDE + +#include "types.h" + +#ifdef __cplusplus +extern "C" +{ +#endif //__cplusplus + +/** Used to store a UTF-32 character in + */ +typedef uint32_t utf_32_char; + +/** Used to store a UTF-16 character in (this is not necessarily a + * full Unicode codepoint) + */ +typedef uint16_t utf_16_char; + +/** Decodes a single Unicode character from the given UTF-16 string. + * + * \param utf16_char Points to a character string that should contain at + * least one valid UTF-16 character sequence. + * \param[out] next_char Will be modified to point to the first character + * following the UTF-16 character sequence. + * + * \return The Unicode character encoded as UTF-32 with native endianness. + */ +utf_32_char UTF16DecodeChar(const utf_16_char *utf16_char, const utf_16_char **next_char); + +/** Decodes a single Unicode character from the given UTF-8 string. + * + * \param utf8_char Points to a character string that should contain at + * least one valid UTF-8 character sequence. + * \param[out] next_char Will be modified to point to the first character + * following the UTF-8 character sequence. + * + * \return The Unicode character encoded as UTF-32 with native endianness. + */ +utf_32_char UTF8DecodeChar(const char *utf8_char, const char **next_char); + +/** Determines the amount of unicode codepoints in a UTF-8 encoded string + * \param utf8_string the UTF-8 encoded string to count + * \return the amount of codepoints found in the UTF-8 string + */ +size_t UTF8CharacterCount(const char *utf8_string); + +size_t UTF16CharacterCount(const uint16_t *utf16); + +/** Encodes a UTF-16 encoded unicode string to a UTF-8 encoded string + * \param unicode_string the UTF-16 encoded unicode string to encode into UTF-8 + * \param[out] nbytes the number of bytes allocated, may be NULL + * \return a UTF-8 encoded unicode nul terminated string (use free() to deallocate it) + */ +char *UTF16toUTF8(const utf_16_char *unicode_string, size_t *nbytes); + +/** Decodes a UTF-8 encoded string to a UTF-16 encoded string (native endianess) + * \param utf8_string a UTF-8 encoded nul terminated string + * \param[out] nbytes the number of bytes allocated, may be NULL + * \return a UTF-16 encoded unicode nul terminated string (use free() to deallocate it) + */ +utf_16_char *UTF8toUTF16(const char *utf8_string, size_t *nbytes); + +char *UTF8CharacterAtOffset(const char *utf8_string, size_t index); +utf_16_char *UTF16CharacterAtOffset(const utf_16_char *utf16_string, size_t index); + +/** Encodes a UTF-32 string to a UTF-8 encoded string + * \param unicode_string the UTF-32 string to encode into UTF-8 + * \param[out] nbytes the number of bytes allocated, may be NULL + * \return a UTF-8 encoded unicode nul terminated string (use free() to deallocate it) + */ +char *UTF32toUTF8(const utf_32_char *unicode_string, size_t *nbytes); + +/** Decodes a UTF-8 encoded string to a UTF-32 string + * \param utf8_string a UTF-8 encoded nul terminated string + * \param[out] nbytes the number of bytes allocated, may be NULL + * \return a UTF-32 nul terminated string (use free() to deallocate it) + */ +utf_32_char *UTF8toUTF32(const char *utf8_string, size_t *nbytes); + +/** Returns number of characters, not including terminating nul. */ +size_t utf32len(const utf_32_char *unicode_string); + +#ifdef __cplusplus +} +#endif //__cplusplus + +#endif // __INCLUDE_LIB_FRAMEWORK_UTF8_H__ diff --git a/lib/clipboard/include/clipboard/wzglobal.h b/lib/clipboard/include/clipboard/wzglobal.h new file mode 100644 index 0000000..113223e --- /dev/null +++ b/lib/clipboard/include/clipboard/wzglobal.h @@ -0,0 +1,614 @@ +/* + This file is part of Warzone 2100. + Copyright (C) 1992-2007 Trolltech ASA. + Copyright (C) 2005-2009 Warzone Resurrection Project + + Warzone 2100 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. + + Warzone 2100 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 Warzone 2100; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ +/*! \file wzglobal.h + * \brief Platform detection, workarounds and compat fixes + * + * OS and CC detection code shamelessly stolen from Qt4 (Qt/qglobal.h) by Dennis. + * This has been stripped down, feel free to add checks as you need them. + */ + +#ifndef WZGLOBAL_H +#define WZGLOBAL_H + +#ifndef __STDC_FORMAT_MACROS +#define __STDC_FORMAT_MACROS +#endif +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS +#endif + +#if defined(HAVE_CONFIG_H) +# undef _XOPEN_SOURCE +# include "config.h" +#elif defined(__MACOSX__) +# include "config-macosx.h" +#endif + + +/* ---- Platform detection ---- */ + + +/* + The operating system, must be one of: (WZ_OS_x) + + DARWIN - Darwin OS (synonym for WZ_OS_MAC) + OS2 - OS/2 + OS2EMX - XFree86 on OS/2 (not PM) + WIN32 - Win32 (Windows 95/98/ME and Windows NT/2000/XP) + CYGWIN - Cygwin + SOLARIS - Sun Solaris + HPUX - HP-UX + ULTRIX - DEC Ultrix + LINUX - Linux + FREEBSD - FreeBSD + GNU_kFREEBSD - GNU/kFreeBSD + NETBSD - NetBSD + OPENBSD - OpenBSD + BSDI - BSD/OS + IRIX - SGI Irix + OSF - HP Tru64 UNIX + SCO - SCO OpenServer 5 + UNIXWARE - UnixWare 7, Open UNIX 8 + AIX - AIX + HURD - GNU Hurd + DGUX - DG/UX + RELIANT - Reliant UNIX + DYNIX - DYNIX/ptx + QNX - QNX + QNX6 - QNX RTP 6.1 + LYNX - LynxOS + BSD4 - Any BSD 4.4 system + UNIX - Any UNIX BSD/SYSV system +*/ + +#if defined(__APPLE__) && (defined(__GNUC__) || defined(__xlC__) || defined(__xlc__)) +# define WZ_OS_DARWIN +# define WZ_OS_BSD4 +# ifdef __LP64__ +# define WZ_OS_DARWIN64 +# else +# define WZ_OS_DARWIN32 +# endif +#elif defined(__CYGWIN__) +# define WZ_OS_CYGWIN +#elif defined(__OS2__) +# if defined(__EMX__) +# define WZ_OS_OS2EMX +# else +# define WZ_OS_OS2 +# endif +#elif !defined(SAG_COM) && (defined(WIN64) || defined(_WIN64) || defined(__WIN64__)) +# define WZ_OS_WIN32 +# define WZ_OS_WIN64 +#elif !defined(SAG_COM) && (defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)) +# define WZ_OS_WIN32 +#elif defined(__MWERKS__) && defined(__INTEL__) +# define WZ_OS_WIN32 +#elif defined(__sun) || defined(sun) +# define WZ_OS_SOLARIS +#elif defined(hpux) || defined(__hpux) +# define WZ_OS_HPUX +#elif defined(__ultrix) || defined(ultrix) +# define WZ_OS_ULTRIX +#elif defined(sinix) +# define WZ_OS_RELIANT +#elif defined(__linux__) || defined(__linux) +# define WZ_OS_LINUX +#elif defined(__FreeBSD__) || defined(__DragonFly__) +# define WZ_OS_FREEBSD +# define WZ_OS_BSD4 +#elif defined(__FreeBSD_kernel__) && !defined(__FreeBSD__) + /* We're running a non-FreeBSD system with a FreeBSD kernel. Find out what C + * library we're using to detect the system we're running on. */ +# include +# if defined(__GLIBC__) + /* We're running GNU/kFreeBSD */ +# define WZ_OS_GNU_kFREEBSD +# endif +#elif defined(__NetBSD__) +# define WZ_OS_NETBSD +# define WZ_OS_BSD4 +#elif defined(__OpenBSD__) +# define WZ_OS_OPENBSD +# define WZ_OS_BSD4 +#elif defined(__bsdi__) +# define WZ_OS_BSDI +# define WZ_OS_BSD4 +#elif defined(__sgi) +# define WZ_OS_IRIX +#elif defined(__osf__) +# define WZ_OS_OSF +#elif defined(_AIX) +# define WZ_OS_AIX +#elif defined(__Lynx__) +# define WZ_OS_LYNX +#elif defined(__GNU__) +# define WZ_OS_HURD +#elif defined(__DGUX__) +# define WZ_OS_DGUX +#elif defined(__QNXNTO__) +# define WZ_OS_QNX6 +#elif defined(__QNX__) +# define WZ_OS_QNX +#elif defined(_SEQUENT_) +# define WZ_OS_DYNIX +#elif defined(_SCO_DS) /* SCO OpenServer 5 + GCC */ +# define WZ_OS_SCO +#elif defined(__USLC__) /* all SCO platforms + UDK or OUDK */ +# define WZ_OS_UNIXWARE +#elif defined(__svr4__) && defined(i386) /* Open UNIX 8 + GCC */ +# define WZ_OS_UNIXWARE +#elif defined(__INTEGRITY) +# define WZ_OS_INTEGRITY +#elif defined(__MAKEDEPEND__) +#else +# error "Warzone has not been tested on this OS. Please contact warzone-dev@gna.org" +#endif /* WZ_OS_x */ + +#if defined(WZ_OS_WIN32) || defined(WZ_OS_WIN64) +# define WZ_OS_WIN +#endif /* WZ_OS_WIN32 */ + +#if defined(WZ_OS_DARWIN) +# define WZ_OS_MAC /* WZ_OS_MAC is mostly for compatibility, but also more clear */ +# define WZ_OS_MACX /* WZ_OS_MACX is only for compatibility.*/ +# if defined(WZ_OS_DARWIN64) +# define WZ_OS_MAC64 +# elif defined(WZ_OS_DARWIN32) +# define WZ_OS_MAC32 +# endif +#endif /* WZ_OS_DARWIN */ + +#if defined(WZ_OS_MSDOS) || defined(WZ_OS_OS2) || defined(WZ_OS_WIN) +# undef WZ_OS_UNIX +#elif !defined(WZ_OS_UNIX) +# define WZ_OS_UNIX +#endif /* WZ_OS_* */ + + +/* + The compiler, must be one of: (WZ_CC_x) + + MSVC - Microsoft Visual C/C++, Intel C++ for Windows + GNU - GNU C++ + CLANG - Clang LLVM + INTEL - Intel C++ for Linux, Intel C++ for Windows + TINYC - Fabrice Bellard's Tiny C Compiler + + Should be sorted most to least authoritative. +*/ + +#if defined(_MSC_VER) +# define WZ_CC_MSVC +/* All ISO C89 compliant compilers _should_ define the macro __STDC__, MSVC + * however is known _not_ to do this, so work around that here. */ +# if !defined(__STDC__) +# define __STDC__ 1 +# endif +/* Visual C++.Net issues for _MSC_VER >= 1300 */ +# if _MSC_VER >= 1300 +# define WZ_CC_MSVC_NET +# endif +/* Intel C++ disguising as Visual C++: the `using' keyword avoids warnings */ +# if defined(__INTEL_COMPILER) +# define WZ_CC_INTEL +# endif +/* x64 does not support mmx intrinsics on windows */ +# if (defined(ZS_OS_WIN64) && defined(_M_X64)) +# undef ZS_HAVE_SSE +# undef ZS_HAVE_SSE2 +# undef ZS_HAVE_MMX +# undef ZS_HAVE_3DNOW +# endif + +#elif defined(__GNUC__) +# define WZ_CC_GNU +# if defined(__MINGW32__) +# define WZ_CC_MINGW +# endif +# if defined(__INTEL_COMPILER) +/* Intel C++ also masquerades as GCC 3.2.0 */ +# define WZ_CC_INTEL +# endif + +# if defined(__llvm__) +# define WZ_CC_LLVM +# endif +# if defined(__clang__) +# define WZ_CC_CLANG +# endif +/* Clang may not always masquerade as gcc */ +#elif defined(__clang__) +# define WZ_CC_CLANG +# define WZ_CC_LLVM + +#elif defined(__TINYC__) +# define WZ_CC_TINYC + +#else +# error "Warzone has not been tested on this compiler. Please contact warzone-dev@gna.org" +#endif /* WZ_CC_x */ + + +/* + The window system, must be one of: (WZ_WS_x) + + MACX - Mac OS X + WIN32 - Windows + X11 - X Window System + QNX - QNX +*/ + +#if defined(_WIN32_X11_) +# define WZ_WS_X11 + +#elif defined(WZ_OS_WIN32) +# define WZ_WS_WIN32 +# if defined(WZ_OS_WIN64) +# define WZ_WS_WIN64 +# endif + +#elif defined(WZ_OS_MAC) +# define WZ_WS_MAC +# define WZ_WS_MACX +# if defined(WZ_OS_MAC64) +# define WZ_WS_MAC64 +# elif defined(WZ_OS_MAC32) +# define WZ_WS_MAC32 +# endif + +#elif defined(WZ_OS_QNX) +# define WZ_WS_QNX + +#elif defined(WZ_OS_UNIX) +# define WZ_WS_X11 + +#else +# error "Warzone has not been tested on this window system. Please contact warzone-dev@gna.org" +#endif /* WZ_WS_x */ + +#if defined(WZ_WS_WIN16) || defined(WZ_WS_WIN32) +# define WZ_WS_WIN +#endif + + +/* + The supported C standard, must be one of: (WZ_Cxx) + + 99 - ISO/IEC 9899:1999 / C99 +*/ +#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L +# define WZ_C99 +#endif /* WZ_Cxx */ + +/* + The supported C++ standard, must be one of: (WZ_CXXxx) + + 98 - ISO/IEC 14882:1998 / C++98 +*/ +#if defined(__cplusplus) +# define WZ_CXX98 +#endif /* WZ_CXXxx */ + + +/* + Convenience macros to test the versions of gcc. + Copied from glibc's features.h. +*/ +#if defined(WZ_CC_GNU) && defined __GNUC__ && defined __GNUC_MINOR__ +# define WZ_CC_GNU_PREREQ(maj, min) \ + ((__GNUC__ << 16) + __GNUC_MINOR__ >= ((maj) << 16) + (min)) +#else +# define WZ_CC_GNU_PREREQ(maj, min) 0 +#endif + + +/* + Convenience macros to test the versions of icc. +*/ +#if defined(WZ_CC_INTEL) && defined __ICC +# define WZ_CC_INTEL_PREREQ(maj, min) \ + ((__ICC) >= ((maj) * 100) + (min)) +#else +# define WZ_CC_INTEL_PREREQ(maj, min) 0 +#endif + + + + +/* ---- Declaration attributes ---- */ + + +/*! + * \def WZ_DECL_DEPRECATED + * + * The WZ_DECL_DEPRECATED macro can be used to trigger compile-time warnings + * with newer compilers when deprecated functions are used. + * + * For non-inline functions, the macro gets inserted at front of the + * function declaration, right before the return type: + * + * \code + * WZ_DECL_DEPRECATED void deprecatedFunctionA(); + * WZ_DECL_DEPRECATED int deprecatedFunctionB() const; + * \endcode + * + * For functions which are implemented inline, + * the WZ_DECL_DEPRECATED macro is inserted at the front, right before the return + * type, but after "static", "inline" or "virtual": + * + * \code + * WZ_DECL_DEPRECATED void deprecatedInlineFunctionA() { .. } + * virtual WZ_DECL_DEPRECATED int deprecatedInlineFunctionB() { .. } + * static WZ_DECL_DEPRECATED bool deprecatedInlineFunctionC() { .. } + * inline WZ_DECL_DEPRECATED bool deprecatedInlineFunctionD() { .. } + * \endcode + * + * You can also mark whole structs or classes as deprecated, by inserting the + * WZ_DECL_DEPRECATED macro after the struct/class keyword, but before the + * name of the struct/class: + * + * \code + * class WZ_DECL_DEPRECATED DeprecatedClass { }; + * struct WZ_DECL_DEPRECATED DeprecatedStruct { }; + * \endcode + * + * \note + * Description copied from KDE4, code copied from Qt4. + * + */ +#if WZ_CC_GNU_PREREQ(3,2) || WZ_CC_INTEL_PREREQ(10,0) +# define WZ_DECL_DEPRECATED __attribute__((__deprecated__)) +#elif defined(WZ_CC_MSVC) && defined(WZ_CC_MSVC_NET) +# define WZ_DECL_DEPRECATED __declspec(deprecated) +#else +# define WZ_DECL_DEPRECATED +#endif + + +/*! \def WZ_DECL_FORMAT + * GCC: "The format attribute specifies that a function takes printf, scanf, strftime or strfmon + * style arguments which should be type-checked against a format string." + */ +#if WZ_CC_GNU_PREREQ(2,5) && !defined(WZ_CC_INTEL) +# define WZ_DECL_FORMAT(archetype, string_index, first_to_check) \ + __attribute__((__format__(archetype, string_index, first_to_check))) +#else +# define WZ_DECL_FORMAT(archetype, string_index, first_to_check) +#endif + + +/*! + * \def WZ_DECL_NORETURN + * "A few standard library functions, such as abort and exit, cannot return. GCC knows this + * automatically. Some programs define their own functions that never return. + * You can declare them noreturn to tell the compiler this fact." + */ +#if WZ_CC_GNU_PREREQ(2,5) && !defined(WZ_CC_INTEL) +# define WZ_DECL_NORETURN __attribute__((__noreturn__)) +#elif defined(WZ_CC_MSVC) +# define WZ_DECL_NORETURN __declspec(noreturn) +#else +# define WZ_DECL_NORETURN +#endif + + +/*! + * \def WZ_DECL_CONST + * GCC: "Many functions do not examine any values except their arguments, and have no effects + * except the return value. Basically this is just slightly more strict class than + * the pure attribute below, since function is not allowed to read global memory." + */ +#if WZ_CC_GNU_PREREQ(2,5) && !defined(WZ_CC_INTEL) +# define WZ_DECL_CONST __attribute__((__const__,__warn_unused_result__)) +#else +# define WZ_DECL_CONST +#endif + + +/*! + * \def WZ_DECL_PURE + * GCC: "Many functions have no effects except the return value and their return value depends + * only on the parameters and/or global variables. Such a function can be subject to + * common subexpression elimination and loop optimization just as an arithmetic operator + * would be." + */ +#if WZ_CC_GNU_PREREQ(2,96) && !defined(WZ_CC_INTEL) +# define WZ_DECL_PURE __attribute__((__pure__)) +#else +# define WZ_DECL_PURE +#endif + + +/*! + * \def WZ_DECL_UNUSED + * GCC: "This attribute, attached to a function, means that the function is meant to be possibly + * unused. GCC will not produce a warning for this function." + */ +#if WZ_CC_GNU_PREREQ(3,2) || WZ_CC_INTEL_PREREQ(10,0) +# define WZ_DECL_UNUSED __attribute__((__unused__)) +#else +# define WZ_DECL_UNUSED +#endif + + +/*! + * \def WZ_DECL_WARN_UNUSED_RESULT + * GCC: "The warn_unused_result attribute causes a warning to be emitted if a caller of the + * function with this attribute does not use its return value. This is useful for + * functions where not checking the result is either a security problem or always a bug, + * such as realloc." + */ +#if defined(WZ_CC_GNU) && !defined(WZ_CC_INTEL) +# define WZ_DECL_WARN_UNUSED_RESULT __attribute__((__warn_unused_result__)) +#else +# define WZ_DECL_WARN_UNUSED_RESULT +#endif + + +/*! \def WZ_DECL_MAY_ALIAS + * GCC: "Accesses to objects with types with this attribute are not subjected to type-based alias + * analysis, but are instead assumed to be able to alias any other type of objects, + * just like the char type. See -fstrict-aliasing for more information on aliasing issues." + */ +#if WZ_CC_GNU_PREREQ(3,3) && !defined(WZ_CC_INTEL) +# define WZ_DECL_MAY_ALIAS __attribute__((__may_alias__)) +#else +# define WZ_DECL_MAY_ALIAS +#endif + + +/*! + * \def WZ_DECL_RESTRICT + * Apply the "restrict" keyword found in the C99 revision of the standard. + * The compiler may assume that the memory referenced by a "restrict" pointer is not aliased + * by any other pointer. Thus this forms the opposite of WZ_DECL_MAY_ALIAS. + */ +#if defined(WZ_C99) && WZ_CC_GNU_PREREQ(4,1) && !defined(WZ_CC_INTEL) +# define WZ_DECL_RESTRICT restrict +#elif defined(WZ_CC_MSVC) && defined(WZ_CC_MSVC_NET) +# define WZ_DECL_RESTRICT __restrict +#else +# define WZ_DECL_RESTRICT +#endif + + +/*! \def WZ_DECL_THREAD + * Declares a variable to be local to the running thread, and not shared between threads. + */ +#if defined(WZ_CC_GNU) || defined(WZ_CC_INTEL) +# define WZ_DECL_THREAD __thread +#elif defined(WZ_CC_MSVC) +# define WZ_DECL_THREAD __declspec(thread) +#else +# error "Thread local storage attribute required" +#endif + + +/*! \def WZ_ASSERT_STATIC_STRING + * Asserts that the given string is statically allocated. + */ +#if defined(__cplusplus) +# include +# define WZ_ASSERT_STATIC_STRING(_var) assert(typeid(_var) == typeid(char[sizeof(_var)])) +#elif defined(WZ_CC_GNU) || defined(WZ_CC_INTEL) +# define WZ_ASSERT_STATIC_STRING(_var) STATIC_ASSERT(__builtin_types_compatible_p(typeof(_var), char[])) +#else +# define WZ_ASSERT_STATIC_STRING(_var) (void)(_var) +#endif + +/*! \def WZ_ASSERT_ARRAY + * Asserts that the given variable is a (statically sized) array, not just a pointer. + */ +#if defined(__cplusplus) +# define WZ_ASSERT_ARRAY_EXPR(a) 0 +#elif defined(WZ_CC_GNU) || defined(WZ_CC_INTEL) +/* &a[0] degrades to a pointer: a different type from an array */ +# define WZ_ASSERT_ARRAY_EXPR(a) STATIC_ASSERT_EXPR(!__builtin_types_compatible_p(typeof(a), typeof(&(a)[0]))) +#else +# define WZ_ASSERT_ARRAY_EXPR(a) 0 +#endif +#define WZ_ASSERT_ARRAY(a) (void)WZ_ASSERT_ARRAY_EXPR(a) + + +/* ---- Platform specific setup ---- */ + + +#if defined(WZ_OS_WIN) +# if defined(WZ_CC_MINGW) +# include +# include +# include +# define _WIN32_IE IE5 +// Required for alloca +# include + +# elif defined(WZ_CC_MSVC) +# if defined(_DEBUG) +# define DEBUG +# define _CRTDBG_MAP_ALLOC +# include +# include +# endif /* _DEBUG */ +# endif /* WZ_CC_* */ + +# define WIN32_LEAN_AND_MEAN +# define WIN32_EXTRA_LEAN +# undef NOMINMAX +# define NOMINMAX 1 // disable the min / max macros +# include + +# if defined(WZ_CC_MSVC) +// notify people we are disabling these warning messages. +# pragma message (" *** Warnings 4018,4100,4127,4204,4244,4267,4389 have been squelched. ***") +# pragma warning (disable : 4018) // Shut up: '>' : signed/unsigned mismatch +# pragma warning (disable : 4100) // Shut up: unreferenced formal parameter (FIXME) +# pragma warning (disable : 4127) // Shut up: conditional expression is constant (eg. "while(0)") +# pragma warning (disable : 4204) // Shut up: non-constant aggregate initializer +# pragma warning (disable : 4244) // Shut up: conversion from 'float' to 'int', possible loss of data +# pragma warning (disable : 4267) // Shut up: conversion from 'size_t' to 'type', possible loss of data +# pragma warning (disable : 4389) // Shut up: '==' : signed/unsigned mismatch + +# define strcasecmp _stricmp +# define strncasecmp _strnicmp +# define inline __inline +# define alloca _alloca +# define fileno _fileno + +# define isnan _isnan +# define isfinite _finite + +# define PATH_MAX MAX_PATH +# endif /* WZ_CC_MSVC */ + +/* Make sure that PATH_MAX is large enough to use as the size for return + * buffers for Windows API calls + */ +# if (PATH_MAX < MAX_PATH) +# undef PATH_MAX +# define PATH_MAX MAX_PATH +# endif + +#elif defined(WZ_OS_UNIX) +# include +# if defined(HAVE_ALLOCA_H) +# include +# endif +#endif /* WZ_OS_* */ + +// Define PATH_MAX for systems that don't have it, like Hurd +#ifndef PATH_MAX +#define PATH_MAX 4096 +#endif + + +#if !defined(WZ_C99) && !defined(va_copy) +/** + * Implements the interface of the C99 macro va_copy such that we can use it on + * non-C99 systems as well. + * + * This implementation assumes that va_list is just a pointer to the stack + * frame of the variadic function. This is by far the most common setup, though + * it might not always work. + */ +# define va_copy(dest, src) (void)((dest) = (src)) +#endif // !WZ_C99 && !va_copy + +#endif /* WZGLOBAL_H */ diff --git a/lib/clipboard/readme.txt b/lib/clipboard/readme.txt new file mode 100644 index 0000000..196c127 --- /dev/null +++ b/lib/clipboard/readme.txt @@ -0,0 +1 @@ +Source code in this directory was taken from Warzone2100 source. Please read COPING.README for licence or visit https://github.com/cybersphinx/wzgraphicsmods for more information. diff --git a/lib/clipboard/src/clipboardWin32.c b/lib/clipboard/src/clipboardWin32.c new file mode 100644 index 0000000..be48906 --- /dev/null +++ b/lib/clipboard/src/clipboardWin32.c @@ -0,0 +1,160 @@ +/* + This file is part of Warzone 2100. + Copyright (C) 2008 Freddie Witherden + Copyright (C) 2008-2009 Warzone Resurrection Project + + Warzone 2100 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. + + Warzone 2100 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 Warzone 2100; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +#define WIN32_LEAN_AND_MEAN +#include + +#include "utf.h" +// Defines most macros and types from and +#include "types.h" + +char *widgetGetClipboardText() +{ + uint16_t *clipboardText; + char *ourText = NULL; + + // If there is any text on the clipboard, open it + if (IsClipboardFormatAvailable(CF_UNICODETEXT) && OpenClipboard(NULL)) + { + // Get any text on the clipboard + HANDLE hClipboardData = GetClipboardData(CF_UNICODETEXT); + + // If the handle is valid, fetch the text + if (hClipboardData) + { + // Get the text + clipboardText = GlobalLock(hClipboardData); + + // So long as we got something + if (clipboardText) + { + int i, j; + + // Convert it to UTF-8 (from UTF-16) + ourText = UTF16toUTF8(clipboardText, NULL); + + // Unlock the text + GlobalUnlock(hClipboardData); + + // Strip any '\r' from the text + for (i = j = 0; ourText[i]; i++) + { + if (ourText[i] != '\r') + { + ourText[j++] = ourText[i]; + } + } + + // NUL terminate + ourText[j] = '\0'; + } + } + + // Close the clipboard + CloseClipboard(); + } + + return ourText; +} + +bool widgetSetClipboardText(const char *text) +{ + bool ret = false; + + // Copy of text with \n => \r\n + char *newText; + + // UTF-16 version of newText + uint16_t *utf16NewText; + + // Number of bytes utf16NewText is in size + size_t nbytes; + + int count, i, j; + + // Get the number of '\n' characters in the text + for (i = count = 0; text[i]; i++) + { + if (text[i] == '\n') + { + count++; + } + } + + // Allocate enough space for the \r\n string + newText = malloc(strlen(text) + count + 1); + + // Copy the string, converting \n to \r\n + for (i = j = 0; text[i]; i++, j++) + { + // If the character is a newline prepend a \r + if (text[i] == '\n') + { + newText[j++] = '\r'; + } + + // Copy the character (\n or otherwise) + newText[j] = text[i]; + } + + // NUL terminate + newText[j] = '\0'; + + // Convert to UTF-16 + utf16NewText = UTF8toUTF16(newText, &nbytes); + + // Open the clipboard + if (OpenClipboard(NULL)) + { + HGLOBAL hGlobal; + uint16_t *clipboardText; + + // Empty it (which also transfers ownership of it to ourself) + EmptyClipboard(); + + // Allocate global space for the text + hGlobal = GlobalAlloc(GMEM_MOVEABLE, nbytes); + + // Lock the newly allocated memory + clipboardText = GlobalLock(hGlobal); + + // Copy the text + memcpy(clipboardText, utf16NewText, nbytes); + + // Unlock the memory (must come before CloseClipboard()) + GlobalUnlock(hGlobal); + + // Place the handle on the clipboard + if (SetClipboardData(CF_UNICODETEXT, hGlobal)) + { + // We were successful + ret = true; + } + + // Close the clipboard + CloseClipboard(); + } + + // Release the malloc-ed strings + free(newText); + free(utf16NewText); + + return ret; +} diff --git a/lib/clipboard/src/clipboardX11.c b/lib/clipboard/src/clipboardX11.c new file mode 100644 index 0000000..0653250 --- /dev/null +++ b/lib/clipboard/src/clipboardX11.c @@ -0,0 +1,293 @@ +/* + This file is part of Warzone 2100. + Copyright (C) 2008 Freddie Witherden + Copyright (C) 2008-2009 Warzone Resurrection Project + + Warzone 2100 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. + + Warzone 2100 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 Warzone 2100; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA +*/ + +/* + * Something wicked this way comes... + * Documentation/reference: + * http://svr-www.eng.cam.ac.uk/~er258/code/dist/x_clipboard/paste.cc + */ + +#include +#include + +#include +#include + +static SDL_SysWMinfo info; + +// Atoms +static Atom XA_CLIPBOARD; +static Atom XA_COMPOUND_TEXT; +static Atom XA_UTF8_STRING; +static Atom XA_TARGETS; + +/** + * Filters through SDL_Events searching for clipboard requests from the X + * server. + * + * @param evt The event to filter. + */ +static int widgetClipboardFilterX11(const SDL_Event *evt) +{ + // We are only interested in window manager events + if (evt->type == SDL_SYSWMEVENT) + { + XEvent xevent = evt->syswm.msg->event.xevent; + + // See if the event is a selection/clipboard request + if (xevent.type == SelectionRequest) + { + // Get the request in question + XSelectionRequestEvent *request = &xevent.xselectionrequest; + + // Generate a reply to the selection request + XSelectionEvent reply; + + reply.type = SelectionNotify; + reply.serial = xevent.xany.send_event; + reply.send_event = True; + reply.display = info.info.x11.display; + reply.requestor = request->requestor; + reply.selection = request->selection; + reply.property = request->property; + reply.target = None; + reply.time = request->time; + + // They want to know what we can provide/offer + if (request->target == XA_TARGETS) + { + Atom possibleTargets[] = + { + XA_STRING, + XA_UTF8_STRING, + XA_COMPOUND_TEXT + }; + + XChangeProperty(info.info.x11.display, request->requestor, + request->property, XA_ATOM, 32, PropModeReplace, + (unsigned char *) possibleTargets, 3); + } + // They want a string (all we can provide) + else if (request->target == XA_STRING + || request->target == XA_UTF8_STRING + || request->target == XA_COMPOUND_TEXT) + { + int len; + char *xdata = XFetchBytes(info.info.x11.display, &len); + + XChangeProperty(info.info.x11.display, request->requestor, + request->property, request->target, 8, + PropModeReplace, (unsigned char *) xdata, + len); + XFree(xdata); + } + else + { + // Did not have what they wanted, so no property set + reply.property = None; + } + + // Dispatch the event + XSendEvent(request->display, request->requestor, 0, NoEventMask, + (XEvent *) &reply); + XSync(info.info.x11.display, False); + } + } + + return 1; +} + +static void widgetInitialiseClipboardX11() +{ + static bool initialised = false; + + if (!initialised) + { + // Get the window manager information + SDL_GetWMInfo(&info); + + // Ensure we're running under X11 + assert(info.subsystem == SDL_SYSWM_X11); + + // Register the event filter + SDL_EventState(SDL_SYSWMEVENT, SDL_ENABLE); + SDL_SetEventFilter(widgetClipboardFilterX11); + + // Lock the connection to the X server + info.info.x11.lock_func(); + + // Get the clipboard atom (it is not defined by default) + XA_CLIPBOARD = XInternAtom(info.info.x11.display, "CLIPBOARD", True); + + // Get the compound text type atom + XA_COMPOUND_TEXT = XInternAtom(info.info.x11.display, "COMPOUND_TEXT", + True); + + // UTF-8 string atom + XA_UTF8_STRING = XInternAtom(info.info.x11.display, "UTF8_STRING", + True); + + // TARGETS atom + XA_TARGETS = XInternAtom(info.info.x11.display, "TARGETS", True); + + // Unlock the connection + info.info.x11.unlock_func(); + + // We are initialised + initialised = true; + } +} + +char *widgetGetClipboardText() +{ + char *text = NULL; + unsigned char *data = NULL; + Atom type; + int format, result; + unsigned long len, bytesLeft, dummy; + Window selectionOwner; + + // Make sure we are initialised + widgetInitialiseClipboardX11(); + + // Lock the connection + info.info.x11.lock_func(); + + // Get the owner of the clipboard selection + selectionOwner = XGetSelectionOwner(info.info.x11.display, XA_CLIPBOARD); + + // If there is a selection (and therefore owner) fetch it + if (selectionOwner != None) + { + SDL_Event event; + bool response = false; + + /* + * Ask the window whom current owns the clipboard to convert it to an + * XA_UTF8_STRING and place it into the XA_CLIPBOARD property of our + * window. + */ + XConvertSelection(info.info.x11.display, XA_CLIPBOARD, XA_UTF8_STRING, + XA_CLIPBOARD, info.info.x11.window, CurrentTime); + XFlush(info.info.x11.display); + + /* + * We now need to wait for a response from the window that owns the + * clipboard. + */ + + // Unlock the connection so that the SDL event loop may function + info.info.x11.unlock_func(); + + while (!response) + { + // Wait for an event + SDL_WaitEvent(&event); + + // If the event is a window manager event + if (event.type == SDL_SYSWMEVENT) + { + XEvent xevent = event.syswm.msg->event.xevent; + + // See if it is a response to our request + if (xevent.type == SelectionNotify + && xevent.xselection.requestor == info.info.x11.window) + { + response = true; + } + } + } + + // Lock the connection once again + info.info.x11.lock_func(); + + // See how much data is there + XGetWindowProperty(info.info.x11.display, info.info.x11.window, + XA_CLIPBOARD, 0, 0, False, AnyPropertyType, &type, + &format, &len, &bytesLeft, &data); + + // If any 0-length data was returned, free it + if (data) + { + XFree(data); + data = NULL; + } + + // If there is any data + if (bytesLeft) + { + // Fetch the data + result = XGetWindowProperty(info.info.x11.display, + info.info.x11.window, XA_CLIPBOARD, 0, + bytesLeft, False, AnyPropertyType, + &type, &format, &len, &dummy, &data); + + // If we got some data, duplicate it + if (result == Success) + { + text = strdup((char *) data); + XFree(data); + } + } + + // Delete the property now that we are finished with it + XDeleteProperty(info.info.x11.display, info.info.x11.window, + XA_CLIPBOARD); + } + + // Unlock the connection + info.info.x11.unlock_func(); + + return text; +} + +bool widgetSetClipboardText(const char *text) +{ + Window selectionOwner; + + // Make sure we are initialised + widgetInitialiseClipboardX11(); + + // Lock the connection + info.info.x11.lock_func(); + + // Copy the text into the root windows cut buffer (for Xterm compatibility) + XStoreBytes(info.info.x11.display, text, strlen(text) + 1); + + // Set ourself as the owner of the CLIPBOARD atom + XSetSelectionOwner(info.info.x11.display, XA_CLIPBOARD, + info.info.x11.window, CurrentTime); + + // Check if we acquired ownership or not + selectionOwner = XGetSelectionOwner(info.info.x11.display, XA_CLIPBOARD); + + // We got ownership + if (selectionOwner == info.info.x11.window) + { + info.info.x11.unlock_func(); + return true; + } + // We did not get ownership + else + { + info.info.x11.unlock_func(); + return false; + } +} diff --git a/lib/clipboard/src/utf.c b/lib/clipboard/src/utf.c new file mode 100644 index 0000000..2313bb6 --- /dev/null +++ b/lib/clipboard/src/utf.c @@ -0,0 +1,530 @@ +/* + This file is part of Warzone 2100. + Copyright (C) 2007 Giel van Schijndel + Copyright (C) 2007-2009 Warzone Resurrection Project + + Warzone 2100 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. + + Warzone 2100 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 Warzone 2100; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + + $Revision: 9101 $ + $Id: utf.c 9101 2010-01-10 13:11:55Z zarelsl $ + $HeadURL: https://warzone2100.svn.sourceforge.net/svnroot/warzone2100/trunk/lib/framework/utf.c $ +*/ + +/** \file + * Functions to convert between different Unicode Transformation Formats (UTF for short) + */ + +#include "utf.h" +#include +#include + +#if defined(LIB_COMPILE) +# define ASSERT(expr, ...) (assert(expr)) +# define debug(part, ...) ((void)0) +#else +# include "debug.h" +#endif + +// Assert that non-starting octets are of the form 10xxxxxx +#define ASSERT_NON_START_OCTET(octet) \ + assert((octet & 0xC0) == 0x80 && "invalid non-start UTF-8 octet") + +// Assert that starting octets are either of the form 0xxxxxxx (ASCII) or 11xxxxxx +#define ASSERT_START_OCTECT(octet) \ + assert((octet & 0x80) == 0x00 || (octet & 0xC0) == 0xC0 || !"invalid starting UTF-8 octet") + +// Assert that hexadect (16bit sequence) 1 of UTF-16 surrogate pair sequences are of the form 110110XXXXXXXXXX +#define ASSERT_START_HEXADECT(hexadect) \ + assert(((hexadect) & 0xD800) == 0xD800 && "invalid first UTF-16 hexadect") + +// Assert that hexadect (16bit sequence) 2 of UTF-16 surrogate pair sequences are of the form 110111XXXXXXXXXX +#define ASSERT_FINAL_HEXADECT(hexadect) \ + assert(((hexadect) & 0xDC00) == 0xDC00 && "invalid first UTF-16 hexadect") + +utf_32_char UTF8DecodeChar(const char *utf8_char, const char **next_char) +{ + utf_32_char decoded = '\0'; + *next_char = utf8_char; + + ASSERT_START_OCTECT(*utf8_char); + + // first octect: 0xxxxxxx: 7 bit (ASCII) + if ((*utf8_char & 0x80) == 0x00) + { + // 1 byte long encoding + decoded = *((*next_char)++); + } + // first octect: 110xxxxx: 11 bit + else if ((*utf8_char & 0xe0) == 0xc0) + { + // 2 byte long encoding + ASSERT_NON_START_OCTET(utf8_char[1]); + + decoded = (*((*next_char)++) & 0x1f) << 6; + decoded |= (*((*next_char)++) & 0x3f) << 0; + } + // first octect: 1110xxxx: 16 bit + else if ((*utf8_char & 0xf0) == 0xe0) + { + // 3 byte long encoding + ASSERT_NON_START_OCTET(utf8_char[1]); + ASSERT_NON_START_OCTET(utf8_char[2]); + + decoded = (*((*next_char)++) & 0x0f) << 12; + decoded |= (*((*next_char)++) & 0x3f) << 6; + decoded |= (*((*next_char)++) & 0x3f) << 0; + } + // first octect: 11110xxx: 21 bit + else if ((*utf8_char & 0xf8) == 0xf0) + { + // 4 byte long encoding + ASSERT_NON_START_OCTET(utf8_char[1]); + ASSERT_NON_START_OCTET(utf8_char[2]); + ASSERT_NON_START_OCTET(utf8_char[3]); + + decoded = (*((*next_char)++) & 0x07) << 18; + decoded |= (*((*next_char)++) & 0x3f) << 12; + decoded |= (*((*next_char)++) & 0x3f) << 6; + decoded |= (*((*next_char)++) & 0x3f) << 0; + } + else + { + // apparently this character uses more than 21 bit + // this decoder is not developed to cope with those + // characters so error out + ASSERT(!"out-of-range UTF-8 character", "this UTF-8 character is too large (> 21bits) for this UTF-8 decoder and too large to be a valid Unicode codepoint"); + } + + return decoded; +} + +size_t UTF8CharacterCount(const char *utf8_string) +{ + size_t length = 0; + + while (*utf8_string != '\0') + { + UTF8DecodeChar(utf8_string, &utf8_string); + + ++length; + } + + return length; +} + +size_t UTF16CharacterCount(const uint16_t *utf16) +{ + size_t length = 0; + + while (*utf16) + { + UTF16DecodeChar(utf16, &utf16); + + ++length; + } + + return length; +} + +static size_t unicode_utf8_char_length(const utf_32_char unicode_char) +{ + // an ASCII character, which uses 7 bit at most, which is one byte in UTF-8 + if (unicode_char < 0x00000080) + return 1; // stores 7 bits + else if (unicode_char < 0x00000800) + return 2; // stores 11 bits + else if (unicode_char < 0x00010000) + return 3; // stores 16 bits + /* This encoder can deal with < 0x00200000, but Unicode only ranges + * from 0x0 to 0x10FFFF. Thus we don't accept anything else. + */ + else if (unicode_char < 0x00110000) + return 4; // stores 21 bits + + /* Apparently this character lies outside the 0x0 - 0x10FFFF + * Unicode range, so don't accept it. + */ + ASSERT(!"out-of-range Unicode codepoint", "This Unicode codepoint is too large (%u > 0x10FFFF) to be a valid Unicode codepoint", (unsigned int)unicode_char); + + // Dummy value to prevent warnings about missing return from function + return 0; +} + +char *UTF8CharacterAtOffset(const char *utf8_string, size_t index) +{ + while (*utf8_string != '\0' + && index != 0) + { + // Move to the next character + UTF8DecodeChar(utf8_string, &utf8_string); + + --index; + } + + if (*utf8_string == '\0') + return NULL; + + return (char*)utf8_string; +} + +/** Encodes a single Unicode character to a UTF-8 encoded string. + * + * \param unicode_char A UTF-32 encoded Unicode codepoint that will be encoded + * into UTF-8. This should be a valid Unicode codepoint + * (i.e. ranging from 0x0 to 0x10FFFF inclusive). + * \param out_char Points to the position in a buffer where the UTF-8 + * encoded character can be stored. + * + * \return A pointer pointing to the first byte after the encoded + * UTF-8 sequence. This can be used as the \c out_char parameter for a + * next invocation of encode_utf8_char(). + */ +static char *encode_utf8_char(const utf_32_char unicode_char, char *out_char) +{ + char *next_char = out_char; + + // 7 bits + if (unicode_char < 0x00000080) + { + *(next_char++) = unicode_char; + } + // 11 bits + else if (unicode_char < 0x00000800) + { + // 0xc0 provides the counting bits: 110 + // then append the 5 most significant bits + *(next_char++) = 0xc0 | (unicode_char >> 6); + // Put the next 6 bits in a byte of their own + *(next_char++) = 0x80 | (unicode_char & 0x3f); + } + // 16 bits + else if (unicode_char < 0x00010000) + { + // 0xe0 provides the counting bits: 1110 + // then append the 4 most significant bits + *(next_char++) = 0xe0 | (unicode_char >> 12); + // Put the next 12 bits in two bytes of their own + *(next_char++) = 0x80 | ((unicode_char >> 6) & 0x3f); + *(next_char++) = 0x80 | (unicode_char & 0x3f); + } + // 21 bits + /* This encoder can deal with < 0x00200000, but Unicode only ranges + * from 0x0 to 0x10FFFF. Thus we don't accept anything else. + */ + else if (unicode_char < 0x00110000) + { + // 0xf0 provides the counting bits: 11110 + // then append the 3 most significant bits + *(next_char++) = 0xf0 | (unicode_char >> 18); + // Put the next 18 bits in three bytes of their own + *(next_char++) = 0x80 | ((unicode_char >> 12) & 0x3f); + *(next_char++) = 0x80 | ((unicode_char >> 6) & 0x3f); + *(next_char++) = 0x80 | (unicode_char & 0x3f); + } + else + { + /* Apparently this character lies outside the 0x0 - 0x10FFFF + * Unicode range, so don't accept it. + */ + ASSERT(!"out-of-range Unicode codepoint", "This Unicode codepoint is too large (%u > 0x10FFFF) to be a valid Unicode codepoint", (unsigned int)unicode_char); + } + + return next_char; +} + +utf_32_char UTF16DecodeChar(const utf_16_char *utf16_char, const utf_16_char **next_char) +{ + utf_32_char decoded; + *next_char = utf16_char; + + // Are we dealing with a surrogate pair + if (*utf16_char >= 0xD800 + && *utf16_char <= 0xDFFF) + { + ASSERT_START_HEXADECT(utf16_char[0]); + ASSERT_FINAL_HEXADECT(utf16_char[1]); + + decoded = (*((*next_char)++) & 0x3ff) << 10; + decoded |= *((*next_char)++) & 0x3ff; + + decoded += 0x10000; + } + // Not a surrogate pair, so it's a valid Unicode codepoint right away + else + { + decoded = *((*next_char)++); + } + + return decoded; +} + +/** Encodes a single Unicode character to a UTF-16 encoded string. + * + * \param unicode_char A UTF-32 encoded Unicode codepoint that will be encoded + * into UTF-16. This should be a valid Unicode codepoint + * (i.e. ranging from 0x0 to 0x10FFFF inclusive). + * \param out_char Points to the position in a buffer where the UTF-16 + * encoded character can be stored. + * + * \return A pointer pointing to the first byte after the encoded + * UTF-16 sequence. This can be used as the \c out_char parameter for a + * next invocation of encode_utf16_char(). + */ +static utf_16_char *encode_utf16_char(const utf_32_char unicode_char, utf_16_char *out_char) +{ + utf_16_char *next_char = out_char; + + // 16 bits + if (unicode_char < 0x10000) + { + *(next_char++) = unicode_char; + } + else if (unicode_char < 0x110000) + { + const utf_16_char v = unicode_char - 0x10000; + + *(next_char++) = 0xD800 | (v >> 10); + *(next_char++) = 0xDC00 | (v & 0x3ff); + + ASSERT_START_HEXADECT(out_char[0]); + ASSERT_FINAL_HEXADECT(out_char[1]); + } + else + { + /* Apparently this character lies outside the 0x0 - 0x10FFFF + * Unicode range, and UTF-16 cannot cope with that, so error + * out. + */ + ASSERT(!"out-of-range Unicode codepoint", "This Unicode codepoint is too large (%u > 0x10FFFF) to be a valid Unicode codepoint", (unsigned int)unicode_char); + } + + return next_char; +} + +static size_t utf16_utf8_buffer_length(const utf_16_char* unicode_string) +{ + const utf_16_char* curChar = unicode_string; + + // Determine length of string (in octets) when encoded in UTF-8 + size_t length = 0; + + while (*curChar) + { + length += unicode_utf8_char_length(UTF16DecodeChar(curChar, &curChar)); + } + + return length; +} + +char *UTF16toUTF8(const utf_16_char *unicode_string, size_t *nbytes) +{ + const utf_16_char* curChar; + + const size_t utf8_length = utf16_utf8_buffer_length(unicode_string); + + // Allocate memory to hold the UTF-8 encoded string (plus a terminating nul char) + char* utf8_string = malloc(utf8_length + 1); + char* curOutPos = utf8_string; + + if (utf8_string == NULL) + { + debug(LOG_ERROR, "Out of memory"); + return NULL; + } + + curChar = unicode_string; + while (*curChar) + { + curOutPos = encode_utf8_char(UTF16DecodeChar(curChar, &curChar), curOutPos); + } + + // Terminate the string with a nul character + utf8_string[utf8_length] = '\0'; + + // Set the number of bytes allocated + if (nbytes) + { + *nbytes = utf8_length + 1; + } + + return utf8_string; +} + +static size_t utf8_as_utf16_buf_size(const char* utf8_string) +{ + const char* curChar = utf8_string; + + size_t length = 0; + while (*curChar != '\0') + { + const utf_32_char unicode_char = UTF8DecodeChar(curChar, &curChar); + + if (unicode_char < 0x10000) + { + length += 1; + } + else if (unicode_char < 0x110000) + { + length += 2; + } + else + { + /* Apparently this character lies outside the 0x0 - 0x10FFFF + * Unicode range, and UTF-16 cannot cope with that, so error + * out. + */ + ASSERT(!"out-of-range Unicode codepoint", "This Unicode codepoint too large (%u > 0x10FFFF) for the UTF-16 encoding", (unsigned int)unicode_char); + } + } + + return length; +} + +utf_16_char *UTF8toUTF16(const char* utf8_string, size_t *nbytes) +{ + const char* curChar = utf8_string; + const size_t unicode_length = utf8_as_utf16_buf_size(utf8_string); + + // Allocate memory to hold the UTF-16 encoded string (plus a terminating nul) + utf_16_char* unicode_string = malloc(sizeof(utf_16_char) * (unicode_length + 1)); + utf_16_char* curOutPos = unicode_string; + + if (unicode_string == NULL) + { + debug(LOG_ERROR, "Out of memory"); + return NULL; + } + + while (*curChar != '\0') + { + curOutPos = encode_utf16_char(UTF8DecodeChar(curChar, &curChar), curOutPos); + } + + // Terminate the string with a nul + unicode_string[unicode_length] = '\0'; + + // Set the number of bytes allocated + if (nbytes) + { + *nbytes = sizeof(utf_16_char) * (unicode_length + 1); + } + + return unicode_string; +} + +utf_16_char *UTF16CharacterAtOffset(const utf_16_char *utf16_string, size_t index) +{ + while (*utf16_string != '\0' + && index != 0) + { + // Move to the next character + UTF16DecodeChar(utf16_string, &utf16_string); + + --index; + } + + if (*utf16_string == '\0') + return NULL; + + return (utf_16_char*)utf16_string; +} + + +static size_t utf32_utf8_buffer_length(const utf_32_char* unicode_string) +{ + const utf_32_char* curChar; + + // Determine length of string (in octets) when encoded in UTF-8 + size_t length = 0; + for (curChar = unicode_string; *curChar != '\0'; ++curChar) + { + length += unicode_utf8_char_length(*curChar); + } + + return length; +} + +char *UTF32toUTF8(const utf_32_char *unicode_string, size_t *nbytes) +{ + const utf_32_char* curChar; + + const size_t utf8_length = utf32_utf8_buffer_length(unicode_string); + + // Allocate memory to hold the UTF-8 encoded string (plus a terminating nul char) + char* utf8_string = malloc(utf8_length + 1); + char* curOutPos = utf8_string; + + if (utf8_string == NULL) + { + debug(LOG_ERROR, "Out of memory"); + return NULL; + } + + for (curChar = unicode_string; *curChar != 0; ++curChar) + { + curOutPos = encode_utf8_char(*curChar, curOutPos); + } + + // Terminate the string with a nul character + utf8_string[utf8_length] = '\0'; + + // Set the number of bytes allocated + if (nbytes) + { + *nbytes = utf8_length + 1; + } + + return utf8_string; +} + +utf_32_char *UTF8toUTF32(const char *utf8_string, size_t *nbytes) +{ + const char* curChar = utf8_string; + const size_t unicode_length = UTF8CharacterCount(utf8_string); + + // Allocate memory to hold the UTF-32 encoded string (plus a terminating nul) + utf_32_char* unicode_string = malloc(sizeof(utf_32_char) * (unicode_length + 1)); + utf_32_char* curOutPos = unicode_string; + + if (unicode_string == NULL) + { + debug(LOG_ERROR, "Out of memory"); + return NULL; + } + + while (*curChar != '\0') + { + *(curOutPos++) = UTF8DecodeChar(curChar, &curChar); + } + + // Terminate the string with a nul + unicode_string[unicode_length] = '\0'; + + // Set the number of bytes allocated + if (nbytes) + { + *nbytes = sizeof(utf_32_char) * (unicode_length + 1); + } + + return unicode_string; +} + +size_t utf32len(const utf_32_char *unicode_string) +{ + size_t ret = 0; + while (*unicode_string++) + ++ret; + return ret; +} -- cgit v1.2.3-1-g7c22