Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Added semicolon to macro in list.h - I just read that

Browse Source 
Vadim doesn't want it there - oh well.
 Added check for XKBext.h
 Made BMP loader BIGENDIAN safe.


git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@2670 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Robert Roebling
1999-06-04 22:53:14 +00:00
parent bcd2b961ff
commit 279338910f
5 changed files with 142 additions and 119 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
configure.in
View File

@@ -1015,6 +1015,8 @@ dnl defines HAVE_WCSTR_H
AC_CHECK_HEADERS(wcstr.h) AC_CHECK_HEADERS(wcstr.h)
dnl defines HAVE_FNMATCH_H dnl defines HAVE_FNMATCH_H
AC_CHECK_HEADERS(fnmatch.h) AC_CHECK_HEADERS(fnmatch.h)
dnl defines HAVE_XKBLIB_H
AC_CHECK_HEADERS(X11/XKBlib.h)
dnl --------------------------------------------------------------------------- dnl ---------------------------------------------------------------------------
dnl Checks for typedefs dnl Checks for typedefs
@@ -1961,6 +1963,7 @@ AC_OUTPUT([
samples/splitter/Makefile samples/splitter/Makefile
samples/tab/Makefile samples/tab/Makefile
samples/taskbar/Makefile samples/taskbar/Makefile
samples/text/Makefile
samples/thread/Makefile samples/thread/Makefile
samples/toolbar/Makefile samples/toolbar/Makefile
samples/treectrl/Makefile samples/treectrl/Makefile

2
include/wx/list.h
View File

@@ -438,7 +438,7 @@ private:
(nodetype *)prev, (nodetype *)next, \ (nodetype *)prev, (nodetype *)next, \
(T *)data, key); \ (T *)data, key); \
} \ } \
} };
#define WX_DECLARE_LIST_2(elementtype, listname, nodename) \ #define WX_DECLARE_LIST_2(elementtype, listname, nodename) \
WX_DECLARE_LIST_3(elementtype, elementtype, listname, nodename) WX_DECLARE_LIST_3(elementtype, elementtype, listname, nodename)

194
src/common/image.cpp
View File

