mirror of
https://gitlab.gnome.org/GNOME/gtk.git
synced 2024-11-10 10:50:10 +00:00
afee2c67c5
Wed Jul 26 12:59:31 2000 Tim Janik <timj@gtk.org>
* *.[hc]: applied patch from Andreas Persenius <ndap@swipnet.se> that
updates the license headers to the GNU Lesser General Public License,
as well as updating the copyright year to 2000.
389 lines
6.8 KiB
C
389 lines
6.8 KiB
C
/* GDK - The GIMP Drawing Kit
|
|
* Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
|
|
*
|
|
* This library 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 of the License, or (at your option) any later version.
|
|
*
|
|
* This library 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
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
* Boston, MA 02111-1307, USA.
|
|
*/
|
|
|
|
/*
|
|
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
|
|
* file for a list of people on the GTK+ Team. See the ChangeLog
|
|
* files for a list of changes. These files are distributed with
|
|
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
|
|
*/
|
|
|
|
#include <config.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <locale.h>
|
|
|
|
#include "gdkim.h"
|
|
#include "gdkpixmap.h"
|
|
#include "gdkinternals.h"
|
|
#include "gdki18n.h"
|
|
#include "gdkwin32.h"
|
|
|
|
/*
|
|
*--------------------------------------------------------------
|
|
* gdk_set_locale
|
|
*
|
|
* Arguments:
|
|
*
|
|
* Results:
|
|
*
|
|
* Side effects:
|
|
*
|
|
*--------------------------------------------------------------
|
|
*/
|
|
|
|
gchar*
|
|
gdk_set_locale (void)
|
|
{
|
|
if (!setlocale (LC_ALL, ""))
|
|
g_warning ("locale not supported by C library");
|
|
|
|
return g_win32_getlocale ();
|
|
}
|
|
|
|
void
|
|
gdk_im_begin (GdkIC *ic, GdkWindow* window)
|
|
{
|
|
}
|
|
|
|
void
|
|
gdk_im_end (void)
|
|
{
|
|
}
|
|
|
|
GdkIMStyle
|
|
gdk_im_decide_style (GdkIMStyle supported_style)
|
|
{
|
|
return GDK_IM_PREEDIT_NONE | GDK_IM_STATUS_NONE;
|
|
}
|
|
|
|
GdkIMStyle
|
|
gdk_im_set_best_style (GdkIMStyle style)
|
|
{
|
|
return GDK_IM_PREEDIT_NONE | GDK_IM_STATUS_NONE;
|
|
}
|
|
|
|
gint
|
|
gdk_im_ready (void)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
GdkIC *
|
|
gdk_ic_new (GdkICAttr *attr, GdkICAttributesType mask)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
void
|
|
gdk_ic_destroy (GdkIC *ic)
|
|
{
|
|
}
|
|
|
|
GdkIMStyle
|
|
gdk_ic_get_style (GdkIC *ic)
|
|
{
|
|
return GDK_IM_PREEDIT_NONE | GDK_IM_STATUS_NONE;
|
|
}
|
|
|
|
void
|
|
gdk_ic_set_values (GdkIC *ic, ...)
|
|
{
|
|
}
|
|
|
|
void
|
|
gdk_ic_get_values (GdkIC *ic, ...)
|
|
{
|
|
}
|
|
|
|
GdkICAttributesType
|
|
gdk_ic_set_attr (GdkIC *ic, GdkICAttr *attr, GdkICAttributesType mask)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
GdkICAttributesType
|
|
gdk_ic_get_attr (GdkIC *ic, GdkICAttr *attr, GdkICAttributesType mask)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
GdkEventMask
|
|
gdk_ic_get_events (GdkIC *ic)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* gdk_wcstombs
|
|
*
|
|
* Returns a multi-byte string converted from the specified array
|
|
* of wide characters. The string is newly allocated. The array of
|
|
* wide characters must be null-terminated. If the conversion is
|
|
* failed, it returns NULL.
|
|
*
|
|
* On Win32, we always use UTF-8.
|
|
*/
|
|
gchar *
|
|
gdk_wcstombs (const GdkWChar *src)
|
|
{
|
|
gint len;
|
|
const GdkWChar *wcp;
|
|
guchar *mbstr, *bp;
|
|
|
|
wcp = src;
|
|
len = 0;
|
|
while (*wcp)
|
|
{
|
|
const GdkWChar c = *wcp++;
|
|
|
|
if (c < 0x80)
|
|
len += 1;
|
|
else if (c < 0x800)
|
|
len += 2;
|
|
else if (c < 0x10000)
|
|
len += 3;
|
|
else if (c < 0x200000)
|
|
len += 4;
|
|
else if (c < 0x4000000)
|
|
len += 5;
|
|
else
|
|
len += 6;
|
|
}
|
|
|
|
mbstr = g_malloc (len + 1);
|
|
|
|
wcp = src;
|
|
bp = mbstr;
|
|
while (*wcp)
|
|
{
|
|
int first;
|
|
int i;
|
|
GdkWChar c = *wcp++;
|
|
|
|
if (c < 0x80)
|
|
{
|
|
first = 0;
|
|
len = 1;
|
|
}
|
|
else if (c < 0x800)
|
|
{
|
|
first = 0xc0;
|
|
len = 2;
|
|
}
|
|
else if (c < 0x10000)
|
|
{
|
|
first = 0xe0;
|
|
len = 3;
|
|
}
|
|
else if (c < 0x200000)
|
|
{
|
|
first = 0xf0;
|
|
len = 4;
|
|
}
|
|
else if (c < 0x4000000)
|
|
{
|
|
first = 0xf8;
|
|
len = 5;
|
|
}
|
|
else
|
|
{
|
|
first = 0xfc;
|
|
len = 6;
|
|
}
|
|
|
|
/* Woo-hoo! */
|
|
switch (len)
|
|
{
|
|
case 6: bp[5] = (c & 0x3f) | 0x80; c >>= 6; /* Fall through */
|
|
case 5: bp[4] = (c & 0x3f) | 0x80; c >>= 6; /* Fall through */
|
|
case 4: bp[3] = (c & 0x3f) | 0x80; c >>= 6; /* Fall through */
|
|
case 3: bp[2] = (c & 0x3f) | 0x80; c >>= 6; /* Fall through */
|
|
case 2: bp[1] = (c & 0x3f) | 0x80; c >>= 6; /* Fall through */
|
|
case 1: bp[0] = c | first;
|
|
}
|
|
|
|
bp += len;
|
|
}
|
|
*bp = 0;
|
|
return mbstr;
|
|
}
|
|
|
|
|
|
/*
|
|
* gdk_mbstowcs
|
|
*
|
|
* Converts the specified string into GDK wide characters, and,
|
|
* returns the number of wide characters written. The string 'src'
|
|
* must be null-terminated. If the conversion is failed, it returns
|
|
* -1.
|
|
*
|
|
* On Win32, the string is assumed to be in UTF-8. Also note that
|
|
* GdkWChar is 32 bits, while wchar_t, and the wide characters the
|
|
* Windows API uses, are 16 bits!
|
|
*/
|
|
|
|
/* First a helper function for not zero-terminated strings */
|
|
gint
|
|
gdk_nmbstowcs (GdkWChar *dest,
|
|
const gchar *src,
|
|
gint src_len,
|
|
gint dest_max)
|
|
{
|
|
guchar *cp, *end;
|
|
gint n;
|
|
|
|
cp = (guchar *) src;
|
|
end = cp + src_len;
|
|
n = 0;
|
|
while (cp != end && dest != dest + dest_max)
|
|
{
|
|
gint i, mask = 0, len;
|
|
guchar c = *cp;
|
|
|
|
if (c < 0x80)
|
|
{
|
|
len = 1;
|
|
mask = 0x7f;
|
|
}
|
|
else if ((c & 0xe0) == 0xc0)
|
|
{
|
|
len = 2;
|
|
mask = 0x1f;
|
|
}
|
|
else if ((c & 0xf0) == 0xe0)
|
|
{
|
|
len = 3;
|
|
mask = 0x0f;
|
|
}
|
|
else if ((c & 0xf8) == 0xf0)
|
|
{
|
|
len = 4;
|
|
mask = 0x07;
|
|
}
|
|
else if ((c & 0xfc) == 0xf8)
|
|
{
|
|
len = 5;
|
|
mask = 0x03;
|
|
}
|
|
else if ((c & 0xfc) == 0xfc)
|
|
{
|
|
len = 6;
|
|
mask = 0x01;
|
|
}
|
|
else
|
|
return -1;
|
|
|
|
if (cp + len > end)
|
|
return -1;
|
|
|
|
*dest = (cp[0] & mask);
|
|
for (i = 1; i < len; i++)
|
|
{
|
|
if ((cp[i] & 0xc0) != 0x80)
|
|
return -1;
|
|
*dest <<= 6;
|
|
*dest |= (cp[i] & 0x3f);
|
|
}
|
|
if (*dest == -1)
|
|
return -1;
|
|
|
|
cp += len;
|
|
dest++;
|
|
n++;
|
|
}
|
|
if (cp != end)
|
|
return -1;
|
|
|
|
return n;
|
|
}
|
|
|
|
gint
|
|
gdk_mbstowcs (GdkWChar *dest,
|
|
const gchar *src,
|
|
gint dest_max)
|
|
{
|
|
return gdk_nmbstowcs (dest, src, strlen (src), dest_max);
|
|
}
|
|
|
|
|
|
/* A version that converts to wchar_t wide chars */
|
|
|
|
gint
|
|
gdk_nmbstowchar_ts (wchar_t *dest,
|
|
const gchar *src,
|
|
gint src_len,
|
|
gint dest_max)
|
|
{
|
|
wchar_t *wcp;
|
|
guchar *cp, *end;
|
|
gint n;
|
|
|
|
wcp = dest;
|
|
cp = (guchar *) src;
|
|
end = cp + src_len;
|
|
n = 0;
|
|
while (cp != end && wcp != dest + dest_max)
|
|
{
|
|
gint i, mask = 0, len;
|
|
guchar c = *cp;
|
|
|
|
if (c < 0x80)
|
|
{
|
|
len = 1;
|
|
mask = 0x7f;
|
|
}
|
|
else if ((c & 0xe0) == 0xc0)
|
|
{
|
|
len = 2;
|
|
mask = 0x1f;
|
|
}
|
|
else if ((c & 0xf0) == 0xe0)
|
|
{
|
|
len = 3;
|
|
mask = 0x0f;
|
|
}
|
|
else /* Other lengths are not possible with 16-bit wchar_t! */
|
|
return -1;
|
|
|
|
if (cp + len > end)
|
|
return -1;
|
|
|
|
*wcp = (cp[0] & mask);
|
|
for (i = 1; i < len; i++)
|
|
{
|
|
if ((cp[i] & 0xc0) != 0x80)
|
|
return -1;
|
|
*wcp <<= 6;
|
|
*wcp |= (cp[i] & 0x3f);
|
|
}
|
|
if (*wcp == 0xFFFF)
|
|
return -1;
|
|
|
|
cp += len;
|
|
wcp++;
|
|
n++;
|
|
}
|
|
if (cp != end)
|
|
return -1;
|
|
|
|
return n;
|
|
}
|