@@ -585,22 +585,7 @@ IMPLEMENT_DYNAMIC_CLASS(wxBMPHandler,wxImageHandler)
#endif #endif
#if wxUSE_STREAMS #if wxUSE_STREAMS
bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
{
unsigned char *data, *ptr;
int done, i, bpp, planes, comp, ncolors, line, column,
linesize, linepos, rshift = 0, gshift = 0, bshift = 0;
unsigned char aByte;
short int word;
long int dbuf[4], dword, rmask = 0, gmask = 0, bmask = 0, offset,
size;
off_t start_offset = stream.TellI();
signed char bbuf[4];
struct _cmap
{
unsigned char r, g, b;
}
*cmap = NULL;
#ifndef BI_RGB #ifndef BI_RGB
#define BI_RGB 0 #define BI_RGB 0
#define BI_RLE8 1 #define BI_RLE8 1
@@ -611,23 +596,37 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
#define BI_BITFIELDS 3 #define BI_BITFIELDS 3
#endif #endif
#define poffset (line * width * 3 + column * 3)
bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
{
int rshift = 0, gshift = 0, bshift = 0;
wxUint8 aByte;
wxUint16 aWord;
wxInt32 dbuf[4], aDword,
rmask = 0, gmask = 0, bmask = 0;
wxInt8 bbuf[4];
struct _cmap {
unsigned char r, g, b;
} *cmap = NULL;
off_t start_offset = stream.TellI();
image->Destroy(); image->Destroy();
done = 0;
/* /*
* Reading the bmp header * Read the BMP header
*/ */
stream.Read(&bbuf, 2); stream.Read( &bbuf, 2 );
stream.Read( dbuf, 4 * 4 );
stream.Read(dbuf, 4 * 4); wxInt32 size = wxINT32_SWAP_FROM_LE( dbuf[0] );
wxInt32 offset = wxINT32_SWAP_FROM_LE( dbuf[2] );
size = dbuf[0];
offset = dbuf[2];
stream.Read(dbuf, 4 * 2); stream.Read(dbuf, 4 * 2);
int width = (int)dbuf[0]; int width = (int)wxINT32_SWAP_FROM_LE( dbuf[0] );
int height = (int)dbuf[1]; int height = (int)wxINT32_SWAP_FROM_LE( dbuf[1] );
if (width > 32767) if (width > 32767)
{ {
wxLogError( _T("Image width > 32767 pixels for file.") ); wxLogError( _T("Image width > 32767 pixels for file.") );
@@ -638,28 +637,36 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
wxLogError( _T("Image height > 32767 pixels for file.") ); wxLogError( _T("Image height > 32767 pixels for file.") );
return FALSE; return FALSE;
} }
stream.Read(&word, 2);
planes = (int)word; stream.Read( &aWord, 2 );
stream.Read(&word, 2); /*
bpp = (int)word; TODO
int planes = (int)wxUINT16_SWAP_FROM_LE( aWord );
*/
stream.Read( &aWord, 2 );
int bpp = (int)wxUINT16_SWAP_FROM_LE( aWord );
if (bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32) if (bpp != 1 && bpp != 4 && bpp != 8 && bpp != 16 && bpp != 24 && bpp != 32)
{ {
wxLogError( _T("unknown bitdepth in file.") ); wxLogError( _T("unknown bitdepth in file.") );
return FALSE; return FALSE;
} }
stream.Read(dbuf, 4 * 4);
comp = (int)dbuf[0]; stream.Read( dbuf, 4 * 4 );
int comp = (int)wxINT32_SWAP_FROM_LE( dbuf[0] );
if (comp != BI_RGB && comp != BI_RLE4 && comp != BI_RLE8 && comp != BI_BITFIELDS) if (comp != BI_RGB && comp != BI_RLE4 && comp != BI_RLE8 && comp != BI_BITFIELDS)
{ {
wxLogError( _T("unknown encoding in Windows BMP file.") ); wxLogError( _T("unknown encoding in Windows BMP file.") );
return FALSE; return FALSE;
} }
stream.Read(dbuf, 4 * 2);
ncolors = (int)dbuf[0]; stream.Read( dbuf, 4 * 2 );
int ncolors = (int)wxINT32_SWAP_FROM_LE( dbuf[0] );
if (ncolors == 0) if (ncolors == 0)
ncolors = 1 << bpp; ncolors = 1 << bpp;
/* some more sanity checks */ /* some more sanity checks */
if (((comp == BI_RLE4) && (bpp != 4)) || ((comp == BI_RLE8) && (bpp != 8)) || ((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32))) if (((comp == BI_RLE4) && (bpp != 4)) ||
((comp == BI_RLE8) && (bpp != 8)) ||
((comp == BI_BITFIELDS) && (bpp != 16 && bpp != 32)))
{ {
wxLogError( _T("encoding of BMP doesn't match bitdepth.") ); wxLogError( _T("encoding of BMP doesn't match bitdepth.") );
return FALSE; return FALSE;
@@ -667,7 +674,6 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
if (bpp < 16) if (bpp < 16)
{ {
cmap = (struct _cmap *)malloc(sizeof(struct _cmap) * ncolors); cmap = (struct _cmap *)malloc(sizeof(struct _cmap) * ncolors);
if (!cmap) if (!cmap)
{ {
wxLogError( _T("Cannot allocate RAM for color map in BMP file.") ); wxLogError( _T("Cannot allocate RAM for color map in BMP file.") );
@@ -678,7 +684,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
cmap = NULL; cmap = NULL;
image->Create( width, height ); image->Create( width, height );
ptr = image->GetData(); unsigned char *ptr = image->GetData();
if (!ptr) if (!ptr)
{ {
wxLogError( _T("Cannot allocate RAM for RGB data in file.") ); wxLogError( _T("Cannot allocate RAM for RGB data in file.") );
@@ -688,28 +694,27 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
} }
/* /*
* Reading the palette, if it exists. * Reading the palette, if it exists.
*/ */
if (bpp < 16 && ncolors != 0) if (bpp < 16 && ncolors != 0)
{ {
for (i = 0; i < ncolors; i++) for (int j = 0; j < ncolors; j++)
{ {
stream.Read(bbuf, 4); stream.Read( bbuf, 4 );
cmap[i].b = bbuf[0]; cmap[j].b = bbuf[0];
cmap[i].g = bbuf[1]; cmap[j].g = bbuf[1];
cmap[i].r = bbuf[2]; cmap[j].r = bbuf[2];
} }
} }
else if (bpp == 16 || bpp == 32) else if (bpp == 16 || bpp == 32)
{ {
if (comp == BI_BITFIELDS) if (comp == BI_BITFIELDS)
{ {
int bit = 0; int bit = 0;
stream.Read( dbuf, 4 * 3 );
stream.Read(dbuf, 4 * 3); bmask = wxINT32_SWAP_FROM_LE( dbuf[0] );
bmask = dbuf[0]; gmask = wxINT32_SWAP_FROM_LE( dbuf[1] );
gmask = dbuf[1]; rmask = wxINT32_SWAP_FROM_LE( dbuf[2] );
rmask = dbuf[2];
/* find shift amount.. ugly, but i can't think of a better way */ /* find shift amount.. ugly, but i can't think of a better way */
for (bit = 0; bit < bpp; bit++) for (bit = 0; bit < bpp; bit++)
{ {
@@ -742,15 +747,15 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
} }
/* /*
* Reading the image data * Reading the image data
*/ */
stream.SeekI(start_offset + offset); stream.SeekI( start_offset + offset );
data = ptr; unsigned char *data = ptr;
/* set the whole image to the background color */ /* set the whole image to the background color */
if (bpp < 16 && (comp == BI_RLE4 || comp == BI_RLE8)) if (bpp < 16 && (comp == BI_RLE4 || comp == BI_RLE8))
{ {
for (i = 0; i < width * height; i++) for (int i = 0; i < width * height; i++)
{ {
*ptr++ = cmap[0].r; *ptr++ = cmap[0].r;
*ptr++ = cmap[0].g; *ptr++ = cmap[0].g;
@@ -758,30 +763,25 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
} }
ptr = data; ptr = data;
} }
line = 0;
column = 0; int line = 0;
#define poffset (line * width * 3 + column * 3) int column = 0;
int linesize = ((width * bpp + 31) / 32) * 4;
/* /* BMPs are stored upside down */
* BMPs are stored upside down... hmmmmmmmmmm.... for (line = (height - 1); line >= 0; line--)
*/
linesize = ((width * bpp + 31) / 32) * 4;
for (line = (height - 1); line >= 0; line--)
{ {
linepos = 0; int linepos = 0;
for (column = 0; column < width;) for (column = 0; column < width;)
{ {
if (bpp < 16) if (bpp < 16)
{ {
int index; int index = 0;
linepos++; linepos++;
aByte = stream.GetC(); aByte = stream.GetC();
if (bpp == 1) if (bpp == 1)
{ {
int bit = 0; int bit = 0;
for (bit = 0; bit < 8; bit++) for (bit = 0; bit < 8; bit++)
{ {
index = ((aByte & (0x80 >> bit)) ? 1 : 0); index = ((aByte & (0x80 >> bit)) ? 1 : 0);
@@ -795,15 +795,14 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
{ {
if (comp == BI_RLE4) if (comp == BI_RLE4)
{ {
wxLogError( _T("can't deal with 4bit encoded yet.") ); wxLogError( _T("Can't deal with 4bit encoded yet.") );
image->Destroy(); image->Destroy();
free(cmap); free(cmap);
return FALSE; return FALSE;
} }
else else
{ {
int nibble = 0; int nibble = 0;
for (nibble = 0; nibble < 2; nibble++) for (nibble = 0; nibble < 2; nibble++)
{ {
index = ((aByte & (0xF0 >> nibble * 4)) >> (!nibble * 4)); index = ((aByte & (0xF0 >> nibble * 4)) >> (!nibble * 4));
@@ -820,15 +819,14 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
{ {
if (comp == BI_RLE8) if (comp == BI_RLE8)
{ {
unsigned char first; unsigned char first;
first = aByte; first = aByte;
aByte = stream.GetC(); aByte = stream.GetC();
if (first == 0) if (first == 0)
{ {
if (aByte == 0) if (aByte == 0)
{ {
/* column = width; */ /* column = width; */
} }
else if (aByte == 1) else if (aByte == 1)
{ {
@@ -845,13 +843,12 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
} }
else else
{ {
int absolute = aByte; int absolute = aByte;
for (int k = 0; k < absolute; k++)
for (i = 0; i < absolute; i++)
{ {
linepos++; linepos++;
aByte = stream.GetC(); aByte = stream.GetC();
ptr[poffset] = cmap[aByte].r; ptr[poffset ] = cmap[aByte].r;
ptr[poffset + 1] = cmap[aByte].g; ptr[poffset + 1] = cmap[aByte].g;
ptr[poffset + 2] = cmap[aByte].b; ptr[poffset + 2] = cmap[aByte].b;
column++; column++;
@@ -862,9 +859,9 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
} }
else else
{ {
for (i = 0; i < first; i++) for (int l = 0; l < first; l++)
{ {
ptr[poffset] = cmap[aByte].r; ptr[poffset ] = cmap[aByte].r;
ptr[poffset + 1] = cmap[aByte].g; ptr[poffset + 1] = cmap[aByte].g;
ptr[poffset + 2] = cmap[aByte].b; ptr[poffset + 2] = cmap[aByte].b;
column++; column++;
@@ -874,7 +871,7 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
} }
else else
{ {
ptr[poffset] = cmap[aByte].r; ptr[poffset ] = cmap[aByte].r;
ptr[poffset + 1] = cmap[aByte].g; ptr[poffset + 1] = cmap[aByte].g;
ptr[poffset + 2] = cmap[aByte].b; ptr[poffset + 2] = cmap[aByte].b;
column++; column++;
@@ -884,51 +881,52 @@ bool wxBMPHandler::LoadFile( wxImage *image, wxInputStream& stream )
} }
else if (bpp == 24) else if (bpp == 24)
{ {
stream.Read(&bbuf, 3); stream.Read( &bbuf, 3 );
linepos += 3; linepos += 3;
ptr[poffset] = (unsigned char)bbuf[2]; ptr[poffset ] = (unsigned char)bbuf[2];
ptr[poffset + 1] = (unsigned char)bbuf[1]; ptr[poffset + 1] = (unsigned char)bbuf[1];
ptr[poffset + 2] = (unsigned char)bbuf[0]; ptr[poffset + 2] = (unsigned char)bbuf[0];
column++; column++;
} }
else if (bpp == 16) else if (bpp == 16)
{ {
unsigned char temp; unsigned char temp;
stream.Read( &aWord, 2 );
stream.Read(&word, 2); aWord = wxUINT16_SWAP_FROM_LE( aWord );
linepos += 2; linepos += 2;
temp = (word & rmask) >> rshift; temp = (aWord & rmask) >> rshift;
ptr[poffset] = temp; ptr[poffset] = temp;
temp = (word & gmask) >> gshift; temp = (aWord & gmask) >> gshift;
ptr[poffset + 1] = temp; ptr[poffset + 1] = temp;
temp = (word & bmask) >> gshift; temp = (aWord & bmask) >> gshift;
ptr[poffset + 2] = temp; ptr[poffset + 2] = temp;
column++; column++;
} }
else else
{ {
unsigned char temp; unsigned char temp;
stream.Read( &aDword, 4 );
stream.Read(&dword, 4); aDword = wxINT32_SWAP_FROM_LE( aDword );
linepos += 4; linepos += 4;
temp = (dword & rmask) >> rshift; temp = (aDword & rmask) >> rshift;
ptr[poffset] = temp; ptr[poffset] = temp;
temp = (dword & gmask) >> gshift; temp = (aDword & gmask) >> gshift;
ptr[poffset + 1] = temp; ptr[poffset + 1] = temp;
temp = (dword & bmask) >> bshift; temp = (aDword & bmask) >> bshift;
ptr[poffset + 2] = temp; ptr[poffset + 2] = temp;
column++; column++;
} }
} }
while ((linepos < linesize) && (comp != 1) && (comp != 2)) while ((linepos < linesize) && (comp != 1) && (comp != 2))
{ {
stream.Read(&aByte, 1); stream.Read( &aByte, 1 );
linepos += 1; linepos += 1;
if (stream.LastError() != wxStream_NOERROR) if (stream.LastError() != wxStream_NOERROR)
break; break;
} }
} }
if (cmap) free(cmap); if (cmap)
free(cmap);
image->SetMask( FALSE ); image->SetMask( FALSE );

31
src/gtk/utilsgtk.cpp
View File

@@ -36,15 +36,19 @@
#include <gtk/gtkfeatures.h> #include <gtk/gtkfeatures.h>
#include <gdk/gdkx.h> #include <gdk/gdkx.h>
#ifdef __HPUX__ #ifdef HAVE_X11_XKBLIB_H
// under HP-UX XKBlib.h defines structures with field named "explicit" - #ifdef __HPUX__
// which is, of course, an error for a C++ compiler /* under HP-UX XKBlib.h defines structures with field named "explicit" -
* which is, of course, an error for a C++ compiler */
#define explicit __wx_explicit #define explicit __wx_explicit
#endif #endif
#include "X11/XKBlib.h"
#ifdef __HPUX__ #include "X11/XKBlib.h"
#ifdef __HPUX__
#undef explicit #undef explicit
#endif // __HPUX__ #endif // __HPUX__
#endif // HAVE_X11_XKBLIB_H
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// misc. // misc.
@@ -55,14 +59,21 @@ void wxBell()
gdk_beep(); gdk_beep();
} }
// Synthesize KeyUp events holding down a key and producing /* Don't synthesize KeyUp events holding down a key and producing
// KeyDown events with autorepeat. KeyDown events with autorepeat. */
#ifdef HAVE_X11_XKBLIB_H
bool wxSetDetectableAutoRepeat( bool flag ) bool wxSetDetectableAutoRepeat( bool flag )
{ {
Bool result; Bool result;
XkbSetDetectableAutoRepeat( GDK_DISPLAY(), flag, &result ); XkbSetDetectableAutoRepeat( GDK_DISPLAY(), flag, &result );
return result; // true if keyboard hardware supports this mode return result; /* TRUE if keyboard hardware supports this mode */
} }
#else
bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
{
return FALSE;
}
#endif
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// display characterstics // display characterstics

31
src/gtk1/utilsgtk.cpp
View File

@@ -36,15 +36,19 @@
#include <gtk/gtkfeatures.h> #include <gtk/gtkfeatures.h>
#include <gdk/gdkx.h> #include <gdk/gdkx.h>
#ifdef __HPUX__ #ifdef HAVE_X11_XKBLIB_H
// under HP-UX XKBlib.h defines structures with field named "explicit" - #ifdef __HPUX__
// which is, of course, an error for a C++ compiler /* under HP-UX XKBlib.h defines structures with field named "explicit" -
* which is, of course, an error for a C++ compiler */
#define explicit __wx_explicit #define explicit __wx_explicit
#endif #endif
#include "X11/XKBlib.h"
#ifdef __HPUX__ #include "X11/XKBlib.h"
#ifdef __HPUX__
#undef explicit #undef explicit
#endif // __HPUX__ #endif // __HPUX__
#endif // HAVE_X11_XKBLIB_H
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// misc. // misc.
@@ -55,14 +59,21 @@ void wxBell()
gdk_beep(); gdk_beep();
} }
// Synthesize KeyUp events holding down a key and producing /* Don't synthesize KeyUp events holding down a key and producing
// KeyDown events with autorepeat. KeyDown events with autorepeat. */
#ifdef HAVE_X11_XKBLIB_H
bool wxSetDetectableAutoRepeat( bool flag ) bool wxSetDetectableAutoRepeat( bool flag )
{ {
Bool result; Bool result;
XkbSetDetectableAutoRepeat( GDK_DISPLAY(), flag, &result ); XkbSetDetectableAutoRepeat( GDK_DISPLAY(), flag, &result );
return result; // true if keyboard hardware supports this mode return result; /* TRUE if keyboard hardware supports this mode */
} }
#else
bool wxSetDetectableAutoRepeat( bool WXUNUSED(flag) )
{
return FALSE;
}
#endif
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// display characterstics // display characterstics