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

_MSC_VER => __VISUALC__ change

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@1580 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
Vadim Zeitlin
1999-02-03 16:48:12 +00:00
parent b7f4714a25
commit 3f4a0c5be3
42 changed files with 1621 additions and 1736 deletions
Download Patch File Download Diff File Expand all files Collapse all files

196
include/wx/defs.h
View File

@@ -6,7 +6,7 @@
// Created: 01/02/97 // Created: 01/02/97
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) // Copyright: (c)
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DEFS_H_ #ifndef _WX_DEFS_H_
@@ -21,27 +21,54 @@
#include "wx/setup.h" #include "wx/setup.h"
#include "wx/version.h" #include "wx/version.h"
// Helps SGI compilation, apparently // ----------------------------------------------------------------------------
#if defined(__SGI__) // compiler and OS identification
#if defined(__GNUG__) // ----------------------------------------------------------------------------
#define __need_wchar_t
#else
/* Note I use the term __SGI_CC__ for both cc and CC, its not a good idea to
* mix gcc and cc/CC, the name mangling is different */
#define __SGI_CC__
#endif
#endif
#if defined(sun) || defined(__SUN__) // OS
# if !defined(__GNUG__) #if defined(__HPUX__) || defined(____SVR4____) || defined(__LINUX__) || defined(__sgi ) || defined(__unix__)
# ifndef __SUNCC__ #ifndef __UNIX__
# define __SUNCC__ #define __UNIX__
# endif #endif // Unix
# endif
#endif // Helps SGI compilation, apparently
#ifdef __SGI__
#ifdef __GNUG__
#define __need_wchar_t
#else // !gcc
// Note I use the term __SGI_CC__ for both cc and CC, its not a good
// idea to mix gcc and cc/CC, the name mangling is different
#define __SGI_CC__
#endif // gcc/!gcc
#endif // SGI
#if defined(sun) || defined(__SUN__)
#ifndef __GNUG__
#ifndef __SUNCC__
#define __SUNCC__
#endif // Sun CC
#endif
#endif // Sun
#else // Windows
#ifndef __WINDOWS__
#define __WINDOWS__
#endif // Windows
// define another standard symbol for Microsoft Visual C++: the standard one
// (_MSC_VER) is also defined by Metrowerks compiler
#if defined(_MSC_VER) && !defined(__MWERKS__)
#define __VISUALC__
#elif defined(__BCPLUSPLUS__) && !defined(__BORLANDC__)
#define __BORLANDC__
#elif defined(__WATCOMC__)
//#define __WATCOMC__
#elif defined(__SC__)
#define __SYMANTECC__
#endif // compiler
#endif // OS
// suppress some Visual C++ warnings // suppress some Visual C++ warnings
#ifdef _MSC_VER #ifdef __VISUALC__
# pragma warning(disable:4244) // cobversion from double to float # pragma warning(disable:4244) // cobversion from double to float
# pragma warning(disable:4100) // unreferenced formal parameter # pragma warning(disable:4100) // unreferenced formal parameter
#endif #endif
@@ -124,9 +151,9 @@
typedef unsigned int bool; typedef unsigned int bool;
#elif defined(__SALFORDC__) #elif defined(__SALFORDC__)
typedef unsigned int bool; typedef unsigned int bool;
#elif defined(_MSC_VER) && (_MSC_VER <= 1000) #elif defined(__VISUALC__) && (__VISUALC__ <= 1000)
typedef unsigned int bool; typedef unsigned int bool;
#elif defined(_MSC_VER) && (_MSC_VER == 1020) #elif defined(__VISUALC__) && (__VISUALC__ == 1020)
#define bool unsigned int #define bool unsigned int
#elif defined(__BORLANDC__) && (__BORLANDC__ < 0x500) #elif defined(__BORLANDC__) && (__BORLANDC__ < 0x500)
typedef unsigned int bool; typedef unsigned int bool;
@@ -144,7 +171,7 @@
#endif // Sun CC #endif // Sun CC
#endif #endif
#if ( defined(_MSC_VER) && (_MSC_VER <= 800) ) || defined(__GNUWIN32__) || (defined(__BORLANDC__) && defined(__WIN16__)) || defined(__SC__) || defined(__SALFORDC__) #if ( defined(__VISUALC__) && (__VISUALC__ <= 800) ) || defined(__GNUWIN32__) || (defined(__BORLANDC__) && defined(__WIN16__)) || defined(__SC__) || defined(__SALFORDC__)
// Not a good idea, because later system files (e.g. windows.h) // Not a good idea, because later system files (e.g. windows.h)
// may try to define it. Use wxByte instead. // may try to define it. Use wxByte instead.
// #define byte unsigned char // #define byte unsigned char
@@ -281,30 +308,6 @@ enum ErrCode
WXDLLEXPORT_DATA(extern const bool) wxTrue; WXDLLEXPORT_DATA(extern const bool) wxTrue;
WXDLLEXPORT_DATA(extern const bool) wxFalse; WXDLLEXPORT_DATA(extern const bool) wxFalse;
// ----------------------------------------------------------------------------
// compiler and OS identification
// ----------------------------------------------------------------------------
// OS
#if defined(__HPUX__) || defined(____SVR4____) || defined(__LINUX__) || defined(__sgi ) || defined(__unix__)
#ifndef __UNIX__
#define __UNIX__
#endif
#endif
#ifndef __UNIX__ // Windows
#if defined(_MSC_VER)
#define __VISUALC__
#elif defined(__BCPLUSPLUS__) && !defined(__BORLANDC__)
#define __BORLANDC__
#elif defined(__WATCOMC__)
//#define __WATCOMC__
#elif defined(__SC__)
#define __SYMANTECC__
#endif // compiler
#endif // OS
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// compiler specific settings // compiler specific settings
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -315,25 +318,18 @@ WXDLLEXPORT_DATA(extern const bool) wxFalse;
#pragma warning(disable: 4514) // unreferenced inline func has been removed #pragma warning(disable: 4514) // unreferenced inline func has been removed
/* /*
you might be tempted to disable this one also: triggered by CHECK and FAIL you might be tempted to disable this one also: triggered by CHECK and FAIL
macros in debug.h, but it's, overall, is a rather useful one, so I leave it macros in debug.h, but it's, overall, a rather useful one, so I leave it and
and will try to find some way to disable this warning just for CHECK/FAIL. will try to find some way to disable this warning just for CHECK/FAIL. Anyone?
Anyone?
*/ */
#pragma warning(disable: 4127) // conditional expression is constant #pragma warning(disable: 4127) // conditional expression is constant
#endif // VC++ #endif // VC++
#if _MSC_VER > 1010 #if defined(__MWERKS__)
#undef try #undef try
#undef except #undef except
#undef finally #undef finally
#define except(x) catch(...) #define except(x) catch(...)
#elif defined(__MWERKS__) #endif // Metrowerks
#undef try
#undef except
#undef finally
#define except(x) catch(...)
#endif
// where should i put this? we need to make sure of this as it breaks // where should i put this? we need to make sure of this as it breaks
// the <iostream> code. // the <iostream> code.
@@ -402,20 +398,20 @@ typedef void (*wxFunction) (wxObject&, wxEvent&);
/* /*
* Frame/dialog style flags * Frame/dialog style flags
*/ */
#define wxSTAY_ON_TOP 0x8000 #define wxSTAY_ON_TOP 0x8000
#define wxICONIZE 0x4000 #define wxICONIZE 0x4000
#define wxMINIMIZE wxICONIZE #define wxMINIMIZE wxICONIZE
#define wxMAXIMIZE 0x2000 #define wxMAXIMIZE 0x2000
#define wxTHICK_FRAME 0x1000 #define wxTHICK_FRAME 0x1000
#define wxSYSTEM_MENU 0x0800 #define wxSYSTEM_MENU 0x0800
#define wxMINIMIZE_BOX 0x0400 #define wxMINIMIZE_BOX 0x0400
#define wxMAXIMIZE_BOX 0x0200 #define wxMAXIMIZE_BOX 0x0200
#define wxTINY_CAPTION_HORIZ 0x0100 #define wxTINY_CAPTION_HORIZ 0x0100
#define wxTINY_CAPTION_VERT 0x0080 #define wxTINY_CAPTION_VERT 0x0080
#define wxRESIZE_BOX wxMAXIMIZE_BOX #define wxRESIZE_BOX wxMAXIMIZE_BOX
#define wxRESIZE_BORDER 0x0040 #define wxRESIZE_BORDER 0x0040
#define wxDIALOG_MODAL 0x0020 #define wxDIALOG_MODAL 0x0020
#define wxDIALOG_MODELESS 0x0000 #define wxDIALOG_MODELESS 0x0000
#define wxDEFAULT_FRAME_STYLE (wxRESIZE_BORDER | wxMINIMIZE_BOX | wxMAXIMIZE_BOX | wxTHICK_FRAME | wxSYSTEM_MENU | wxCAPTION | wxCLIP_CHILDREN) #define wxDEFAULT_FRAME_STYLE (wxRESIZE_BORDER | wxMINIMIZE_BOX | wxMAXIMIZE_BOX | wxTHICK_FRAME | wxSYSTEM_MENU | wxCAPTION | wxCLIP_CHILDREN)
@@ -423,7 +419,7 @@ typedef void (*wxFunction) (wxObject&, wxEvent&);
#define wxDEFAULT_FRAME wxDEFAULT_FRAME_STYLE #define wxDEFAULT_FRAME wxDEFAULT_FRAME_STYLE
#endif #endif
#define wxDEFAULT_DIALOG_STYLE (wxSYSTEM_MENU|wxCAPTION|wxTHICK_FRAME) #define wxDEFAULT_DIALOG_STYLE (wxSYSTEM_MENU|wxCAPTION|wxTHICK_FRAME)
/* /*
* Subwindow style flags * Subwindow style flags
@@ -671,7 +667,7 @@ enum {
wxCROSS_HATCH, wxCROSS_HATCH,
wxHORIZONTAL_HATCH, wxHORIZONTAL_HATCH,
wxVERTICAL_HATCH, wxVERTICAL_HATCH,
#define IS_HATCH(s) ((s)>=wxBDIAGONAL_HATCH && (s)<=wxVERTICAL_HATCH) #define IS_HATCH(s) ((s)>=wxBDIAGONAL_HATCH && (s)<=wxVERTICAL_HATCH)
wxJOIN_BEVEL = 120, wxJOIN_BEVEL = 120,
wxJOIN_MITER, wxJOIN_MITER,
@@ -715,10 +711,10 @@ typedef enum
#define wxWINDING_RULE 2 #define wxWINDING_RULE 2
// ToolPanel in wxFrame // ToolPanel in wxFrame
#define wxTOOL_TOP 1 #define wxTOOL_TOP 1
#define wxTOOL_BOTTOM 2 #define wxTOOL_BOTTOM 2
#define wxTOOL_LEFT 3 #define wxTOOL_LEFT 3
#define wxTOOL_RIGHT 4 #define wxTOOL_RIGHT 4
// Dialog specifiers/return values // Dialog specifiers/return values
@@ -788,9 +784,9 @@ enum wxKeyCode
{ {
WXK_BACK = 8, WXK_BACK = 8,
WXK_TAB = 9, WXK_TAB = 9,
WXK_RETURN = 13, WXK_RETURN = 13,
WXK_ESCAPE = 27, WXK_ESCAPE = 27,
WXK_SPACE = 32, WXK_SPACE = 32,
WXK_DELETE = 127, WXK_DELETE = 127,
WXK_START = 300, WXK_START = 300,
@@ -869,22 +865,22 @@ enum wxKeyCode
enum enum
{ {
wxUNKNOWN_PLATFORM, wxUNKNOWN_PLATFORM,
wxCURSES, /* Text-only CURSES */ wxCURSES, // Text-only CURSES
wxXVIEW_X, /* Sun's XView OpenLOOK toolkit */ wxXVIEW_X, // Sun's XView OpenLOOK toolkit
wxMOTIF_X, /* OSF Motif 1.x.x */ wxMOTIF_X, // OSF Motif 1.x.x
wxCOSE_X, /* OSF Common Desktop Environment */ wxCOSE_X, // OSF Common Desktop Environment
wxNEXTSTEP, /* NeXTStep */ wxNEXTSTEP, // NeXTStep
wxMACINTOSH, /* Apple System 7 */ wxMACINTOSH, // Apple System 7
wxGTK, /* GTK */ wxGTK, // GTK
wxQT, /* Qt */ wxQT, // Qt
wxGEOS, /* GEOS */ wxGEOS, // GEOS
wxOS2_PM, /* OS/2 Workplace */ wxOS2_PM, // OS/2 Workplace
wxWINDOWS, /* Windows or WfW */ wxWINDOWS, // Windows or WfW
wxPENWINDOWS, /* Windows for Pen Computing */ wxPENWINDOWS, // Windows for Pen Computing
wxWINDOWS_NT, /* Windows NT */ wxWINDOWS_NT, // Windows NT
wxWIN32S, /* Windows 32S API */ wxWIN32S, // Windows 32S API
wxWIN95, /* Windows 95 */ wxWIN95, // Windows 95
wxWIN386 /* Watcom 32-bit supervisor modus */ wxWIN386 // Watcom 32-bit supervisor modus
}; };
/* Printing */ /* Printing */

4
include/wx/docview.h
View File

@@ -6,7 +6,7 @@
// Created: 01/02/97 // Created: 01/02/97
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) // Copyright: (c)
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_DOCH__ #ifndef _WX_DOCH__
@@ -44,7 +44,7 @@ class WXDLLEXPORT wxConfigBase;
#else #else
# include <istream> # include <istream>
# include <ostream> # include <ostream>
# ifdef _MSC_VER # ifdef __VISUALC__
using namespace std; using namespace std;
# endif # endif
#endif #endif

16
include/wx/filefn.h
View File

@@ -29,16 +29,12 @@
typedef long off_t; typedef long off_t;
#endif #endif
#ifdef _MSC_VER #if defined(__VISUALC__) || defined(__MWERKS__)
#define off_t _off_t typedef _off_t off_t;
#endif #elif defined(__BORLANDC__) && defined(__WIN16__)
typedef long off_t;
#if defined(__BORLANDC__) && defined(__WIN16__) #elif defined(__SC__)
typedef long off_t; typedef long off_t;
#endif
#if defined(__SC__)
typedef long off_t;
#endif #endif
const off_t wxInvalidOffset = (off_t)-1; const off_t wxInvalidOffset = (off_t)-1;

20
include/wx/ioswrap.h Normal file
View File

@@ -0,0 +1,20 @@
///////////////////////////////////////////////////////////////////////////////
// Name: ioswrap.h
// Purpose: includes the correct iostream headers for current compiler
// Author: Vadim Zeitlin
// Modified by:
// Created: 03.02.99
// RCS-ID: $Id$
// Copyright: (c) 1998 Vadim Zeitlin <zeitlin@dptmaths.ens-cachan.fr>
// Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////////
#if wxUSE_IOSTREAMH
// N.B. BC++ doesn't have istream.h, ostream.h
# include <iostream.h>
#else
# include <iostream>
# if defined(__VISUALC__) || defined(__MWERKS__)
using namespace std;
# endif
#endif

12
include/wx/log.h
View File

@@ -57,13 +57,13 @@ class WXDLLEXPORT wxLogFrame;
class WXDLLEXPORT wxFrame; class WXDLLEXPORT wxFrame;
#if wxUSE_IOSTREAMH #if wxUSE_IOSTREAMH
// N.B. BC++ doesn't have istream.h, ostream.h // N.B. BC++ doesn't have istream.h, ostream.h
# include <iostream.h> # include <iostream.h>
#else #else
# include <ostream> # include <ostream>
# ifdef _MSC_VER # if defined(__VISUALC__) || defined(__MWERKS__)
using namespace std; using namespace std;
# endif # endif
#endif #endif
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------

30
include/wx/memory.h
View File

@@ -6,7 +6,7 @@
// Created: 29/01/98 // Created: 29/01/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) 1998 Julian Smart // Copyright: (c) 1998 Julian Smart
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_MEMORYH__ #ifndef _WX_MEMORYH__
@@ -29,13 +29,13 @@
#include <stddef.h> #include <stddef.h>
#if wxUSE_IOSTREAMH #if wxUSE_IOSTREAMH
// N.B. BC++ doesn't have istream.h, ostream.h // N.B. BC++ doesn't have istream.h, ostream.h
# include <iostream.h> # include <iostream.h>
#else #else
# include <ostream> # include <ostream>
# ifdef _MSC_VER # if defined(__VISUALC__) || defined(__MWERKS__)
using namespace std; using namespace std;
# endif # endif
#endif #endif
#ifdef __WXDEBUG__ #ifdef __WXDEBUG__
@@ -49,15 +49,15 @@ void wxDebugFree(void * buf, bool isVect = FALSE);
// Undefine temporarily (new is #defined in object.h) because we want to // Undefine temporarily (new is #defined in object.h) because we want to
// declare some new operators. // declare some new operators.
#ifdef new #ifdef new
#undef new #undef new
#endif #endif
#if defined(__SUNCC__) #if defined(__SUNCC__)
#define wxUSE_ARRAY_MEMORY_OPERATORS 0 #define wxUSE_ARRAY_MEMORY_OPERATORS 0
#elif !( defined (_MSC_VER) && (_MSC_VER <= 1020) ) || defined( __MWERKS__) #elif !( defined (__VISUALC__) && (__VISUALC__ <= 1020) ) || defined( __MWERKS__)
#define wxUSE_ARRAY_MEMORY_OPERATORS 1 #define wxUSE_ARRAY_MEMORY_OPERATORS 1
#else #else
#define wxUSE_ARRAY_MEMORY_OPERATORS 0 #define wxUSE_ARRAY_MEMORY_OPERATORS 0
#endif #endif
// Added JACS 25/11/98: needed for some compilers // Added JACS 25/11/98: needed for some compilers
@@ -76,9 +76,9 @@ void operator delete[] (void * buf);
#endif #endif
// VC++ 6.0 // VC++ 6.0
#if _MSC_VER >= 1200 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
void operator delete(void *buf, char*, int); void operator delete(void *buf, char*, int);
void operator delete[](void *buf, char*, int); void operator delete[](void *buf, char*, int);
#endif #endif
#endif #endif

15
include/wx/msw/msvcrt.h
View File

@@ -19,12 +19,14 @@
#ifndef _MSW_MSVCRT_H_ #ifndef _MSW_MSVCRT_H_
#define _MSW_MSVCRT_H_ #define _MSW_MSVCRT_H_
// use debug CRT functions for memory leak detections in VC++ if we're not // use debug CRT functions for memory leak detections in VC++ 5.0+ in debug
// using wxWindows own methods // builds
#if defined(__WXDEBUG__) && defined(_MSC_VER) && !wxUSE_GLOBAL_MEMORY_OPERATORS && !defined(__NO_VC_CRTDBG__) #undef wxUSE_VC_CRTDBG
#define wxUSE_VC_CRTDBG #if defined(__WXDEBUG__) && defined(__VISUALC__) && (__VISUALC__ >= 1000)
#else // it doesn't combine well with wxWin own memory debugging methods
#undef wxUSE_VC_CRTDBG #if !wxUSE_GLOBAL_MEMORY_OPERATORS && !defined(__NO_VC_CRTDBG__)
#define wxUSE_VC_CRTDBG
#endif
#endif #endif
#ifdef wxUSE_VC_CRTDBG #ifdef wxUSE_VC_CRTDBG
@@ -47,3 +49,4 @@
#endif // wxUSE_VC_CRTDBG #endif // wxUSE_VC_CRTDBG
#endif // _MSW_MSVCRT_H_ #endif // _MSW_MSVCRT_H_

10
include/wx/msw/ole/oleutils.h
View File

@@ -121,11 +121,10 @@ bool IsIidFromList(REFIID riid, const IID *aIids[], size_t nCount);
// Debugging support // Debugging support
// ============================================================================ // ============================================================================
#if defined(__WXDEBUG__) && defined(_MSC_VER) && (_MSC_VER > 1000) // VZ: I don't know it's not done for compilers other than VC++ but I leave it
// ---------------------------------------------------------------------------- // as is. Please note, though, that tracing OLE interface calls may be
// // incredibly useful when debugging OLE programs.
// ---------------------------------------------------------------------------- #if defined(__WXDEBUG__) && defined(__VISUALC__) && (__VISUALC__ >= 1000)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// All OLE specific log functions have DebugTrace level (as LogTrace) // All OLE specific log functions have DebugTrace level (as LogTrace)
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
@@ -144,3 +143,4 @@ void wxLogRelease(const char *szInterface, ULONG cRef);
#endif //WXDEBUG #endif //WXDEBUG
#endif //_WX_OLEUTILS_H #endif //_WX_OLEUTILS_H

23
include/wx/object.h
View File

@@ -6,7 +6,7 @@
// Created: 01/02/97 // Created: 01/02/97
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem // Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_OBJECTH__ #ifndef _WX_OBJECTH__
@@ -40,13 +40,13 @@ class WXDLLEXPORT wxHashTable;
class WXDLLEXPORT wxObject_Serialize; class WXDLLEXPORT wxObject_Serialize;
#if wxUSE_IOSTREAMH #if wxUSE_IOSTREAMH
// N.B. BC++ doesn't have istream.h, ostream.h // N.B. BC++ doesn't have istream.h, ostream.h
# include <iostream.h> # include <iostream.h>
#else #else
# include <ostream> # include <ostream>
# ifdef _MSC_VER # if defined(__VISUALC__) || defined(__MWERKS__)
using namespace std; using namespace std;
# endif # endif
#endif #endif
/* /*
@@ -198,13 +198,12 @@ class WXDLLEXPORT wxObject
void operator delete (void * buf); void operator delete (void * buf);
// VC++ 6.0 // VC++ 6.0
#if _MSC_VER >= 1200 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
void operator delete(void *buf, char*, int); void operator delete(void *buf, char*, int);
#endif #endif
// Cause problems for VC++ // Causes problems for VC++
// #ifndef _MSC_VER #if wxUSE_ARRAY_MEMORY_OPERATORS && !defined(__VISUALC__)
#if !defined(_MSC_VER) && wxUSE_ARRAY_MEMORY_OPERATORS
void * operator new[] (size_t size, char * fileName = NULL, int lineNum = 0); void * operator new[] (size_t size, char * fileName = NULL, int lineNum = 0);
void operator delete[] (void * buf); void operator delete[] (void * buf);
#endif #endif
@@ -216,7 +215,7 @@ class WXDLLEXPORT wxObject
#endif #endif
*/ */
#endif #endif // Debug & memory tracing
#if defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT #if defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT
virtual void Dump(ostream& str); virtual void Dump(ostream& str);

34
include/wx/string.h
View File

@@ -16,15 +16,10 @@
#pragma interface "string.h" #pragma interface "string.h"
#endif #endif
/* Dependencies (should be included before this header):
* string.h
* stdio.h
* stdarg.h
* limits.h
*/
#ifdef __WXMAC__ #ifdef __WXMAC__
#include <ctype.h> #include <ctype.h>
#endif #endif
#include <string.h> #include <string.h>
#include <stdio.h> #include <stdio.h>
#include <stdarg.h> #include <stdarg.h>
@@ -32,11 +27,12 @@
#include <stdlib.h> #include <stdlib.h>
#ifndef WX_PRECOMP #ifndef WX_PRECOMP
#include "wx/defs.h" // Robert Roebling #include "wx/defs.h"
#ifdef WXSTRING_IS_WXOBJECT #ifdef WXSTRING_IS_WXOBJECT
#include "wx/object.h" #include "wx/object.h"
#endif #endif
#endif #endif // !PCH
#include "wx/debug.h" #include "wx/debug.h"
@@ -83,7 +79,7 @@ inline size_t WXDLLEXPORT Strlen(const char *psz)
// portable strcasecmp/_stricmp // portable strcasecmp/_stricmp
inline int WXDLLEXPORT Stricmp(const char *psz1, const char *psz2) inline int WXDLLEXPORT Stricmp(const char *psz1, const char *psz2)
{ {
#if defined(_MSC_VER) #if defined(__VISUALC__) || defined(__MWERKS__)
return _stricmp(psz1, psz2); return _stricmp(psz1, psz2);
#elif defined(__SC__) #elif defined(__SC__)
return _stricmp(psz1, psz2); return _stricmp(psz1, psz2);
@@ -645,7 +641,7 @@ public:
size_t find(const wxString& str, size_t nStart = 0) const; size_t find(const wxString& str, size_t nStart = 0) const;
// VC++ 1.5 can't cope with this syntax. // VC++ 1.5 can't cope with this syntax.
#if !(defined(_MSC_VER) && !defined(__WIN32__)) #if !defined(__VISUALC__) || defined(__WIN32__)
// find first n characters of sz // find first n characters of sz
size_t find(const char* sz, size_t nStart = 0, size_t n = npos) const; size_t find(const char* sz, size_t nStart = 0, size_t n = npos) const;
#endif #endif
@@ -661,7 +657,7 @@ public:
size_t rfind(const wxString& str, size_t nStart = npos) const; size_t rfind(const wxString& str, size_t nStart = npos) const;
// VC++ 1.5 can't cope with this syntax. // VC++ 1.5 can't cope with this syntax.
#if ! (defined(_MSC_VER) && !defined(__WIN32__)) #if !defined(__VISUALC__) || defined(__WIN32__)
// as find, but from the end // as find, but from the end
size_t rfind(const char* sz, size_t nStart = npos, size_t rfind(const char* sz, size_t nStart = npos,
size_t n = npos) const; size_t n = npos) const;
@@ -854,19 +850,7 @@ wxString WXDLLEXPORT operator+(const char *psz, const wxString& string);
#ifdef wxSTD_STRING_COMPATIBILITY #ifdef wxSTD_STRING_COMPATIBILITY
// forward declare iostream #include "wx/ioswrap.h"
// Known not to work with wxUSE_IOSTREAMH set to 0, so
// replacing with includes (on advice of ungod@pasdex.com.au)
// class WXDLLEXPORT istream;
#if wxUSE_IOSTREAMH
// N.B. BC++ doesn't have istream.h, ostream.h
#include <iostream.h>
#else
#include <istream>
# ifdef _MSC_VER
using namespace std;
# endif
#endif
WXDLLEXPORT istream& operator>>(istream& is, wxString& str); WXDLLEXPORT istream& operator>>(istream& is, wxString& str);

11
include/wx/utils.h
View File

@@ -6,7 +6,7 @@
// Created: 29/01/98 // Created: 29/01/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) 1998 Julian Smart // Copyright: (c) 1998 Julian Smart
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_UTILSH__ #ifndef _WX_UTILSH__
@@ -23,14 +23,7 @@
#include "wx/filefn.h" #include "wx/filefn.h"
#include "wx/process.h" #include "wx/process.h"
#if wxUSE_IOSTREAMH #include "wx/ioswrap.h"
#include <iostream.h>
#else
#include <iostream>
# ifdef _MSC_VER
using namespace std;
# endif
#endif
#ifdef __X__ #ifdef __X__
#ifndef __VMS__ #ifndef __VMS__

17
include/wx/variant.h
View File

@@ -6,7 +6,7 @@
// Created: 10/09/98 // Created: 10/09/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) // Copyright: (c)
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_VARIANT_H_ #ifndef _WX_VARIANT_H_
@@ -22,18 +22,11 @@
#include "wx/list.h" #include "wx/list.h"
#if wxUSE_TIMEDATE #if wxUSE_TIMEDATE
#include "wx/time.h" #include "wx/time.h"
#include "wx/date.h" #include "wx/date.h"
#endif #endif // time/date
#if wxUSE_IOSTREAMH #include "wx/ioswrap.h"
#include <iostream.h>
#else
#include <iostream>
# ifdef _MSC_VER
using namespace std;
# endif
#endif
/* /*
* wxVariantData stores the actual data in a wxVariant object, * wxVariantData stores the actual data in a wxVariant object,

16
include/wx/wxchar.h
View File

@@ -22,11 +22,11 @@
#endif #endif
// only do Unicode for Windows (VC++), for now // only do Unicode for Windows (VC++), for now
#if defined(_MSC_VER) && defined(__WIN32__) #if defined(__VISUALC__) && defined(__WIN32__)
#include <tchar.h> #include <tchar.h>
typedef _TCHAR wxChar; typedef _TCHAR wxChar;
typedef _TSCHAR wxSChar; typedef _TSCHAR wxSChar;
typedef _TUCHAR wxUChar; typedef _TUCHAR wxUChar;
// ctype.h functions // ctype.h functions
@@ -120,11 +120,11 @@ typedef _TUCHAR wxUChar;
#error "Please define your compiler's Unicode conventions in wxChar.h" #error "Please define your compiler's Unicode conventions in wxChar.h"
#endif #endif
typedef char wxChar; typedef char wxChar;
typedef signed char wxSChar; typedef signed char wxSChar;
typedef unsigned char wxUChar; typedef unsigned char wxUChar;
#define _T(x) x #define _T(x) x
// ctype.h functions // ctype.h functions
#define wxIsalnum isalnum #define wxIsalnum isalnum
@@ -212,7 +212,7 @@ inline bool WXDLLEXPORT wxIsEmpty(const wxChar *p) { return !p || !*p; }
/// safe version of strlen() (returns 0 if passed NULL pointer) /// safe version of strlen() (returns 0 if passed NULL pointer)
inline size_t WXDLLEXPORT wxStrlen(const wxChar *psz) inline size_t WXDLLEXPORT wxStrlen(const wxChar *psz)
#if defined(_MSC_VER) #if defined(__VISUALC__)
{ return psz ? _tcslen(psz) : 0; } { return psz ? _tcslen(psz) : 0; }
#else #else
{ return psz ? strlen(psz) : 0; } { return psz ? strlen(psz) : 0; }
@@ -220,7 +220,7 @@ inline size_t WXDLLEXPORT wxStrlen(const wxChar *psz)
/// portable strcasecmp/_stricmp /// portable strcasecmp/_stricmp
inline int WXDLLEXPORT wxStricmp(const wxChar *, const wxChar *) inline int WXDLLEXPORT wxStricmp(const wxChar *, const wxChar *)
#if defined(_MSC_VER) #if defined(__VISUALC__)
{ return _tcsicmp(psz1, psz2); } { return _tcsicmp(psz1, psz2); }
#elif defined(__BORLANDC__) #elif defined(__BORLANDC__)
{ return stricmp(psz1, psz2); } { return stricmp(psz1, psz2); }

9
include/wx/wxexpr.h
View File

@@ -21,14 +21,7 @@
#include "wx/defs.h" #include "wx/defs.h"
#include "wx/string.h" #include "wx/string.h"
#if wxUSE_IOSTREAMH #include "wx/ioswrap.h"
#include <iostream.h>
#else
#include <iostream>
# ifdef _MSC_VER
using namespace std;
# endif
#endif
#include "wx/list.h" #include "wx/list.h"
#include "wx/hash.h" #include "wx/hash.h"

12
include/wx/wxprec.h
View File

@@ -6,19 +6,19 @@
// Created: 01/02/97 // Created: 01/02/97
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) // Copyright: (c)
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// check if to use precompiled headers // check if to use precompiled headers
#if (defined(__BORLANDC__) || defined(_MSC_VER) || defined(__WATCOMC__)) && defined(__WXMSW__) #if (defined(__BORLANDC__) || defined(__VISUALC__) || defined(__WATCOMC__)) && defined(__WXMSW__)
#if !NOPCH #if !NOPCH
#define WX_PRECOMP #define WX_PRECOMP
#endif #endif
#endif #endif
// For some reason, this must be defined for common dialogs to work. // For some reason, this must be defined for common dialogs to work.
#ifdef __WATCOMC__ #ifdef __WATCOMC__
#define INCLUDE_COMMDLG_H 1 #define INCLUDE_COMMDLG_H 1
#endif #endif
// include the wx definitions // include the wx definitions

2
src/common/docmdi.cpp
View File

@@ -6,7 +6,7 @@
// Created: 01/02/97 // Created: 01/02/97
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart // Copyright: (c) Julian Smart
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__

13
src/common/docview.cpp
View File

@@ -6,7 +6,7 @@
// Created: 01/02/97 // Created: 01/02/97
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem // Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__
@@ -51,15 +51,12 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include "wx/ioswrap.h"
#if wxUSE_IOSTREAMH #if wxUSE_IOSTREAMH
#include <iostream.h> #include <fstream.h>
#include <fstream.h>
#else #else
#include <iostream> #include <fstream>
#include <fstream>
# ifdef _MSC_VER
using namespace std;
# endif
#endif #endif
#if !USE_SHARED_LIBRARY #if !USE_SHARED_LIBRARY

68
src/common/file.cpp
View File

@@ -15,7 +15,7 @@
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#ifdef __GNUG__ #ifdef __GNUG__
#pragma implementation "file.h" #pragma implementation "file.h"
#endif #endif
// For compilers that support precompilation, includes "wx.h". // For compilers that support precompilation, includes "wx.h".
@@ -23,7 +23,7 @@
#include "wx/defs.h" #include "wx/defs.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
// standard // standard
@@ -55,37 +55,34 @@
#include <windows.h> // for GetTempFileName #include <windows.h> // for GetTempFileName
#elif (defined(__UNIX__) || defined(__GNUWIN32__)) #elif (defined(__UNIX__) || defined(__GNUWIN32__))
#include <unistd.h> #include <unistd.h>
#ifdef __GNUWIN32__ #ifdef __GNUWIN32__
#include <windows.h> #include <windows.h>
#endif #endif
#elif (defined(__WXSTUBS__)) #elif (defined(__WXSTUBS__))
// Have to ifdef this for different environments // Have to ifdef this for different environments
#include <io.h> #include <io.h>
#elif (defined(__WXMAC__)) #elif (defined(__WXMAC__))
int access( const char *path, int mode ) { return 0 ; } int access( const char *path, int mode ) { return 0 ; }
char* mktemp( char * path ) { return path ;} char* mktemp( char * path ) { return path ;}
#include <unistd.h> #include <unistd.h>
#include <unix.h> #include <unix.h>
#define W_OK 2 #define W_OK 2
#define R_OK 4 #define R_OK 4
#else #else
#error "Please specify the header with file functions declarations." #error "Please specify the header with file functions declarations."
#endif //Win/UNIX #endif //Win/UNIX
#include <stdio.h> // SEEK_xxx constants #include <stdio.h> // SEEK_xxx constants
#include <fcntl.h> // O_RDONLY &c #include <fcntl.h> // O_RDONLY &c
#ifndef __MWERKS__ #ifndef __MWERKS__
#include <sys/types.h> // needed for stat #include <sys/types.h> // needed for stat
#include <sys/stat.h> // stat #include <sys/stat.h> // stat
#endif #endif
// Microsoft compiler loves underscores, feed them to it // Microsoft compiler loves underscores, feed them to it
#ifdef _MSC_VER #ifdef __VISUALC__
#ifndef __MWERKS__
// functions // functions
#define open _open #define open _open
#define close _close #define close _close
@@ -110,16 +107,11 @@
#define S_IFDIR _S_IFDIR #define S_IFDIR _S_IFDIR
#define S_IFREG _S_IFREG #define S_IFREG _S_IFREG
#endif
#define W_OK 2
#define R_OK 4
#else #else
#define tell(fd) lseek(fd, 0, SEEK_CUR) #define tell(fd) lseek(fd, 0, SEEK_CUR)
#endif //_MSC_VER #endif // VC++
#ifdef __BORLANDC__ #if defined(__BORLANDC__) || defined(_MSC_VER)
#define W_OK 2 #define W_OK 2
#define R_OK 4 #define R_OK 4
#endif #endif
@@ -129,9 +121,8 @@
#define O_BINARY (0) #define O_BINARY (0)
#endif //__UNIX__ #endif //__UNIX__
#ifdef __SALFORDC__ #ifdef __SALFORDC__
#include <unix.h> #include <unix.h>
#endif #endif
// wxWindows // wxWindows
@@ -141,13 +132,13 @@
#include <wx/log.h> #include <wx/log.h>
#ifndef MAX_PATH #ifndef MAX_PATH
#define MAX_PATH 512 #define MAX_PATH 512
#endif #endif
#ifdef __WXMAC__ #ifdef __WXMAC__
char gwxMacFileName[ MAX_PATH ] ; char gwxMacFileName[ MAX_PATH ] ;
char gwxMacFileName2[ MAX_PATH ] ; char gwxMacFileName2[ MAX_PATH ] ;
char gwxMacFileName3[ MAX_PATH ] ; char gwxMacFileName3[ MAX_PATH ] ;
#endif #endif
// ============================================================================ // ============================================================================
@@ -330,7 +321,7 @@ size_t wxFile::Write(const void *pBuf, size_t nCount)
bool wxFile::Flush() bool wxFile::Flush()
{ {
if ( IsOpened() ) { if ( IsOpened() ) {
#if (defined(_MSC_VER) && !defined(__MWERKS__)) || wxHAVE_FSYNC #if defined(__VISUALC__) || wxHAVE_FSYNC
if ( fsync(m_fd) == -1 ) if ( fsync(m_fd) == -1 )
{ {
wxLogSysError(_("can't flush file descriptor %d"), m_fd); wxLogSysError(_("can't flush file descriptor %d"), m_fd);
@@ -399,9 +390,9 @@ off_t wxFile::Length() const
{ {
wxASSERT( IsOpened() ); wxASSERT( IsOpened() );
#if defined( _MSC_VER ) && !defined( __MWERKS__ ) #ifdef __VISUALC__
int iRc = _filelength(m_fd); int iRc = _filelength(m_fd);
#else #else // !VC++
int iRc = tell(m_fd); int iRc = tell(m_fd);
if ( iRc != -1 ) { if ( iRc != -1 ) {
// @ have to use const_cast :-( // @ have to use const_cast :-(
@@ -416,8 +407,7 @@ off_t wxFile::Length() const
iRc = iLen; iRc = iLen;
} }
#endif // VC++
#endif //_MSC_VER
if ( iRc == -1 ) { if ( iRc == -1 ) {
wxLogSysError(_("can't find length of file on file descriptor %d"), m_fd); wxLogSysError(_("can't find length of file on file descriptor %d"), m_fd);

792
src/common/filefn.cpp
View File

File diff suppressed because it is too large Load Diff

2
src/common/log.cpp
View File

@@ -986,7 +986,7 @@ void wxOnAssert(const char *szFile, int nLine, const char *szMsg)
// make life easier for people using VC++ IDE: clicking on the message will // make life easier for people using VC++ IDE: clicking on the message will
// take us immediately to the place of the failed assert // take us immediately to the place of the failed assert
#ifdef _MSC_VER #ifdef __VISUALC__
sprintf(szBuf, _("%s(%d): assert failed"), szFile, nLine); sprintf(szBuf, _("%s(%d): assert failed"), szFile, nLine);
#else // !VC++ #else // !VC++
// make the error message more clear for all the others // make the error message more clear for all the others

185
src/common/memory.cpp
View File

@@ -6,7 +6,7 @@
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem // Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__
@@ -38,15 +38,12 @@
#include <wx/log.h> #include <wx/log.h>
#include <stdlib.h> #include <stdlib.h>
#include "wx/ioswrap.h"
#if wxUSE_IOSTREAMH #if wxUSE_IOSTREAMH
#include <iostream.h> #include <fstream.h>
#include <fstream.h>
#else #else
#include <iostream> #include <fstream>
#include <fstream>
# ifdef _MSC_VER
using namespace std;
# endif
#endif #endif
#if !defined(__WATCOMC__) && !defined(__VMS__) && !defined( __MWERKS__ ) && !defined(__SALFORDC__) #if !defined(__WATCOMC__) && !defined(__VMS__) && !defined( __MWERKS__ ) && !defined(__SALFORDC__)
@@ -78,8 +75,8 @@
// wxDebugContext wxTheDebugContext; // wxDebugContext wxTheDebugContext;
/* /*
Redefine new and delete so that we can pick up situations where: Redefine new and delete so that we can pick up situations where:
- we overwrite or underwrite areas of malloc'd memory. - we overwrite or underwrite areas of malloc'd memory.
- we use uninitialise variables - we use uninitialise variables
Only do this in debug mode. Only do this in debug mode.
We change new to get enough memory to allocate a struct, followed We change new to get enough memory to allocate a struct, followed
@@ -116,7 +113,7 @@ void wxMemStruct::ErrorMsg (const char * mesg)
wxLogDebug("wxWindows memory checking error: %s", mesg); wxLogDebug("wxWindows memory checking error: %s", mesg);
PrintNode (); PrintNode ();
// << m_fileName << ' ' << m_lineNum << endl; // << m_fileName << ' ' << m_lineNum << endl;
} }
/* /*
@@ -141,9 +138,9 @@ void wxMemStruct::ErrorMsg ()
int wxMemStruct::AssertList () int wxMemStruct::AssertList ()
{ {
if (wxDebugContext::GetHead () != 0 && ! (wxDebugContext::GetHead ())->AssertIt () || if (wxDebugContext::GetHead () != 0 && ! (wxDebugContext::GetHead ())->AssertIt () ||
wxDebugContext::GetTail () != 0 && ! wxDebugContext::GetTail ()->AssertIt ()) { wxDebugContext::GetTail () != 0 && ! wxDebugContext::GetTail ()->AssertIt ()) {
ErrorMsg ("Head or tail pointers trashed"); ErrorMsg ("Head or tail pointers trashed");
return 0; return 0;
} }
return 1; return 1;
} }
@@ -163,8 +160,8 @@ int wxMemStruct::AssertList ()
int wxMemStruct::AssertIt () int wxMemStruct::AssertIt ()
{ {
return (m_id == MemStructId && return (m_id == MemStructId &&
(m_prev == 0 || m_prev->m_id == MemStructId) && (m_prev == 0 || m_prev->m_id == MemStructId) &&
(m_next == 0 || m_next->m_id == MemStructId)); (m_next == 0 || m_next->m_id == MemStructId));
} }
@@ -175,19 +172,19 @@ int wxMemStruct::AssertIt ()
int wxMemStruct::Append () int wxMemStruct::Append ()
{ {
if (! AssertList ()) if (! AssertList ())
return 0; return 0;
if (wxDebugContext::GetHead () == 0) { if (wxDebugContext::GetHead () == 0) {
if (wxDebugContext::GetTail () != 0) { if (wxDebugContext::GetTail () != 0) {
ErrorMsg ("Null list should have a null tail pointer"); ErrorMsg ("Null list should have a null tail pointer");
return 0; return 0;
} }
(void) wxDebugContext::SetHead (this); (void) wxDebugContext::SetHead (this);
(void) wxDebugContext::SetTail (this); (void) wxDebugContext::SetTail (this);
} else { } else {
wxDebugContext::GetTail ()->m_next = this; wxDebugContext::GetTail ()->m_next = this;
this->m_prev = wxDebugContext::GetTail (); this->m_prev = wxDebugContext::GetTail ();
(void) wxDebugContext::SetTail (this); (void) wxDebugContext::SetTail (this);
} }
return 1; return 1;
} }
@@ -201,51 +198,51 @@ int wxMemStruct::Append ()
int wxMemStruct::Unlink () int wxMemStruct::Unlink ()
{ {
if (! AssertList ()) if (! AssertList ())
return 0; return 0;
if (wxDebugContext::GetHead () == 0 || wxDebugContext::GetTail () == 0) { if (wxDebugContext::GetHead () == 0 || wxDebugContext::GetTail () == 0) {
ErrorMsg ("Trying to remove node from empty list"); ErrorMsg ("Trying to remove node from empty list");
return 0; return 0;
} }
// Handle the part of the list before this node. // Handle the part of the list before this node.
if (m_prev == 0) { if (m_prev == 0) {
if (this != wxDebugContext::GetHead ()) { if (this != wxDebugContext::GetHead ()) {
ErrorMsg ("No previous node for non-head node"); ErrorMsg ("No previous node for non-head node");
return 0; return 0;
} }
(void) wxDebugContext::SetHead (m_next); (void) wxDebugContext::SetHead (m_next);
} else { } else {
if (! m_prev->AssertIt ()) { if (! m_prev->AssertIt ()) {
ErrorMsg ("Trashed previous pointer"); ErrorMsg ("Trashed previous pointer");
return 0; return 0;
} }
if (m_prev->m_next != this) { if (m_prev->m_next != this) {
ErrorMsg ("List is inconsistent"); ErrorMsg ("List is inconsistent");
return 0; return 0;
} }
m_prev->m_next = m_next; m_prev->m_next = m_next;
} }
// Handle the part of the list after this node. // Handle the part of the list after this node.
if (m_next == 0) { if (m_next == 0) {
if (this != wxDebugContext::GetTail ()) { if (this != wxDebugContext::GetTail ()) {
ErrorMsg ("No next node for non-tail node"); ErrorMsg ("No next node for non-tail node");
return 0; return 0;
} }
(void) wxDebugContext::SetTail (m_prev); (void) wxDebugContext::SetTail (m_prev);
} else { } else {
if (! m_next->AssertIt ()) { if (! m_next->AssertIt ()) {
ErrorMsg ("Trashed next pointer"); ErrorMsg ("Trashed next pointer");
return 0; return 0;
} }
if (m_next->m_prev != this) { if (m_next->m_prev != this) {
ErrorMsg ("List is inconsistent"); ErrorMsg ("List is inconsistent");
return 0; return 0;
} }
m_next->m_prev = m_prev; m_next->m_prev = m_prev;
} }
return 1; return 1;
@@ -262,20 +259,20 @@ int wxMemStruct::CheckBlock ()
int nFailures = 0; int nFailures = 0;
if (m_firstMarker != MemStartCheck) { if (m_firstMarker != MemStartCheck) {
nFailures++; nFailures++;
ErrorMsg (); ErrorMsg ();
} }
char * pointer = wxDebugContext::MidMarkerPos ((char *) this); char * pointer = wxDebugContext::MidMarkerPos ((char *) this);
if (* (wxMarkerType *) pointer != MemMidCheck) { if (* (wxMarkerType *) pointer != MemMidCheck) {
nFailures++; nFailures++;
ErrorMsg (); ErrorMsg ();
} }
pointer = wxDebugContext::EndMarkerPos ((char *) this, RequestSize ()); pointer = wxDebugContext::EndMarkerPos ((char *) this, RequestSize ());
if (* (wxMarkerType *) pointer != MemEndCheck) { if (* (wxMarkerType *) pointer != MemEndCheck) {
nFailures++; nFailures++;
ErrorMsg (); ErrorMsg ();
} }
return nFailures; return nFailures;
@@ -290,10 +287,10 @@ int wxMemStruct::CheckAllPrevious ()
int nFailures = 0; int nFailures = 0;
for (wxMemStruct * st = this->m_prev; st != 0; st = st->m_prev) { for (wxMemStruct * st = this->m_prev; st != 0; st = st->m_prev) {
if (st->AssertIt ()) if (st->AssertIt ())
nFailures += st->CheckBlock (); nFailures += st->CheckBlock ();
else else
return -1; return -1;
} }
return nFailures; return nFailures;
@@ -416,15 +413,15 @@ int wxMemStruct::ValidateNode ()
{ {
char * startPointer = (char *) this; char * startPointer = (char *) this;
if (!AssertIt ()) { if (!AssertIt ()) {
if (IsDeleted ()) if (IsDeleted ())
ErrorMsg ("Object already deleted"); ErrorMsg ("Object already deleted");
else { else {
// Can't use the error routines as we have no recognisable object. // Can't use the error routines as we have no recognisable object.
#ifndef __WXGTK__ #ifndef __WXGTK__
wxLogDebug("Can't verify memory struct - all bets are off!"); wxLogDebug("Can't verify memory struct - all bets are off!");
#endif #endif
} }
return 0; return 0;
} }
/* /*
@@ -438,20 +435,20 @@ int wxMemStruct::ValidateNode ()
if (* (wxMarkerType *) wxDebugContext::MidMarkerPos (startPointer) != MemMidCheck) if (* (wxMarkerType *) wxDebugContext::MidMarkerPos (startPointer) != MemMidCheck)
ErrorMsg (); ErrorMsg ();
if (* (wxMarkerType *) wxDebugContext::EndMarkerPos (startPointer, if (* (wxMarkerType *) wxDebugContext::EndMarkerPos (startPointer,
RequestSize ()) != RequestSize ()) !=
MemEndCheck) MemEndCheck)
ErrorMsg (); ErrorMsg ();
// Back to before the extra buffer and check that // Back to before the extra buffer and check that
// we can still read what we originally wrote. // we can still read what we originally wrote.
if (Marker () != MemStartCheck || if (Marker () != MemStartCheck ||
* (wxMarkerType *) wxDebugContext::MidMarkerPos (startPointer) * (wxMarkerType *) wxDebugContext::MidMarkerPos (startPointer)
!= MemMidCheck || != MemMidCheck ||
* (wxMarkerType *) wxDebugContext::EndMarkerPos (startPointer, * (wxMarkerType *) wxDebugContext::EndMarkerPos (startPointer,
RequestSize ()) != MemEndCheck) RequestSize ()) != MemEndCheck)
{ {
ErrorMsg (); ErrorMsg ();
return 0; return 0;
} }
return 1; return 1;
@@ -588,7 +585,7 @@ char * wxDebugContext::EndMarkerPos (const char * buf, const size_t size)
char * wxDebugContext::StartPos (const char * caller) char * wxDebugContext::StartPos (const char * caller)
{ {
return ((char *) (caller - wxDebugContext::PaddedSize (sizeof(wxMarkerType)) - return ((char *) (caller - wxDebugContext::PaddedSize (sizeof(wxMarkerType)) -
wxDebugContext::PaddedSize (sizeof (wxMemStruct)))); wxDebugContext::PaddedSize (sizeof (wxMemStruct))));
} }
/* /*
@@ -620,7 +617,7 @@ size_t wxDebugContext::PaddedSize (const size_t size)
size_t wxDebugContext::TotSize (const size_t reqSize) size_t wxDebugContext::TotSize (const size_t reqSize)
{ {
return (PaddedSize (sizeof (wxMemStruct)) + PaddedSize (reqSize) + return (PaddedSize (sizeof (wxMemStruct)) + PaddedSize (reqSize) +
2 * sizeof(wxMarkerType)); 2 * sizeof(wxMarkerType));
} }
@@ -942,7 +939,7 @@ int wxDebugContext::CountObjectsLeft(bool sinceCheckpoint)
#endif #endif
// Seems OK all of a sudden. Maybe to do with linking with multithreaded library? // Seems OK all of a sudden. Maybe to do with linking with multithreaded library?
#if 0 // def _MSC_VER #if 0 // def __VISUALC__
#define NO_DEBUG_ALLOCATION #define NO_DEBUG_ALLOCATION
#endif #endif
@@ -1001,7 +998,7 @@ void operator delete (void * buf)
} }
// VC++ 6.0 // VC++ 6.0
#if _MSC_VER >= 1200 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
void operator delete(void* pData, char* /* fileName */, int /* lineNum */) void operator delete(void* pData, char* /* fileName */, int /* lineNum */)
{ {
// ::operator delete(pData); // ::operator delete(pData);
@@ -1043,8 +1040,8 @@ void * wxDebugAlloc(size_t size, char * fileName, int lineNum, bool isObject, bo
int totSize = wxDebugContext::TotSize (size); int totSize = wxDebugContext::TotSize (size);
char * buf = (char *) malloc(totSize); char * buf = (char *) malloc(totSize);
if (!buf) { if (!buf) {
wxLogDebug("Call to malloc (%ld) failed.", (long)size); wxLogDebug("Call to malloc (%ld) failed.", (long)size);
return 0; return 0;
} }
wxMemStruct * st = (wxMemStruct *)buf; wxMemStruct * st = (wxMemStruct *)buf;
st->m_firstMarker = MemStartCheck; st->m_firstMarker = MemStartCheck;
@@ -1058,13 +1055,13 @@ void * wxDebugAlloc(size_t size, char * fileName, int lineNum, bool isObject, bo
// Errors from Append() shouldn't really happen - but just in case! // Errors from Append() shouldn't really happen - but just in case!
if (st->Append () == 0) { if (st->Append () == 0) {
st->ErrorMsg ("Trying to append new node"); st->ErrorMsg ("Trying to append new node");
} }
if (wxDebugContext::GetCheckPrevious ()) { if (wxDebugContext::GetCheckPrevious ()) {
if (st->CheckAllPrevious () < 0) { if (st->CheckAllPrevious () < 0) {
st->ErrorMsg ("Checking previous nodes"); st->ErrorMsg ("Checking previous nodes");
} }
} }
// Set up the extra markers at the middle and end. // Set up the extra markers at the middle and end.
@@ -1101,7 +1098,7 @@ void wxDebugFree(void * buf, bool WXUNUSED(isVect) )
wxMemStruct * st = (wxMemStruct *) wxDebugContext::StructPos (startPointer); wxMemStruct * st = (wxMemStruct *) wxDebugContext::StructPos (startPointer);
if (! st->ValidateNode ()) if (! st->ValidateNode ())
return; return;
// If this is the current checkpoint, we need to // If this is the current checkpoint, we need to
// move the checkpoint back so it points to a valid // move the checkpoint back so it points to a valid
@@ -1118,7 +1115,7 @@ void wxDebugFree(void * buf, bool WXUNUSED(isVect) )
// memory locations. // memory locations.
st->SetDeleted (); st->SetDeleted ();
(void) memset (wxDebugContext::CallerMemPos (startPointer), MemFillChar, (void) memset (wxDebugContext::CallerMemPos (startPointer), MemFillChar,
st->RequestSize ()); st->RequestSize ());
// Don't allow delayed freeing of memory in this version // Don't allow delayed freeing of memory in this version
// if (!wxDebugContext::GetDelayFree()) // if (!wxDebugContext::GetDelayFree())

17
src/common/object.cpp
View File

@@ -6,7 +6,7 @@
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem // Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__
@@ -40,15 +40,8 @@
#endif #endif
#if defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT #if defined(__WXDEBUG__) || wxUSE_DEBUG_CONTEXT
// for wxObject::Dump // for wxObject::Dump
#if wxUSE_IOSTREAMH #include "wx/ioswrap.h"
# include <iostream.h>
#else
# include <iostream>
# ifdef _MSC_VER
using namespace std;
# endif
#endif
#endif #endif
#if !USE_SHARED_LIBRARY #if !USE_SHARED_LIBRARY
@@ -121,7 +114,7 @@ void wxObject::operator delete (void * buf)
} }
// VC++ 6.0 // VC++ 6.0
#if _MSC_VER >= 1200 #if defined(__VISUALC__) && (__VISUALC__ >= 1200)
void wxObject::operator delete(void* pData, char* /* fileName */, int /* lineNum */) void wxObject::operator delete(void* pData, char* /* fileName */, int /* lineNum */)
{ {
::operator delete(pData); ::operator delete(pData);
@@ -129,7 +122,7 @@ void wxObject::operator delete(void* pData, char* /* fileName */, int /* lineNum
#endif #endif
// Cause problems for VC++ - crashes // Cause problems for VC++ - crashes
#if !defined(_MSC_VER) && wxUSE_ARRAY_MEMORY_OPERATORS #if !defined(__VISUALC__) && wxUSE_ARRAY_MEMORY_OPERATORS
void * wxObject::operator new[] (size_t size, char * fileName, int lineNum) void * wxObject::operator new[] (size_t size, char * fileName, int lineNum)
{ {
return wxDebugAlloc(size, fileName, lineNum, TRUE, TRUE); return wxDebugAlloc(size, fileName, lineNum, TRUE, TRUE);

8
src/common/odbc.cpp
View File

@@ -2,12 +2,12 @@
// Name: odbc.cpp // Name: odbc.cpp
// Purpose: ODBC implementation // Purpose: ODBC implementation
// Author: Julian Smart, Olaf Klein (oklein@smallo.ruhr.de), // Author: Julian Smart, Olaf Klein (oklein@smallo.ruhr.de),
// Patrick Halke (patrick@zaphod.ruhr.de) // Patrick Halke (patrick@zaphod.ruhr.de)
// Modified by: // Modified by:
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem // Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__
@@ -25,7 +25,7 @@
#if wxUSE_ODBC #if wxUSE_ODBC
#ifdef _MSC_VER #ifdef __VISUALC__
#pragma warning(disable:4706) // assignment within conditional expression #pragma warning(disable:4706) // assignment within conditional expression
#endif // VC++ #endif // VC++
@@ -1831,7 +1831,7 @@ bool wxQueryField::IsDirty(void) {
return dirty; return dirty;
} }
#ifdef _MSC_VER #ifdef __VISUALC__
#pragma warning(default:4706) // assignment within conditional expression #pragma warning(default:4706) // assignment within conditional expression
#endif // VC++ #endif // VC++

4
src/common/resourc2.cpp
View File

@@ -22,7 +22,7 @@
#if wxUSE_WX_RESOURCES #if wxUSE_WX_RESOURCES
#ifdef _MSC_VER #ifdef __VISUALC__
#pragma warning(disable:4706) // assignment within conditional expression #pragma warning(disable:4706) // assignment within conditional expression
#endif // VC++ #endif // VC++
@@ -1568,7 +1568,7 @@ wxControl *wxWindow::CreateItem(const wxItemResource *resource, const wxItemReso
return table->CreateItem((wxWindow *)this, resource, parentResource); return table->CreateItem((wxWindow *)this, resource, parentResource);
} }
#ifdef _MSC_VER #ifdef __VISUALC__
#pragma warning(default:4706) // assignment within conditional expression #pragma warning(default:4706) // assignment within conditional expression
#endif // VC++ #endif // VC++

4
src/common/resource.cpp
View File

@@ -22,7 +22,7 @@
#if wxUSE_WX_RESOURCES #if wxUSE_WX_RESOURCES
#ifdef _MSC_VER #ifdef __VISUALC__
#pragma warning(disable:4706) // assignment within conditional expression #pragma warning(disable:4706) // assignment within conditional expression
#endif // VC++ #endif // VC++
@@ -2916,7 +2916,7 @@ wxControl *wxWindow::CreateItem(const wxItemResource *resource, const wxItemReso
return table->CreateItem((wxWindow *)this, resource, parentResource); return table->CreateItem((wxWindow *)this, resource, parentResource);
} }
#ifdef _MSC_VER #ifdef __VISUALC__
#pragma warning(default:4706) // assignment within conditional expression #pragma warning(default:4706) // assignment within conditional expression
#endif // VC++ #endif // VC++

12
src/common/socket.cpp
View File

@@ -97,7 +97,7 @@ void wxMacProcessEvents() ;
#include <signal.h> #include <signal.h>
#include <errno.h> #include <errno.h>
#ifdef _MSC_VER #ifdef __VISUALC__
#include <io.h> #include <io.h>
#endif #endif
@@ -157,7 +157,7 @@ void wxMacProcessEvents() ;
// implementations (such as PC-NFS) will require you to include this // implementations (such as PC-NFS) will require you to include this
// or a similar routine (see appendix in WinSock doc or help file). // or a similar routine (see appendix in WinSock doc or help file).
#if defined( NEED_WSAFDIsSet ) || defined( _MSC_VER ) #if defined( NEED_WSAFDIsSet ) || defined( __VISUALC__ )
int PASCAL FAR __WSAFDIsSet(SOCKET fd, fd_set FAR *set) int PASCAL FAR __WSAFDIsSet(SOCKET fd, fd_set FAR *set)
{ {
int i = set->fd_count; int i = set->fd_count;
@@ -440,9 +440,9 @@ wxSocketBase& wxSocketBase::WriteMsg(const char *buffer, size_t nbytes)
SockMsg msg; SockMsg msg;
// warning about 'cast truncates constant value' // warning about 'cast truncates constant value'
#ifdef _MSC_VER #ifdef __VISUALC__
#pragma warning(disable: 4310) #pragma warning(disable: 4310)
#endif // _MSC_VER #endif // __VISUALC__
msg.sig[0] = (char) 0xad; msg.sig[0] = (char) 0xad;
msg.sig[1] = (char) 0xde; msg.sig[1] = (char) 0xde;
@@ -468,9 +468,9 @@ wxSocketBase& wxSocketBase::WriteMsg(const char *buffer, size_t nbytes)
return *this; return *this;
#ifdef _MSC_VER #ifdef __VISUALC__
#pragma warning(default: 4310) #pragma warning(default: 4310)
#endif // _MSC_VER #endif // __VISUALC__
} }
wxSocketBase& wxSocketBase::Unread(const char *buffer, size_t nbytes) wxSocketBase& wxSocketBase::Unread(const char *buffer, size_t nbytes)

48
src/common/string.cpp
View File

@@ -90,7 +90,7 @@ extern const char WXDLLEXPORT *g_szNul = &g_strEmpty.dummy;
// function: for Unix this is done with configure, for Windows we test the // function: for Unix this is done with configure, for Windows we test the
// compiler explicitly. // compiler explicitly.
#ifdef __WXMSW__ #ifdef __WXMSW__
#ifdef _MSC_VER #ifdef __VISUALC__
#define wxVsprintf _vsnprintf #define wxVsprintf _vsnprintf
#endif #endif
#else // !Windows #else // !Windows
@@ -107,7 +107,7 @@ extern const char WXDLLEXPORT *g_szNul = &g_strEmpty.dummy;
#ifndef __SC__ #ifndef __SC__
#pragma message("Using sprintf() because no snprintf()-like function defined") #pragma message("Using sprintf() because no snprintf()-like function defined")
#endif #endif
#endif #endif // no vsnprintf
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
// global functions // global functions
@@ -119,46 +119,18 @@ extern const char WXDLLEXPORT *g_szNul = &g_strEmpty.dummy;
// iostream ones. // iostream ones.
// //
// ATTN: you can _not_ use both of these in the same program! // ATTN: you can _not_ use both of these in the same program!
#if wxUSE_IOSTREAMH
#include <iostream.h>
#define NAMESPACE
#else
#include <iostream>
# ifdef _MSC_VER
using namespace std;
# endif
// for msvc (bcc50+ also) you don't need these NAMESPACE defines,
// using namespace std; takes care of that.
#define NAMESPACE std::
#endif
#ifdef __WXMSW__ istream& operator>>(istream& is, wxString& WXUNUSED(str))
#ifdef _MSC_VER
#define wxVsprintf _vsnprintf
#endif
#else
#if defined ( HAVE_VSNPRINTF )
#define wxVsprintf vsnprintf
#endif
#endif
#ifndef wxVsprintf
// vsprintf() is ANSI so we can always use it, but it's unsafe!
#define wxVsprintf(buffer,len,format,argptr) vsprintf(buffer,format, argptr)
#pragma message("Using sprintf() because no snprintf()-like function defined")
#endif
NAMESPACE istream& operator>>(NAMESPACE istream& is, wxString& WXUNUSED(str))
{ {
#if 0 #if 0
int w = is.width(0); int w = is.width(0);
if ( is.ipfx(0) ) { if ( is.ipfx(0) ) {
NAMESPACE streambuf *sb = is.rdbuf(); streambuf *sb = is.rdbuf();
str.erase(); str.erase();
while ( true ) { while ( true ) {
int ch = sb->sbumpc (); int ch = sb->sbumpc ();
if ( ch == EOF ) { if ( ch == EOF ) {
is.setstate(NAMESPACE ios::eofbit); is.setstate(ios::eofbit);
break; break;
} }
else if ( isspace(ch) ) { else if ( isspace(ch) ) {
@@ -174,7 +146,7 @@ NAMESPACE istream& operator>>(NAMESPACE istream& is, wxString& WXUNUSED(str))
is.isfx(); is.isfx();
if ( str.length() == 0 ) if ( str.length() == 0 )
is.setstate(NAMESPACE ios::failbit); is.setstate(ios::failbit);
#endif #endif
return is; return is;
} }
@@ -1142,12 +1114,12 @@ size_t wxString::find(const wxString& str, size_t nStart) const
} }
// VC++ 1.5 can't cope with the default argument in the header. // VC++ 1.5 can't cope with the default argument in the header.
#if ! (defined(_MSC_VER) && !defined(__WIN32__)) #if !defined(__VISUALC__) || defined(__WIN32__)
size_t wxString::find(const char* sz, size_t nStart, size_t n) const size_t wxString::find(const char* sz, size_t nStart, size_t n) const
{ {
return find(wxString(sz, n == npos ? 0 : n), nStart); return find(wxString(sz, n == npos ? 0 : n), nStart);
} }
#endif #endif // VC++ 1.5
// Gives a duplicate symbol (presumably a case-insensitivity problem) // Gives a duplicate symbol (presumably a case-insensitivity problem)
#if !defined(__BORLANDC__) #if !defined(__BORLANDC__)
@@ -1178,7 +1150,7 @@ size_t wxString::rfind(const wxString& str, size_t nStart) const
} }
// VC++ 1.5 can't cope with the default argument in the header. // VC++ 1.5 can't cope with the default argument in the header.
#if ! (defined(_MSC_VER) && !defined(__WIN32__)) #if !defined(__VISUALC__) || defined(__WIN32__)
size_t wxString::rfind(const char* sz, size_t nStart, size_t n) const size_t wxString::rfind(const char* sz, size_t nStart, size_t n) const
{ {
return rfind(wxString(sz, n == npos ? 0 : n), nStart); return rfind(wxString(sz, n == npos ? 0 : n), nStart);
@@ -1192,7 +1164,7 @@ size_t wxString::rfind(char ch, size_t nStart) const
return p == NULL ? npos : p - c_str(); return p == NULL ? npos : p - c_str();
} }
#endif #endif // VC++ 1.5
wxString wxString::substr(size_t nStart, size_t nLen) const wxString wxString::substr(size_t nStart, size_t nLen) const
{ {

161
src/common/time.cpp
View File

@@ -6,7 +6,7 @@
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem // Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__
@@ -32,17 +32,14 @@ seconds since January 1, 1901, GMT.
#include "wx/time.h" #include "wx/time.h"
#include "wx/date.h" #include "wx/date.h"
#include "wx/utils.h" #include "wx/utils.h"
#include <wx/intl.h> #include "wx/intl.h"
#include "wx/ioswrap.h"
#if wxUSE_IOSTREAMH #if wxUSE_IOSTREAMH
#include <iostream.h> #include <iomanip.h>
#include <iomanip.h>
#else #else
#include <iostream> #include <iomanip>
#include <iomanip>
# ifdef _MSC_VER
using namespace std;
# endif
#endif #endif
#include <string.h> #include <string.h>
@@ -60,8 +57,8 @@ static int DST_OBSERVED; /* flags U.S. daylight saving time observed */
static bool wxTimeInitialized = FALSE; static bool wxTimeInitialized = FALSE;
wxTime::tFormat wxTime::Format = wxTime::wx12h; wxTime::tFormat wxTime::Format = wxTime::wx12h;
wxTime::tPrecision wxTime::Precision = wxTime::wxStdMinSec; wxTime::tPrecision wxTime::Precision = wxTime::wxStdMinSec;
static const unsigned long seconds_in_day = 24*60*60L; static const unsigned long seconds_in_day = 24*60*60L;
static const wxDate refDate(1,1,1901); static const wxDate refDate(1,1,1901);
@@ -69,19 +66,19 @@ static const wxDate refDate(1,1,1901);
wxTime wxTime::GetLocalTime(const wxDate& date, hourTy h, minuteTy m, secondTy s) wxTime wxTime::GetLocalTime(const wxDate& date, hourTy h, minuteTy m, secondTy s)
/* /*
Return a local wxTime for the specified Standard Time date, hour, minute, Return a local wxTime for the specified Standard Time date, hour, minute,
and second. and second.
*/ */
{ {
if (!wxTimeInitialized) if (!wxTimeInitialized)
{ {
wxGetLocalTime(&TIME_ZONE, &DST_OBSERVED); wxGetLocalTime(&TIME_ZONE, &DST_OBSERVED);
wxTimeInitialized = TRUE; wxTimeInitialized = TRUE;
} }
/* /*
if (!date.IsBetween(refDate,maxDate)) if (!date.IsBetween(refDate,maxDate))
setError(NIHCL_DATERANGE,DEFAULT, setError(NIHCL_DATERANGE,DEFAULT,
date.dayOfMonth(),date.nameOfMonth(),date.year()); date.dayOfMonth(),date.nameOfMonth(),date.year());
*/ */
// The following line causes an error in GCC 2.1 // The following line causes an error in GCC 2.1
// long daysBetween = date-refDate; // long daysBetween = date-refDate;
@@ -95,13 +92,13 @@ wxTime wxTime::GetLocalTime(const wxDate& date, hourTy h, minuteTy m, secondTy s
wxTime::wxTime() wxTime::wxTime()
/* /*
Construct a wxTime for this instant. Construct a wxTime for this instant.
*/ */
{ {
if (!wxTimeInitialized) if (!wxTimeInitialized)
{ {
wxGetLocalTime(&TIME_ZONE, &DST_OBSERVED); wxGetLocalTime(&TIME_ZONE, &DST_OBSERVED);
wxTimeInitialized = TRUE; wxTimeInitialized = TRUE;
} }
sec = wxGetCurrentTime(); sec = wxGetCurrentTime();
#ifdef __SALFORDC__ #ifdef __SALFORDC__
@@ -113,14 +110,14 @@ wxTime::wxTime()
wxTime::wxTime(hourTy h, minuteTy m, secondTy s, bool dst) wxTime::wxTime(hourTy h, minuteTy m, secondTy s, bool dst)
/* /*
Construct a wxTime for today at the specified (local) hour, minute, and Construct a wxTime for today at the specified (local) hour, minute, and
second. second.
*/ */
{ {
if (!wxTimeInitialized) if (!wxTimeInitialized)
{ {
wxGetLocalTime(&TIME_ZONE, &DST_OBSERVED); wxGetLocalTime(&TIME_ZONE, &DST_OBSERVED);
wxTimeInitialized = TRUE; wxTimeInitialized = TRUE;
} }
sec = wxTime(wxDate(),h,m,s,dst).sec; sec = wxTime(wxDate(),h,m,s,dst).sec;
@@ -136,7 +133,7 @@ wxTime::wxTime(const wxDate& date, hourTy h, minuteTy m, secondTy s, bool dst)
if (!wxTimeInitialized) if (!wxTimeInitialized)
{ {
wxGetLocalTime(&TIME_ZONE, &DST_OBSERVED); wxGetLocalTime(&TIME_ZONE, &DST_OBSERVED);
wxTimeInitialized = TRUE; wxTimeInitialized = TRUE;
} }
sec = GetLocalTime(date,h,m,s).sec-3600; sec = GetLocalTime(date,h,m,s).sec-3600;
if (IsDST()) if (IsDST())
@@ -149,8 +146,8 @@ wxTime::wxTime(const wxDate& date, hourTy h, minuteTy m, secondTy s, bool dst)
sec += 3600; sec += 3600;
/* /*
if (IsDST()) setError(NIHCL_BADTIME,DEFAULT, if (IsDST()) setError(NIHCL_BADTIME,DEFAULT,
date.dayOfMonth(),date.nameOfMonth(),date.year(), date.dayOfMonth(),date.nameOfMonth(),date.year(),
h,m,s,(dst?_("DST"):"")); h,m,s,(dst?_("DST"):""));
*/ */
} }
sec += TIME_ZONE; // adjust to GMT sec += TIME_ZONE; // adjust to GMT
@@ -159,11 +156,11 @@ wxTime::wxTime(const wxDate& date, hourTy h, minuteTy m, secondTy s, bool dst)
#ifndef __SALFORDC__ #ifndef __SALFORDC__
wxTime::operator wxDate() const wxTime::operator wxDate() const
/* /*
Convert a wxTime to a local wxDate Convert a wxTime to a local wxDate
*/ */
{ {
// return wxDate((int)(GetLocalTime().sec/seconds_in_day)); 4.2 cc bug // return wxDate((int)(GetLocalTime().sec/seconds_in_day)); 4.2 cc bug
long daycount = (long)(GetLocalTime().sec/seconds_in_day); long daycount = (long)(GetLocalTime().sec/seconds_in_day);
wxDate date(1,1,1901); wxDate date(1,1,1901);
date += daycount; date += daycount;
@@ -178,11 +175,11 @@ bool wxTime::IsBetween(const wxTime& a, const wxTime& b) const
hourTy wxTime::GetHour() const hourTy wxTime::GetHour() const
/* /*
Return the hour of this wxTime in local time; i.e., adjust for Return the hour of this wxTime in local time; i.e., adjust for
time zone and Daylight Savings Time. time zone and Daylight Savings Time.
*/ */
{ {
return GetLocalTime().GetHourGMT(); return GetLocalTime().GetHourGMT();
} }
hourTy wxTime::GetHourGMT() const hourTy wxTime::GetHourGMT() const
@@ -190,12 +187,12 @@ hourTy wxTime::GetHourGMT() const
Return the hour of this Time in GMT. Return the hour of this Time in GMT.
*/ */
{ {
return (hourTy)((sec % 86400) / 3600); return (hourTy)((sec % 86400) / 3600);
} }
wxTime wxTime::GetBeginDST(unsigned year) wxTime wxTime::GetBeginDST(unsigned year)
/* /*
Return the local Standard Time at which Daylight Savings Time Return the local Standard Time at which Daylight Savings Time
begins in the specified year. begins in the specified year.
*/ */
{ {
@@ -203,8 +200,8 @@ wxTime wxTime::GetBeginDST(unsigned year)
wxTime DSTtime(GetLocalTime(wxDate(3,31,year).Previous(1)+7,2)); wxTime DSTtime(GetLocalTime(wxDate(3,31,year).Previous(1)+7,2));
if (year<=1986) { if (year<=1986) {
// Previous Sunday // Previous Sunday
DSTtime = GetLocalTime(wxDate(4,30,year).Previous(1),2); DSTtime = GetLocalTime(wxDate(4,30,year).Previous(1),2);
if (year==1974) DSTtime = GetLocalTime(wxDate(1,6,1974),2); if (year==1974) DSTtime = GetLocalTime(wxDate(1,6,1974),2);
if (year==1975) DSTtime = GetLocalTime(wxDate(2,23,1975),2); if (year==1975) DSTtime = GetLocalTime(wxDate(2,23,1975),2);
} }
return DSTtime; return DSTtime;
@@ -216,8 +213,8 @@ wxTime wxTime::GetEndDST(unsigned year)
ends in the specified year. ends in the specified year.
*/ */
{ {
wxTime STDtime(GetLocalTime(wxDate(10,31,year).Previous(1),2-1)); wxTime STDtime(GetLocalTime(wxDate(10,31,year).Previous(1),2-1));
return STDtime; return STDtime;
} }
bool wxTime::IsDST() const bool wxTime::IsDST() const
@@ -229,12 +226,12 @@ bool wxTime::IsDST() const
long daycount = (long)(sec/seconds_in_day); long daycount = (long)(sec/seconds_in_day);
// At this point, daycount is the number of days from 1/1/1901. // At this point, daycount is the number of days from 1/1/1901.
// Need to convert to julian date (which starts at 1/1/4713 B.C.) // Need to convert to julian date (which starts at 1/1/4713 B.C.)
wxDate date(1,1,1901); wxDate date(1,1,1901);
date += daycount; date += daycount;
unsigned year = date.GetYear(); unsigned year = date.GetYear();
if (DST_OBSERVED) if (DST_OBSERVED)
{ {
if (*this >= GetBeginDST(year)) if (*this >= GetBeginDST(year))
if (*this < GetEndDST(year)) return TRUE; if (*this < GetEndDST(year)) return TRUE;
@@ -247,7 +244,7 @@ wxTime wxTime::GetLocalTime() const
Adjusts this GM Time for local time zone and Daylight Savings Time. Adjusts this GM Time for local time zone and Daylight Savings Time.
*/ */
{ {
wxTime local_time(sec-TIME_ZONE); wxTime local_time(sec-TIME_ZONE);
if (local_time.IsDST()) local_time.sec += 3600; if (local_time.IsDST()) local_time.sec += 3600;
return local_time; return local_time;
} }
@@ -255,7 +252,7 @@ wxTime wxTime::GetLocalTime() const
minuteTy wxTime::GetMinute() const minuteTy wxTime::GetMinute() const
/* /*
Return the minute of this wxTime in local time; i.e., adjust Return the minute of this wxTime in local time; i.e., adjust
for time zone and Daylight Savings Time. for time zone and Daylight Savings Time.
*/ */
{ {
return GetLocalTime().GetMinuteGMT(); return GetLocalTime().GetMinuteGMT();
@@ -266,7 +263,7 @@ minuteTy wxTime::GetMinuteGMT() const
Return the minute of this wxTime in GMT. Return the minute of this wxTime in GMT.
*/ */
{ {
return (minuteTy)(((sec % 86400) % 3600) / 60); return (minuteTy)(((sec % 86400) % 3600) / 60);
} }
secondTy wxTime::GetSecond() const secondTy wxTime::GetSecond() const
@@ -274,7 +271,7 @@ secondTy wxTime::GetSecond() const
Return the second of this wxTime. Return the second of this wxTime.
*/ */
{ {
return (secondTy)(((sec % 86400) % 3600) % 60); return (secondTy)(((sec % 86400) % 3600) % 60);
} }
secondTy wxTime::GetSecondGMT() const secondTy wxTime::GetSecondGMT() const
@@ -318,7 +315,7 @@ wxTime wxTime::Max(const wxTime& t) const
wxTime wxTime::Min(const wxTime& t) const wxTime wxTime::Min(const wxTime& t) const
{ {
if (t > *this) return *this; if (t > *this) return *this;
return t; return t;
} }
#ifndef __SALFORDC__ #ifndef __SALFORDC__
@@ -329,46 +326,46 @@ wxTime::operator char *(void)
#endif #endif
void wxTime::SetFormat(const wxTime::tFormat lFormat, void wxTime::SetFormat(const wxTime::tFormat lFormat,
const wxTime::tPrecision lPrecision) { const wxTime::tPrecision lPrecision) {
wxTime::Format = lFormat; wxTime::Format = lFormat;
wxTime::Precision = lPrecision; wxTime::Precision = lPrecision;
} }
char *wxTime::FormatTime() const { char *wxTime::FormatTime() const {
static char timeBuf[30]; static char timeBuf[30];
unsigned hh(GetHour()); unsigned hh(GetHour());
switch (Format) { switch (Format) {
case wx12h: case wx12h:
hh -= 12; hh -= 12;
break; break;
case wx24h: case wx24h:
break; break;
} }
switch (Precision) { switch (Precision) {
case wxStdMinSec: case wxStdMinSec:
sprintf(timeBuf,"%2d:%02d:%02d",hh,GetMinute(),GetSecond()); sprintf(timeBuf,"%2d:%02d:%02d",hh,GetMinute(),GetSecond());
break; break;
case wxStdMin: case wxStdMin:
sprintf(timeBuf,"%2d:%02d",hh,GetMinute()); sprintf(timeBuf,"%2d:%02d",hh,GetMinute());
break; break;
} }
if (Format == wx12h) if (Format == wx12h)
if (GetHour() <= 12) if (GetHour() <= 12)
strcat(timeBuf,_("am")); strcat(timeBuf,_("am"));
else else
strcat(timeBuf,_("pm")); strcat(timeBuf,_("pm"));
return timeBuf; return timeBuf;
} }
/* /*
int wxTime::compare(const Object& ob) const int wxTime::compare(const Object& ob) const
{ {
assertArgSpecies(ob,classDesc,"compare"); assertArgSpecies(ob,classDesc,"compare");
register clockTy t = castdown(ob).sec; register clockTy t = castdown(ob).sec;
if (sec < t) return -1; if (sec < t) return -1;
if (sec > t) return 1; if (sec > t) return 1;
@@ -392,16 +389,16 @@ void wxTime::printOn(ostream& strm) const
wxDate(*this).printOn(strm); wxDate(*this).printOn(strm);
strm << ' ' << ((hh <= 12) ? hh : hh-12) << ':' strm << ' ' << ((hh <= 12) ? hh : hh-12) << ':'
<< setfill('0') << setw(2) << GetMinute() << ':' << setfill('0') << setw(2) << GetMinute() << ':'
<< setfill('0') << setw(2) << GetSecond() << ' '; << setfill('0') << setw(2) << GetSecond() << ' ';
if (hh < 12) strm << _("am"); if (hh < 12) strm << _("am");
else strm << _("pm"); else strm << _("pm");
} }
wxTime::wxTime(OIOin& strm) wxTime::wxTime(OIOin& strm)
: BASE(strm) : BASE(strm)
{ {
unsigned long usec; unsigned long usec;
strm >> sec >> usec; strm >> sec >> usec;
} }
void wxTime::storer(OIOout& strm) const void wxTime::storer(OIOout& strm) const
@@ -412,16 +409,16 @@ void wxTime::storer(OIOout& strm) const
wxTime::wxTime(OIOifd& fd) wxTime::wxTime(OIOifd& fd)
: BASE(fd) : BASE(fd)
{ {
unsigned long usec; unsigned long usec;
fd >> sec >> usec; fd >> sec >> usec;
} }
void wxTime::storer(OIOofd& fd) const void wxTime::storer(OIOofd& fd) const
{ {
BASE::storer(fd); BASE::storer(fd);
fd << sec << 0l; fd << sec << 0l;
} }
*/ */

331
src/common/utilscmn.cpp
View File

@@ -6,7 +6,7 @@
// Created: 29/01/98 // Created: 29/01/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) 1998 Julian Smart // Copyright: (c) 1998 Julian Smart
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__
@@ -30,15 +30,12 @@
#include "wx/textdlg.h" #include "wx/textdlg.h"
#endif #endif
#include "wx/ioswrap.h"
#if wxUSE_IOSTREAMH #if wxUSE_IOSTREAMH
#include <iostream.h> #include <fstream.h>
#include <fstream.h>
#else #else
#include <iostream> #include <fstream>
#include <fstream>
# ifdef _MSC_VER
using namespace std;
# endif
#endif #endif
#include <ctype.h> #include <ctype.h>
@@ -46,9 +43,9 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#if !defined(__WATCOMC__) #if !defined(__WATCOMC__)
#if !(defined(_MSC_VER) && (_MSC_VER > 800)) #if !(defined(_MSC_VER) && (_MSC_VER > 800))
#include <errno.h> #include <errno.h>
#endif #endif
#endif #endif
#include <time.h> #include <time.h>
#ifndef __MWERKS__ #ifndef __MWERKS__
@@ -98,7 +95,7 @@ int strncasecmp(const char *str_1, const char *str_2, size_t maxchar)
c2 = tolower(*str_2++); c2 = tolower(*str_2++);
if ( !c1 || c1!=c2 ) if ( !c1 || c1!=c2 )
return c1 - c2; return c1 - c2;
} ; } ;
@@ -163,14 +160,6 @@ int strncasecmp(const char *str_1, const char *str_2, size_t maxchar)
#endif #endif
#endif #endif
#ifdef _MSC_VER
#pragma warning (disable : 4245)
#endif
#ifdef _MSC_VER
#pragma warning (default : 4245)
#endif
#else #else
// This declaration is missing in SunOS! // This declaration is missing in SunOS!
// (Yes, I know it is NOT ANSI-C but its in BSD libc) // (Yes, I know it is NOT ANSI-C but its in BSD libc)
@@ -181,7 +170,7 @@ extern "C"
int strncasecmp (const char *, const char *, size_t); int strncasecmp (const char *, const char *, size_t);
} }
#endif #endif
#endif /* __WXMSW__ */ #endif /* __WXMSW__ */
char * char *
@@ -191,7 +180,7 @@ copystring (const char *s)
size_t len = strlen (s) + 1; size_t len = strlen (s) + 1;
char *news = new char[len]; char *news = new char[len];
memcpy (news, s, len); // Should be the fastest memcpy (news, s, len); // Should be the fastest
return news; return news;
} }
@@ -338,15 +327,15 @@ StringMatch (char *str1, char *str2, bool subString, bool exact)
// Search for str1 in str2 // Search for str1 in str2
// Slow .... but acceptable for short strings // Slow .... but acceptable for short strings
for (i = 0; i <= len2 - len1; i++) for (i = 0; i <= len2 - len1; i++)
{ {
if (strncasecmp (str1, str2 + i, len1) == 0) if (strncasecmp (str1, str2 + i, len1) == 0)
return TRUE; return TRUE;
} }
} }
else if (exact) else if (exact)
{ {
if (strcasecmp (str1, str2) == 0) if (strcasecmp (str1, str2) == 0)
return TRUE; return TRUE;
} }
else else
{ {
@@ -354,7 +343,7 @@ StringMatch (char *str1, char *str2, bool subString, bool exact)
int len2 = strlen (str2); int len2 = strlen (str2);
if (strncasecmp (str1, str2, wxMin (len1, len2)) == 0) if (strncasecmp (str1, str2, wxMin (len1, len2)) == 0)
return TRUE; return TRUE;
} }
return FALSE; return FALSE;
@@ -409,22 +398,22 @@ char *wxStripMenuCodes (char *in, char *out)
while (*in) while (*in)
{ {
if (*in == '&') if (*in == '&')
{ {
// Check && -> &, &x -> x // Check && -> &, &x -> x
if (*++in == '&') if (*++in == '&')
*out++ = *in++; *out++ = *in++;
} }
else if (*in == '\t') else if (*in == '\t')
{ {
// Remove all stuff after \t in X mode, and let the stuff as is // Remove all stuff after \t in X mode, and let the stuff as is
// in Windows mode. // in Windows mode.
// Accelerators are handled in wx_item.cc for Motif, and are not // Accelerators are handled in wx_item.cc for Motif, and are not
// YET supported in XView // YET supported in XView
break; break;
} }
else else
*out++ = *in++; *out++ = *in++;
} // while } // while
*out = '\0'; *out = '\0';
@@ -463,12 +452,12 @@ wxFindWindowByLabel (const wxString& title, wxWindow * parent)
else else
{ {
for (wxNode * node = wxTopLevelWindows.First (); node; node = node->Next ()) for (wxNode * node = wxTopLevelWindows.First (); node; node = node->Next ())
{ {
wxWindow *win = (wxWindow *) node->Data (); wxWindow *win = (wxWindow *) node->Data ();
wxWindow *retwin = wxFindWindowByLabel1 (title, win); wxWindow *retwin = wxFindWindowByLabel1 (title, win);
if (retwin) if (retwin)
return retwin; return retwin;
} // for() } // for()
} }
return (wxWindow *) NULL; return (wxWindow *) NULL;
@@ -481,22 +470,22 @@ wxFindWindowByLabel1 (const wxString& title, wxWindow * parent)
if (parent) if (parent)
{ {
if (parent->GetLabel() == title) if (parent->GetLabel() == title)
return parent; return parent;
} }
if (parent) if (parent)
{ {
for (wxNode * node = parent->GetChildren().First (); node; node = node->Next ()) for (wxNode * node = parent->GetChildren().First (); node; node = node->Next ())
{ {
wxWindow *win = (wxWindow *) node->Data (); wxWindow *win = (wxWindow *) node->Data ();
wxWindow *retwin = wxFindWindowByLabel1 (title, win); wxWindow *retwin = wxFindWindowByLabel1 (title, win);
if (retwin) if (retwin)
return retwin; return retwin;
} // for() } // for()
} }
return (wxWindow *) NULL; // Not found return (wxWindow *) NULL; // Not found
} }
@@ -518,12 +507,12 @@ wxFindWindowByName (const wxString& title, wxWindow * parent)
else else
{ {
for (wxNode * node = wxTopLevelWindows.First (); node; node = node->Next ()) for (wxNode * node = wxTopLevelWindows.First (); node; node = node->Next ())
{ {
wxWindow *win = (wxWindow *) node->Data (); wxWindow *win = (wxWindow *) node->Data ();
wxWindow *retwin = wxFindWindowByName1 (title, win); wxWindow *retwin = wxFindWindowByName1 (title, win);
if (retwin) if (retwin)
return retwin; return retwin;
} // for() } // for()
} }
// Failed? Try by label instead. // Failed? Try by label instead.
@@ -536,23 +525,23 @@ wxFindWindowByName1 (const wxString& title, wxWindow * parent)
{ {
if (parent) if (parent)
{ {
if ( parent->GetName() == title ) if ( parent->GetName() == title )
return parent; return parent;
} }
if (parent) if (parent)
{ {
for (wxNode * node = parent->GetChildren().First (); node; node = node->Next ()) for (wxNode * node = parent->GetChildren().First (); node; node = node->Next ())
{ {
wxWindow *win = (wxWindow *) node->Data (); wxWindow *win = (wxWindow *) node->Data ();
wxWindow *retwin = wxFindWindowByName1 (title, win); wxWindow *retwin = wxFindWindowByName1 (title, win);
if (retwin) if (retwin)
return retwin; return retwin;
} // for() } // for()
} }
return (wxWindow *) NULL; // Not found return (wxWindow *) NULL; // Not found
} }
@@ -599,7 +588,7 @@ static void
whereami(name) whereami(name)
char *name; char *name;
{ {
register char *cutoff = NULL; /* stifle -Wall */ register char *cutoff = NULL; /* stifle -Wall */
register char *s; register char *s;
register char *t; register char *t;
int cc; int cc;
@@ -612,117 +601,117 @@ whereami(name)
if (access(name, R_OK) == 0) { if (access(name, R_OK) == 0) {
/*-------------------------------------------------------------* /*-------------------------------------------------------------*
* The file was accessible without any other work. But the current * The file was accessible without any other work. But the current
* working directory might change on us, so if it was accessible * working directory might change on us, so if it was accessible
* through the cwd, then we should get it for later accesses. * through the cwd, then we should get it for later accesses.
*-------------------------------------------------------------*/ *-------------------------------------------------------------*/
t = imagedir; t = imagedir;
if (!absolute_pathname(name)) { if (!absolute_pathname(name)) {
#if defined(DOS) || defined(__WIN32__) #if defined(DOS) || defined(__WIN32__)
int drive; int drive;
char *newrbuf; char *newrbuf;
newrbuf = imagedir; newrbuf = imagedir;
#ifndef __DJGPP__ #ifndef __DJGPP__
if (*(name + 1) == ':') { if (*(name + 1) == ':') {
if (*name >= 'a' && *name <= 'z') if (*name >= 'a' && *name <= 'z')
drive = (int) (*name - 'a' + 1); drive = (int) (*name - 'a' + 1);
else else
drive = (int) (*name - 'A' + 1); drive = (int) (*name - 'A' + 1);
*newrbuf++ = *name; *newrbuf++ = *name;
*newrbuf++ = *(name + 1); *newrbuf++ = *(name + 1);
*newrbuf++ = DIR_SEPARATOR; *newrbuf++ = DIR_SEPARATOR;
} }
else { else {
drive = 0; drive = 0;
*newrbuf++ = DIR_SEPARATOR; *newrbuf++ = DIR_SEPARATOR;
} }
if (getcwd(newrbuf, drive) == 0) { /* } */ if (getcwd(newrbuf, drive) == 0) { /* } */
#else #else
if (getcwd(newrbuf, 1024) == 0) { /* } */ if (getcwd(newrbuf, 1024) == 0) { /* } */
#endif #endif
#else /* DOS */ #else /* DOS */
#ifdef HAVE_GETWD #ifdef HAVE_GETWD
if (getwd(imagedir) == 0) { /* } */ if (getwd(imagedir) == 0) { /* } */
#else /* !HAVE_GETWD */ #else /* !HAVE_GETWD */
if (getcwd(imagedir, 1024) == 0) { if (getcwd(imagedir, 1024) == 0) {
#endif /* !HAVE_GETWD */ #endif /* !HAVE_GETWD */
#endif /* DOS */ #endif /* DOS */
fatal_error(FE_GETCWD, 0); fatal_error(FE_GETCWD, 0);
} }
for (; *t; t++) /* Set t to end of buffer */ for (; *t; t++) /* Set t to end of buffer */
; ;
if (*(t - 1) == DIR_SEPARATOR) /* leave slash if already if (*(t - 1) == DIR_SEPARATOR) /* leave slash if already
* last char * last char
*/ */
cutoff = t - 1; cutoff = t - 1;
else { else {
cutoff = t; /* otherwise put one in */ cutoff = t; /* otherwise put one in */
*t++ = DIR_SEPARATOR; *t++ = DIR_SEPARATOR;
} }
} }
#if (!defined(__MAC__) && !defined(__DJGPP__) && !defined(__GO32__) && !defined(__WIN32__)) #if (!defined(__MAC__) && !defined(__DJGPP__) && !defined(__GO32__) && !defined(__WIN32__))
else else
(*t++ = DIR_SEPARATOR); (*t++ = DIR_SEPARATOR);
#endif #endif
/*-------------------------------------------------------------* /*-------------------------------------------------------------*
* Copy the rest of the string and set the cutoff if it was not * Copy the rest of the string and set the cutoff if it was not
* already set. If the first character of name is a slash, cutoff * already set. If the first character of name is a slash, cutoff
* is not presently set but will be on the first iteration of the * is not presently set but will be on the first iteration of the
* loop below. * loop below.
*-------------------------------------------------------------*/ *-------------------------------------------------------------*/
for ((*name == DIR_SEPARATOR ? (s = name+1) : (s = name));;) { for ((*name == DIR_SEPARATOR ? (s = name+1) : (s = name));;) {
if (*s == DIR_SEPARATOR) if (*s == DIR_SEPARATOR)
cutoff = t; cutoff = t;
if (!(*t++ = *s++)) if (!(*t++ = *s++))
break; break;
} }
} }
else { else {
/*-------------------------------------------------------------* /*-------------------------------------------------------------*
* Get the path list from the environment. If the path list is * Get the path list from the environment. If the path list is
* inaccessible for any reason, leave with fatal error. * inaccessible for any reason, leave with fatal error.
*-------------------------------------------------------------*/ *-------------------------------------------------------------*/
#ifdef __MAC__ #ifdef __MAC__
if ((s = getenv("Commands")) == (char *) 0) if ((s = getenv("Commands")) == (char *) 0)
#else #else
if ((s = getenv("PATH")) == (char *) 0) if ((s = getenv("PATH")) == (char *) 0)
#endif #endif
fatal_error(FE_PATH, 0); fatal_error(FE_PATH, 0);
/* /*
* Copy path list into ebuf and set the source pointer to the * Copy path list into ebuf and set the source pointer to the
* beginning of this buffer. * beginning of this buffer.
*/ */
strcpy(ebuf, s); strcpy(ebuf, s);
s = ebuf; s = ebuf;
for (;;) { for (;;) {
t = imagedir; t = imagedir;
while (*s && *s != PATH_SEPARATOR) while (*s && *s != PATH_SEPARATOR)
*t++ = *s++; *t++ = *s++;
if (t > imagedir && *(t - 1) == DIR_SEPARATOR) if (t > imagedir && *(t - 1) == DIR_SEPARATOR)
; /* do nothing -- slash already is in place */ ; /* do nothing -- slash already is in place */
else else
*t++ = DIR_SEPARATOR; /* put in the slash */ *t++ = DIR_SEPARATOR; /* put in the slash */
cutoff = t - 1; /* set cutoff */ cutoff = t - 1; /* set cutoff */
strcpy(t, name); strcpy(t, name);
if (access(imagedir, R_OK) == 0) if (access(imagedir, R_OK) == 0)
break; break;
if (*s) if (*s)
s++; /* advance source pointer */ s++; /* advance source pointer */
else else
fatal_error(FE_INFND, 0); fatal_error(FE_INFND, 0);
} }
} }
@@ -735,26 +724,26 @@ whereami(name)
#ifdef HAVE_SYMLINK #ifdef HAVE_SYMLINK
while ((cc = readlink(imagedir, ebuf, 512)) != -1) { while ((cc = readlink(imagedir, ebuf, 512)) != -1) {
ebuf[cc] = 0; ebuf[cc] = 0;
s = ebuf; s = ebuf;
if (*s == DIR_SEPARATOR) { if (*s == DIR_SEPARATOR) {
t = imagedir; t = imagedir;
} }
else { else {
t = cutoff + 1; t = cutoff + 1;
} }
for (;;) { for (;;) {
if (*s == DIR_SEPARATOR) if (*s == DIR_SEPARATOR)
cutoff = t; /* mark the last slash seen */ cutoff = t; /* mark the last slash seen */
if (!(*t++ = *s++)) /* copy the character */ if (!(*t++ = *s++)) /* copy the character */
break; break;
} }
} }
#endif /* HAVE_SYMLINK */ #endif /* HAVE_SYMLINK */
strcpy(imagename, cutoff + 1); /* keep the image name */ strcpy(imagename, cutoff + 1); /* keep the image name */
*(cutoff + 1) = 0; /* chop off the filename part */ *(cutoff + 1) = 0; /* chop off the filename part */
} }
#endif #endif
@@ -803,12 +792,12 @@ wxString wxGetTextFromUser(const wxString& message, const wxString& caption,
#ifdef __MWERKS__ #ifdef __MWERKS__
char *strdup(const char *s) char *strdup(const char *s)
{ {
return strcpy( (char*) malloc( strlen( s ) + 1 ) , s ) ; return strcpy( (char*) malloc( strlen( s ) + 1 ) , s ) ;
} }
int isascii( int c ) int isascii( int c )
{ {
return ( c >= 0 && c < 128 ) ; return ( c >= 0 && c < 128 ) ;
} }
#endif #endif

7
src/common/variant.cpp
View File

@@ -6,7 +6,7 @@
// Created: 10/09/98 // Created: 10/09/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) // Copyright: (c)
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__
@@ -17,16 +17,13 @@
#include "wx/wxprec.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__ #ifdef __BORLANDC__
#pragma hdrstop #pragma hdrstop
#endif #endif
#if wxUSE_IOSTREAMH #if wxUSE_IOSTREAMH
# include <fstream.h> # include <fstream.h>
#else #else
# include <fstream> # include <fstream>
# ifdef _MSC_VER
using namespace std;
# endif
#endif #endif
#include "wx/stream.h" #include "wx/stream.h"

9
src/common/wxexpr.cpp
View File

@@ -6,7 +6,7 @@
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem // Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__
@@ -21,12 +21,9 @@
#endif #endif
#if wxUSE_IOSTREAMH #if wxUSE_IOSTREAMH
#include <fstream.h> #include <fstream.h>
#else #else
#include <fstream> #include <fstream>
# ifdef _MSC_VER
using namespace std;
# endif
#endif #endif
#include <stdarg.h> #include <stdarg.h>

24
src/generic/helpxlp.cpp
View File

@@ -6,7 +6,7 @@
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem // Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__
@@ -67,8 +67,8 @@ IMPLEMENT_CLASS(wxXLPHelpController, wxHelpControllerBase)
#endif #endif
// suppress annoying warning "'this' used in base member init list" (so what?) // suppress annoying warning "'this' used in base member init list" (so what?)
#ifdef _MSC_VER #ifdef __VISUALC__
#pragma warning(disable: 4355) #pragma warning(disable: 4355)
#endif // Visual C++ #endif // Visual C++
wxXLPHelpController::wxXLPHelpController(void) wxXLPHelpController::wxXLPHelpController(void)
@@ -78,8 +78,8 @@ wxXLPHelpController::wxXLPHelpController(void)
helpRunning = FALSE; helpConnection = NULL; helpRunning = FALSE; helpConnection = NULL;
} }
#ifdef _MSC_VER #ifdef __VISUALC__
#pragma warning(default: 4355) #pragma warning(default: 4355)
#endif // Visual C++ #endif // Visual C++
wxXLPHelpController::~wxXLPHelpController(void) wxXLPHelpController::~wxXLPHelpController(void)
@@ -118,21 +118,21 @@ bool wxXLPHelpController::LoadFile(const wxString& file)
bool wxXLPHelpController::DisplayContents(void) bool wxXLPHelpController::DisplayContents(void)
{ {
if (!helpRunning) if (!helpRunning)
{ {
if (!Run()) if (!Run())
return FALSE; return FALSE;
} }
if (helpConnection) if (helpConnection)
return helpConnection->Execute("s -1"); return helpConnection->Execute("s -1");
else else
return FALSE; return FALSE;
} }
bool wxXLPHelpController::DisplaySection(int section) bool wxXLPHelpController::DisplaySection(int section)
{ {
if (!helpRunning) if (!helpRunning)
{ {
if (!Run()) if (!Run())
return FALSE; return FALSE;
} }
@@ -146,7 +146,7 @@ bool wxXLPHelpController::DisplaySection(int section)
bool wxXLPHelpController::DisplayBlock(long block) bool wxXLPHelpController::DisplayBlock(long block)
{ {
if (!helpRunning) if (!helpRunning)
{ {
if (!Run()) if (!Run())
return FALSE; return FALSE;
} }
@@ -160,7 +160,7 @@ bool wxXLPHelpController::DisplayBlock(long block)
bool wxXLPHelpController::KeywordSearch(const wxString& k) bool wxXLPHelpController::KeywordSearch(const wxString& k)
{ {
if (!helpRunning) if (!helpRunning)
{ {
if (!Run()) if (!Run())
return FALSE; return FALSE;
} }

12
src/msw/app.cpp
View File

@@ -227,7 +227,7 @@ bool wxApp::Initialize()
// This is to foil optimizations in Visual C++ that throw out dummy.obj. // This is to foil optimizations in Visual C++ that throw out dummy.obj.
// PLEASE DO NOT ALTER THIS. // PLEASE DO NOT ALTER THIS.
#if defined(_MSC_VER) && !defined(WXMAKINGDLL) #if defined(__VISUALC__) && !defined(WXMAKINGDLL)
extern char wxDummyChar; extern char wxDummyChar;
if (wxDummyChar) wxDummyChar++; if (wxDummyChar) wxDummyChar++;
#endif #endif
@@ -545,7 +545,7 @@ void wxApp::CleanUp()
#if !defined(_WINDLL) || (defined(_WINDLL) && defined(WXMAKINGDLL)) #if !defined(_WINDLL) || (defined(_WINDLL) && defined(WXMAKINGDLL))
// temporarily disable this warning // temporarily disable this warning
#ifdef _MSC_VER #ifdef __VISUALC__
#pragma warning(disable: 4715) // not all control paths return a value #pragma warning(disable: 4715) // not all control paths return a value
#endif // Visual C++ #endif // Visual C++
@@ -565,10 +565,10 @@ int wxEntry(WXHINSTANCE hInstance,
// FIXME other compilers must support Win32 SEH (structured exception // FIXME other compilers must support Win32 SEH (structured exception
// handling) too, just find the appropriate keyword in their docs! // handling) too, just find the appropriate keyword in their docs!
// Please note that it's _not_ the same as C++ exceptions! // Please note that it's _not_ the same as C++ exceptions!
#if !defined(__WXDEBUG__) && defined(_MSC_VER) && !defined(__MWERKS__) #if !defined(__WXDEBUG__) && defined(__VISUALC__)
#define CATCH_PROGRAM_EXCEPTIONS #define CATCH_PROGRAM_EXCEPTIONS
__try { __try {
#else #else
#undef CATCH_PROGRAM_EXCEPTIONS #undef CATCH_PROGRAM_EXCEPTIONS
#endif #endif
@@ -656,7 +656,7 @@ int wxEntry(WXHINSTANCE hInstance,
} }
// restore warning state // restore warning state
#ifdef _MSC_VER #ifdef __VISUALC__
#pragma warning(default: 4715) // not all control paths return a value #pragma warning(default: 4715) // not all control paths return a value
#endif // Visual C++ #endif // Visual C++
@@ -1123,6 +1123,6 @@ HINSTANCE wxGetInstance()
// For some reason, with MSVC++ 1.5, WinMain isn't linked in properly // For some reason, with MSVC++ 1.5, WinMain isn't linked in properly
// if in a separate file. So include it here to ensure it's linked. // if in a separate file. So include it here to ensure it's linked.
#if (defined(_MSC_VER) && !defined(__WIN32__)) || (defined(__GNUWIN32__) && !defined(__TWIN32__)) #if (defined(__VISUALC__) && !defined(__WIN32__)) || (defined(__GNUWIN32__) && !defined(__TWIN32__))
#include "main.cpp" #include "main.cpp"
#endif #endif

245
src/msw/dibutils.cpp
View File

@@ -6,7 +6,7 @@
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Microsoft, Julian Smart and Markus Holzem // Copyright: (c) Microsoft, Julian Smart and Markus Holzem
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__
@@ -29,13 +29,14 @@
#include <windows.h> #include <windows.h>
#include <windowsx.h> #include <windowsx.h>
#include <stdio.h> #include <stdio.h>
#include <wx/msw/dibutils.h>
#include "wx/msw/dibutils.h"
#if defined(__WIN32__) #if defined(__WIN32__)
#if !defined(__MWERKS__) && !defined(__SALFORDC__) #if !defined(__MWERKS__) && !defined(__SALFORDC__)
#include <memory.h> // for _fmemcpy() #include <memory.h> // for _fmemcpy()
#endif #endif
#define _huge #define _huge
#ifndef hmemcpy #ifndef hmemcpy
#define hmemcpy memcpy #define hmemcpy memcpy
#endif #endif
@@ -81,7 +82,7 @@ void ClearSystemPalette(void)
for(Counter = 0; Counter < 256; Counter++) for(Counter = 0; Counter < 256; Counter++)
{ {
Palette.aEntries[Counter].peRed = 0; Palette.aEntries[Counter].peRed = 0;
Palette.aEntries[Counter].peGreen = 0; Palette.aEntries[Counter].peGreen = 0;
Palette.aEntries[Counter].peBlue = 0; Palette.aEntries[Counter].peBlue = 0;
Palette.aEntries[Counter].peFlags = PC_NOCOLLAPSE; Palette.aEntries[Counter].peFlags = PC_NOCOLLAPSE;
} }
@@ -92,8 +93,8 @@ void ClearSystemPalette(void)
if (ScreenPalette) if (ScreenPalette)
{ {
ScreenPalette = SelectPalette(ScreenDC,ScreenPalette,FALSE); ScreenPalette = SelectPalette(ScreenDC,ScreenPalette,FALSE);
nMapped = RealizePalette(ScreenDC); nMapped = RealizePalette(ScreenDC);
ScreenPalette = SelectPalette(ScreenDC,ScreenPalette,FALSE); ScreenPalette = SelectPalette(ScreenDC,ScreenPalette,FALSE);
bOK = DeleteObject(ScreenPalette); bOK = DeleteObject(ScreenPalette);
} }
@@ -114,14 +115,14 @@ void ClearSystemPalette(void)
int DibWriteFile(LPSTR szFile, LPBITMAPINFOHEADER lpbi) int DibWriteFile(LPSTR szFile, LPBITMAPINFOHEADER lpbi)
{ {
HFILE fh; HFILE fh;
OFSTRUCT of; OFSTRUCT of;
fh = OpenFile(szFile, &of, OF_WRITE | OF_CREATE); fh = OpenFile(szFile, &of, OF_WRITE | OF_CREATE);
if (!fh) { if (!fh) {
// printf("la regamos0"); // printf("la regamos0");
return 0; return 0;
} }
long size = DibSize(lpbi); long size = DibSize(lpbi);
@@ -133,19 +134,19 @@ int DibWriteFile(LPSTR szFile, LPBITMAPINFOHEADER lpbi)
bmf.bfReserved1 = 0; bmf.bfReserved1 = 0;
bmf.bfReserved2 = 0; bmf.bfReserved2 = 0;
bmf.bfOffBits = sizeof(bmf) + (char far*)(DibPtr(lpbi)) - (char far*)lpbi; bmf.bfOffBits = sizeof(bmf) + (char far*)(DibPtr(lpbi)) - (char far*)lpbi;
#if defined( __WATCOMC__) || defined(_MSC_VER) || defined(__SC__) || defined(__SALFORDC__) #if defined( __WATCOMC__) || defined(__VISUALC__) || defined(__SC__) || defined(__SALFORDC__)
if (_hwrite(fh, (LPCSTR)(&bmf), sizeof(bmf))<0 || if (_hwrite(fh, (LPCSTR)(&bmf), sizeof(bmf))<0 ||
_hwrite(fh, (LPCSTR)lpbi, size)<0) { _hwrite(fh, (LPCSTR)lpbi, size)<0) {
_lclose(fh); _lclose(fh);
// printf("la regamos1"); // printf("la regamos1");
return 0; return 0;
} }
#else #else
if (_hwrite(fh, (LPBYTE)(&bmf), sizeof(bmf))<0 || if (_hwrite(fh, (LPBYTE)(&bmf), sizeof(bmf))<0 ||
_hwrite(fh, (LPBYTE)lpbi, size)<0) { _hwrite(fh, (LPBYTE)lpbi, size)<0) {
_lclose(fh); _lclose(fh);
// printf("la regamos1"); // printf("la regamos1");
return 0; return 0;
} }
#endif #endif
@@ -155,50 +156,50 @@ int DibWriteFile(LPSTR szFile, LPBITMAPINFOHEADER lpbi)
PDIB DibOpenFile(LPSTR szFile) PDIB DibOpenFile(LPSTR szFile)
{ {
HFILE fh; HFILE fh;
DWORD dwLen; DWORD dwLen;
DWORD dwBits; DWORD dwBits;
PDIB pdib; PDIB pdib;
LPVOID p; LPVOID p;
OFSTRUCT of; OFSTRUCT of;
#if defined(WIN32) || defined(_WIN32) #if defined(WIN32) || defined(_WIN32)
#define GetCurrentInstance() GetModuleHandle(NULL) #define GetCurrentInstance() GetModuleHandle(NULL)
#else #else
#define GetCurrentInstance() (HINSTANCE)SELECTOROF((LPVOID)&of) #define GetCurrentInstance() (HINSTANCE)SELECTOROF((LPVOID)&of)
#endif #endif
fh = OpenFile(szFile, &of, OF_READ); fh = OpenFile(szFile, &of, OF_READ);
if (fh == -1) if (fh == -1)
{ {
HRSRC h; HRSRC h;
// TODO: Unicode version // TODO: Unicode version
#ifdef __WIN16__ #ifdef __WIN16__
h = FindResource(GetCurrentInstance(), szFile, RT_BITMAP); h = FindResource(GetCurrentInstance(), szFile, RT_BITMAP);
#else #else
h = FindResourceA(GetCurrentInstance(), szFile, RT_BITMAP); h = FindResourceA(GetCurrentInstance(), szFile, RT_BITMAP);
#endif #endif
#if defined(__WIN32__) #if defined(__WIN32__)
//!!! can we call GlobalFree() on this? is it the right format. //!!! can we call GlobalFree() on this? is it the right format.
//!!! can we write to this resource? //!!! can we write to this resource?
if (h) if (h)
return (PDIB)LockResource(LoadResource(GetCurrentInstance(), h)); return (PDIB)LockResource(LoadResource(GetCurrentInstance(), h));
#else #else
if (h) if (h)
fh = AccessResource(GetCurrentInstance(), h); fh = AccessResource(GetCurrentInstance(), h);
#endif #endif
} }
if (fh == -1) if (fh == -1)
return NULL; return NULL;
pdib = DibReadBitmapInfo(fh); pdib = DibReadBitmapInfo(fh);
if (!pdib) if (!pdib)
return NULL; return NULL;
/* How much memory do we need to hold the DIB */ /* How much memory do we need to hold the DIB */
@@ -207,11 +208,11 @@ PDIB DibOpenFile(LPSTR szFile)
/* Can we get more memory? */ /* Can we get more memory? */
p = GlobalReAllocPtr(pdib,dwLen,0); p = GlobalReAllocPtr(pdib,dwLen,0);
if (!p) if (!p)
{ {
GlobalFreePtr(pdib); GlobalFreePtr(pdib);
pdib = NULL; pdib = NULL;
} }
else else
@@ -221,8 +222,8 @@ PDIB DibOpenFile(LPSTR szFile)
if (pdib) if (pdib)
{ {
/* read in the bits */ /* read in the bits */
_hread(fh, (LPBYTE)pdib + (UINT)pdib->biSize + DibPaletteSize(pdib), dwBits); _hread(fh, (LPBYTE)pdib + (UINT)pdib->biSize + DibPaletteSize(pdib), dwBits);
} }
_lclose(fh); _lclose(fh);
@@ -468,7 +469,7 @@ PDIB DibCreate(int bits, int dx, int dy)
*pdw++ = 0x00000000; // 0000 black *pdw++ = 0x00000000; // 0000 black
*pdw++ = 0x00800000; // 0001 dark red *pdw++ = 0x00800000; // 0001 dark red
*pdw++ = 0x00008000; // 0010 dark green *pdw++ = 0x00008000; // 0010 dark green
*pdw++ = 0x00808000; // 0011 mustard *pdw++ = 0x00808000; // 0011 mustard
*pdw++ = 0x00000080; // 0100 dark blue *pdw++ = 0x00000080; // 0100 dark blue
*pdw++ = 0x00800080; // 0101 purple *pdw++ = 0x00800080; // 0101 purple
*pdw++ = 0x00008080; // 0110 dark turquoise *pdw++ = 0x00008080; // 0110 dark turquoise
@@ -476,7 +477,7 @@ PDIB DibCreate(int bits, int dx, int dy)
*pdw++ = 0x00808080; // 0111 dark gray *pdw++ = 0x00808080; // 0111 dark gray
*pdw++ = 0x00FF0000; // 1001 red *pdw++ = 0x00FF0000; // 1001 red
*pdw++ = 0x0000FF00; // 1010 green *pdw++ = 0x0000FF00; // 1010 green
*pdw++ = 0x00FFFF00; // 1011 yellow *pdw++ = 0x00FFFF00; // 1011 yellow
*pdw++ = 0x000000FF; // 1100 blue *pdw++ = 0x000000FF; // 1100 blue
*pdw++ = 0x00FF00FF; // 1101 pink (magenta) *pdw++ = 0x00FF00FF; // 1101 pink (magenta)
*pdw++ = 0x0000FFFF; // 1110 cyan *pdw++ = 0x0000FFFF; // 1110 cyan
@@ -583,69 +584,69 @@ static void hmemmove(BYTE _huge *d, BYTE _huge *s, LONG len)
BOOL DibMapToPalette(PDIB pdib, HPALETTE hpal) BOOL DibMapToPalette(PDIB pdib, HPALETTE hpal)
{ {
LPBITMAPINFOHEADER lpbi; LPBITMAPINFOHEADER lpbi;
PALETTEENTRY pe; PALETTEENTRY pe;
int n; int n;
int nDibColors; int nDibColors;
int nPalColors=0; int nPalColors=0;
BYTE FAR * lpBits; BYTE FAR * lpBits;
RGBQUAD FAR * lpRgb; RGBQUAD FAR * lpRgb;
BYTE xlat[256]; BYTE xlat[256];
DWORD SizeImage; DWORD SizeImage;
if (!hpal || !pdib) if (!hpal || !pdib)
return FALSE; return FALSE;
lpbi = (LPBITMAPINFOHEADER)pdib; lpbi = (LPBITMAPINFOHEADER)pdib;
lpRgb = DibColors(pdib); lpRgb = DibColors(pdib);
GetObject(hpal,sizeof(int),(LPSTR)&nPalColors); GetObject(hpal,sizeof(int),(LPSTR)&nPalColors);
nDibColors = DibNumColors(pdib); nDibColors = DibNumColors(pdib);
if ((SizeImage = lpbi->biSizeImage) == 0) if ((SizeImage = lpbi->biSizeImage) == 0)
SizeImage = DibSizeImage(lpbi); SizeImage = DibSizeImage(lpbi);
// //
// build a xlat table. from the current DIB colors to the given // build a xlat table. from the current DIB colors to the given
// palette. // palette.
// //
for (n=0; n<nDibColors; n++) for (n=0; n<nDibColors; n++)
xlat[n] = (BYTE)GetNearestPaletteIndex(hpal,RGB(lpRgb[n].rgbRed,lpRgb[n].rgbGreen,lpRgb[n].rgbBlue)); xlat[n] = (BYTE)GetNearestPaletteIndex(hpal,RGB(lpRgb[n].rgbRed,lpRgb[n].rgbGreen,lpRgb[n].rgbBlue));
lpBits = (LPBYTE)DibPtr(lpbi); lpBits = (LPBYTE)DibPtr(lpbi);
lpbi->biClrUsed = nPalColors; lpbi->biClrUsed = nPalColors;
// //
// re-size the DIB // re-size the DIB
// //
if (nPalColors > nDibColors) if (nPalColors > nDibColors)
{ {
GlobalReAllocPtr(lpbi, lpbi->biSize + nPalColors*sizeof(RGBQUAD) + SizeImage, 0); GlobalReAllocPtr(lpbi, lpbi->biSize + nPalColors*sizeof(RGBQUAD) + SizeImage, 0);
hmemmove((BYTE _huge *)DibPtr(lpbi), (BYTE _huge *)lpBits, SizeImage); hmemmove((BYTE _huge *)DibPtr(lpbi), (BYTE _huge *)lpBits, SizeImage);
lpBits = (LPBYTE)DibPtr(lpbi); lpBits = (LPBYTE)DibPtr(lpbi);
} }
else if (nPalColors < nDibColors) else if (nPalColors < nDibColors)
{ {
hmemcpy(DibPtr(lpbi), lpBits, SizeImage); hmemcpy(DibPtr(lpbi), lpBits, SizeImage);
GlobalReAllocPtr(lpbi, lpbi->biSize + nPalColors*sizeof(RGBQUAD) + SizeImage, 0); GlobalReAllocPtr(lpbi, lpbi->biSize + nPalColors*sizeof(RGBQUAD) + SizeImage, 0);
lpBits = (LPBYTE)DibPtr(lpbi); lpBits = (LPBYTE)DibPtr(lpbi);
} }
// //
// translate the DIB bits // translate the DIB bits
// //
switch (lpbi->biCompression) switch (lpbi->biCompression)
{ {
case BI_RLE8: case BI_RLE8:
xlatRle8(lpBits, SizeImage, xlat); xlatRle8(lpBits, SizeImage, xlat);
break; break;
case BI_RLE4: case BI_RLE4:
xlatRle4(lpBits, SizeImage, xlat); xlatRle4(lpBits, SizeImage, xlat);
break; break;
case BI_RGB: case BI_RGB:
if (lpbi->biBitCount == 8) if (lpbi->biBitCount == 8)
xlatClut8(lpBits, SizeImage, xlat); xlatClut8(lpBits, SizeImage, xlat);
else else
xlatClut4(lpBits, SizeImage, xlat); xlatClut4(lpBits, SizeImage, xlat);
@@ -660,12 +661,12 @@ BOOL DibMapToPalette(PDIB pdib, HPALETTE hpal)
GetPaletteEntries(hpal,n,1,&pe); GetPaletteEntries(hpal,n,1,&pe);
lpRgb[n].rgbRed = pe.peRed; lpRgb[n].rgbRed = pe.peRed;
lpRgb[n].rgbGreen = pe.peGreen; lpRgb[n].rgbGreen = pe.peGreen;
lpRgb[n].rgbBlue = pe.peBlue; lpRgb[n].rgbBlue = pe.peBlue;
lpRgb[n].rgbReserved = (BYTE)0; lpRgb[n].rgbReserved = (BYTE)0;
} }
return TRUE; return TRUE;
} }
@@ -676,21 +677,21 @@ HPALETTE MakePalette(const BITMAPINFO FAR* Info, UINT flags)
WORD nColors = Info->bmiHeader.biClrUsed; WORD nColors = Info->bmiHeader.biClrUsed;
if (nColors) { if (nColors) {
LOGPALETTE* logPal = (LOGPALETTE*) LOGPALETTE* logPal = (LOGPALETTE*)
new BYTE[sizeof(LOGPALETTE) + (nColors-1)*sizeof(PALETTEENTRY)]; new BYTE[sizeof(LOGPALETTE) + (nColors-1)*sizeof(PALETTEENTRY)];
logPal->palVersion = 0x300; // Windows 3.0 version logPal->palVersion = 0x300; // Windows 3.0 version
logPal->palNumEntries = nColors; logPal->palNumEntries = nColors;
for (short n = 0; n < nColors; n++) { for (short n = 0; n < nColors; n++) {
logPal->palPalEntry[n].peRed = rgb[n].rgbRed; logPal->palPalEntry[n].peRed = rgb[n].rgbRed;
logPal->palPalEntry[n].peGreen = rgb[n].rgbGreen; logPal->palPalEntry[n].peGreen = rgb[n].rgbGreen;
logPal->palPalEntry[n].peBlue = rgb[n].rgbBlue; logPal->palPalEntry[n].peBlue = rgb[n].rgbBlue;
logPal->palPalEntry[n].peFlags = (BYTE)flags; logPal->palPalEntry[n].peFlags = (BYTE)flags;
} }
hPalette = ::CreatePalette(logPal); hPalette = ::CreatePalette(logPal);
delete logPal; delete logPal;
} else } else
hPalette = 0; hPalette = 0;
return hPalette; return hPalette;
} }

10
src/msw/dummy.cpp
View File

@@ -1,8 +1,8 @@
/* /*
* File: dummy.cc * File: dummy.cc
* Purpose: See below * Purpose: See below
* Author: Julian Smart * Author: Julian Smart
* Created: 1993 * Created: 1993
* Updated: * Updated:
* Copyright: (c) 1993, AIAI, University of Edinburgh * Copyright: (c) 1993, AIAI, University of Edinburgh
*/ */
@@ -40,7 +40,7 @@
// Foils optimizations in Visual C++ (see also app.cpp). Without it, // Foils optimizations in Visual C++ (see also app.cpp). Without it,
// dummy.obj isn't linked and we get a linker error. // dummy.obj isn't linked and we get a linker error.
#if defined(_MSC_VER) #if defined(__VISUALC__)
char wxDummyChar = 0; char wxDummyChar = 0;
#endif #endif

12
src/msw/dummydll.cpp
View File

@@ -1,13 +1,13 @@
/* /*
* File: dummydll.cc * File: dummydll.cc
* Purpose: * Purpose:
* Author: Julian Smart * Author: Julian Smart
* Created: 1993 * Created: 1993
* Updated: * Updated:
* Copyright: (c) 1993, AIAI, University of Edinburgh * Copyright: (c) 1993, AIAI, University of Edinburgh
*/ */
/* static const char sccsid[] = "@(#)dummydll.cc 1.2 5/9/94"; */ /* static const char sccsid[] = "@(#)dummydll.cc 1.2 5/9/94"; */
/* /*
* A dummy file to include wx.h. If precompiling wx.h, I * A dummy file to include wx.h. If precompiling wx.h, I
@@ -19,7 +19,7 @@
// Foils optimizations in Visual C++ (see also app.cpp). Without it, // Foils optimizations in Visual C++ (see also app.cpp). Without it,
// dummy.obj isn't linked and we get a linker error. // dummy.obj isn't linked and we get a linker error.
#if defined(_MSC_VER) && defined(__WIN16__) #if defined(__VISUALC__) && defined(__WIN16__)
char wxDummyChar=0; char wxDummyChar=0;
#endif #endif

4
src/msw/ole/dataobj.cpp
View File

@@ -359,7 +359,7 @@ const char *wxDataObject::GetFormatName(wxDataFormat format)
{ {
#ifdef __WXDEBUG__ #ifdef __WXDEBUG__
// case 'xxx' is not a valid value for switch of enum 'wxDataFormat' // case 'xxx' is not a valid value for switch of enum 'wxDataFormat'
#ifdef _MSC_VER #ifdef __VISUALC__
#pragma warning(disable:4063) #pragma warning(disable:4063)
#endif // VC++ #endif // VC++
@@ -386,7 +386,7 @@ const char *wxDataObject::GetFormatName(wxDataFormat format)
return s_szBuf; return s_szBuf;
} }
#ifdef _MSC_VER #ifdef __VISUALC__
#pragma warning(default:4063) #pragma warning(default:4063)
#endif // VC++ #endif // VC++

6
src/msw/ole/oleutils.cpp
View File

@@ -37,8 +37,8 @@
#include <wx/msw/ole/uuid.h> #include <wx/msw/ole/uuid.h>
#include <wx/msw/ole/oleutils.h> #include <wx/msw/ole/oleutils.h>
#if defined(_MSC_VER) && (_MSC_VER > 1000) #if defined(__VISUALC__) && (__VISUALC__ > 1000)
#include <docobj.h> #include <docobj.h>
#endif #endif
// ============================================================================ // ============================================================================
@@ -62,7 +62,7 @@ bool IsIidFromList(REFIID riid, const IID *aIids[], size_t nCount)
// Debug support // Debug support
// ---------------------------------------------------------------------------- // ----------------------------------------------------------------------------
#if defined(__WXDEBUG__) && defined(_MSC_VER) && (_MSC_VER > 1000) #if defined(__WXDEBUG__) && defined(__VISUALC__) && (__VISUALC__ > 1000)
const char *GetIidName(REFIID riid) const char *GetIidName(REFIID riid)
{ {
// an association between symbolic name and numeric value of an IID // an association between symbolic name and numeric value of an IID

471
src/msw/pnghand.cpp
View File

@@ -6,7 +6,7 @@
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem // Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__
@@ -26,12 +26,9 @@
#include <string.h> #include <string.h>
#if wxUSE_IOSTREAMH #if wxUSE_IOSTREAMH
#include <fstream.h> # include <fstream.h>
#else #else
#include <fstream> # include <fstream>
# ifdef _MSC_VER
using namespace std;
# endif
#endif #endif
#include <windows.h> #include <windows.h>
@@ -70,7 +67,7 @@ ima_png_error(png_struct *png_ptr, char *message)
{ {
// wxMessageBox(message, "PNG error"); // wxMessageBox(message, "PNG error");
longjmp(png_ptr->jmpbuf, 1); longjmp(png_ptr->jmpbuf, 1);
} }
@@ -80,15 +77,15 @@ wxPalette *wxCopyPalette(const wxPalette *cmap);
wxPNGReader::wxPNGReader(void) wxPNGReader::wxPNGReader(void)
{ {
filetype = 0; filetype = 0;
RawImage = NULL; // Image data RawImage = NULL; // Image data
Width = 0; Height = 0; // Dimensions Width = 0; Height = 0; // Dimensions
Depth = 0; // (bits x pixel) Depth = 0; // (bits x pixel)
ColorType = 0; // Bit 1 = Palette used ColorType = 0; // Bit 1 = Palette used
// Bit 2 = Color used // Bit 2 = Color used
// Bit 3 = Alpha used // Bit 3 = Alpha used
EfeWidth = 0; // Efective Width EfeWidth = 0; // Efective Width
lpbi = NULL; lpbi = NULL;
bgindex = -1; bgindex = -1;
@@ -100,15 +97,15 @@ wxPNGReader::wxPNGReader ( char* ImageFileName )
{ {
imageOK = FALSE; imageOK = FALSE;
filetype = 0; filetype = 0;
RawImage = NULL; // Image data RawImage = NULL; // Image data
Width = 0; Height = 0; // Dimensions Width = 0; Height = 0; // Dimensions
Depth = 0; // (bits x pixel) Depth = 0; // (bits x pixel)
ColorType = 0; // Bit 1 = Palette used ColorType = 0; // Bit 1 = Palette used
// Bit 2 = Color used // Bit 2 = Color used
// Bit 3 = Alpha used // Bit 3 = Alpha used
EfeWidth = 0; // Efective Width EfeWidth = 0; // Efective Width
lpbi = NULL; lpbi = NULL;
bgindex = -1; bgindex = -1;
@@ -125,17 +122,17 @@ wxPNGReader::Create(int width, int height, int depth, int colortype)
if (lpbi) { if (lpbi) {
#ifdef __WIN16__ #ifdef __WIN16__
GlobalFreePtr((unsigned int) lpbi); GlobalFreePtr((unsigned int) lpbi);
#else #else
GlobalFreePtr(lpbi); GlobalFreePtr(lpbi);
#endif #endif
// delete Palette; // delete Palette;
} }
RawImage = 0; RawImage = 0;
Palette = 0; Palette = 0;
if (lpbi = DibCreate(Depth, Width, Height)) { if (lpbi = DibCreate(Depth, Width, Height)) {
RawImage = (ImagePointerType)DibPtr(lpbi); RawImage = (ImagePointerType)DibPtr(lpbi);
EfeWidth = (long)(((long)Width*Depth + 31) / 32) * 4; EfeWidth = (long)(((long)Width*Depth + 31) / 32) * 4;
imageOK = TRUE; imageOK = TRUE;
} }
} }
@@ -144,11 +141,11 @@ wxPNGReader::~wxPNGReader ( )
{ {
if (lpbi) { if (lpbi) {
#ifdef __WIN16__ #ifdef __WIN16__
GlobalFreePtr((unsigned int) lpbi); GlobalFreePtr((unsigned int) lpbi);
#else #else
GlobalFreePtr(lpbi); GlobalFreePtr(lpbi);
#endif #endif
delete Palette; delete Palette;
} }
} }
@@ -167,17 +164,17 @@ bool wxPNGReader::GetRGB(int x, int y, byte* r, byte* g, byte* b)
if (!Inside(x, y)) return FALSE; if (!Inside(x, y)) return FALSE;
if (Palette) { if (Palette) {
return Palette->GetRGB(GetIndex(x, y), r, g, b); return Palette->GetRGB(GetIndex(x, y), r, g, b);
/* PALETTEENTRY entry; /* PALETTEENTRY entry;
::GetPaletteEntries((HPALETTE) Palette->GetHPALETTE(), GetIndex(x, y), 1, &entry); ::GetPaletteEntries((HPALETTE) Palette->GetHPALETTE(), GetIndex(x, y), 1, &entry);
*r = entry.peRed; *r = entry.peRed;
*g = entry.peGreen; *g = entry.peGreen;
*b = entry.peBlue; */ *b = entry.peBlue; */
} else { } else {
ImagePointerType ImagePointer = RawImage + EfeWidth*y + (x*Depth >> 3); ImagePointerType ImagePointer = RawImage + EfeWidth*y + (x*Depth >> 3);
*b = ImagePointer[0]; *b = ImagePointer[0];
*g = ImagePointer[1]; *g = ImagePointer[1];
*r = ImagePointer[2]; *r = ImagePointer[2];
} }
return TRUE; return TRUE;
} }
@@ -199,14 +196,14 @@ bool wxPNGReader::SetRGB(int x, int y, byte r, byte g, byte b)
if (ColorType & COLORTYPE_PALETTE) if (ColorType & COLORTYPE_PALETTE)
{ {
if (!Palette) return FALSE; if (!Palette) return FALSE;
SetIndex(x, y, Palette->GetPixel(r, g, b)); SetIndex(x, y, Palette->GetPixel(r, g, b));
} else { } else {
ImagePointerType ImagePointer = RawImage + EfeWidth*y + (x*Depth >> 3); ImagePointerType ImagePointer = RawImage + EfeWidth*y + (x*Depth >> 3);
ImagePointer[0] = b; ImagePointer[0] = b;
ImagePointer[1] = g; ImagePointer[1] = g;
ImagePointer[2] = r; ImagePointer[2] = r;
} }
return TRUE; return TRUE;
@@ -215,7 +212,7 @@ bool wxPNGReader::SetRGB(int x, int y, byte r, byte g, byte b)
bool wxPNGReader::SetPalette(wxPalette* colourmap) bool wxPNGReader::SetPalette(wxPalette* colourmap)
{ {
if (!colourmap) if (!colourmap)
return FALSE; return FALSE;
ColorType |= (COLORTYPE_PALETTE | COLORTYPE_COLOR); ColorType |= (COLORTYPE_PALETTE | COLORTYPE_COLOR);
Palette = colourmap; Palette = colourmap;
return (DibSetUsage(lpbi, (HPALETTE) Palette->GetHPALETTE(), WXIMA_COLORS ) != 0); return (DibSetUsage(lpbi, (HPALETTE) Palette->GetHPALETTE(), WXIMA_COLORS ) != 0);
@@ -226,7 +223,7 @@ wxPNGReader::SetPalette(int n, byte *r, byte *g, byte *b)
{ {
Palette = new wxPalette(); Palette = new wxPalette();
if (!Palette) if (!Palette)
return FALSE; return FALSE;
if (!g) g = r; if (!g) g = r;
if (!b) b = g; if (!b) b = g;
@@ -240,15 +237,15 @@ wxPNGReader::SetPalette(int n, rgb_color_struct *rgb_struct)
{ {
Palette = new wxPalette(); Palette = new wxPalette();
if (!Palette) if (!Palette)
return FALSE; return FALSE;
byte r[256], g[256], b[256]; byte r[256], g[256], b[256];
for(int i=0; i<n; i++) for(int i=0; i<n; i++)
{ {
r[i] = rgb_struct[i].red; r[i] = rgb_struct[i].red;
g[i] = rgb_struct[i].green; g[i] = rgb_struct[i].green;
b[i] = rgb_struct[i].blue; b[i] = rgb_struct[i].blue;
} }
// Added by JACS copying from Andrew Davison's additions // Added by JACS copying from Andrew Davison's additions
// to GIF-reading code // to GIF-reading code
@@ -281,10 +278,10 @@ wxBitmap* wxPNGReader::GetBitmap(void)
bool wxPNGReader::InstantiateBitmap(wxBitmap *bitmap) bool wxPNGReader::InstantiateBitmap(wxBitmap *bitmap)
{ {
HDC dc = ::CreateCompatibleDC(NULL); HDC dc = ::CreateCompatibleDC(NULL);
if (dc) if (dc)
{ {
// tmpBitmap is a dummy, to satisfy ::CreateCompatibleDC (it // tmpBitmap is a dummy, to satisfy ::CreateCompatibleDC (it
// is a memory dc that must have a bitmap selected into it) // is a memory dc that must have a bitmap selected into it)
HDC dc2 = GetDC(NULL); HDC dc2 = GetDC(NULL);
@@ -295,11 +292,11 @@ bool wxPNGReader::InstantiateBitmap(wxBitmap *bitmap)
if ( Palette ) if ( Palette )
{ {
HPALETTE oldPal = ::SelectPalette(dc, (HPALETTE) Palette->GetHPALETTE(), FALSE); HPALETTE oldPal = ::SelectPalette(dc, (HPALETTE) Palette->GetHPALETTE(), FALSE);
::RealizePalette(dc); ::RealizePalette(dc);
} }
HBITMAP hBitmap = ::CreateDIBitmap(dc, lpbi, HBITMAP hBitmap = ::CreateDIBitmap(dc, lpbi,
CBM_INIT, RawImage, (LPBITMAPINFO) lpbi, DIB_PAL_COLORS); CBM_INIT, RawImage, (LPBITMAPINFO) lpbi, DIB_PAL_COLORS);
::SelectPalette(dc, NULL, TRUE); ::SelectPalette(dc, NULL, TRUE);
::SelectObject(dc, oldBitmap); ::SelectObject(dc, oldBitmap);
@@ -323,16 +320,16 @@ bool wxPNGReader::InstantiateBitmap(wxBitmap *bitmap)
wxMask *mask = CreateMask(); wxMask *mask = CreateMask();
bitmap->SetMask(mask); bitmap->SetMask(mask);
} }
return TRUE; return TRUE;
} }
else else
{ {
return FALSE; return FALSE;
} }
} }
else else
{ {
return FALSE; return FALSE;
} }
} }
@@ -343,7 +340,7 @@ wxPalette *wxCopyPalette(const wxPalette *cmap)
::GetObject((HPALETTE) cmap->GetHPALETTE(), sizeof(WORD), &count); ::GetObject((HPALETTE) cmap->GetHPALETTE(), sizeof(WORD), &count);
LOGPALETTE* logPal = (LOGPALETTE*) LOGPALETTE* logPal = (LOGPALETTE*)
new BYTE[sizeof(LOGPALETTE) + count*sizeof(PALETTEENTRY)]; new BYTE[sizeof(LOGPALETTE) + count*sizeof(PALETTEENTRY)];
logPal->palVersion = 0x300; logPal->palVersion = 0x300;
logPal->palNumEntries = count; logPal->palNumEntries = count;
::GetPaletteEntries((HPALETTE) cmap->GetHPALETTE(), 0, count, logPal->palPalEntry); ::GetPaletteEntries((HPALETTE) cmap->GetHPALETTE(), 0, count, logPal->palPalEntry);
@@ -360,7 +357,7 @@ wxMask *wxPNGReader::CreateMask(void)
{ {
HBITMAP hBitmap = ::CreateBitmap(GetWidth(), GetHeight(), 1, 1, NULL); HBITMAP hBitmap = ::CreateBitmap(GetWidth(), GetHeight(), 1, 1, NULL);
HDC dc = ::CreateCompatibleDC(NULL); HDC dc = ::CreateCompatibleDC(NULL);
HBITMAP oldBitmap = (HBITMAP) ::SelectObject(dc, hBitmap); HBITMAP oldBitmap = (HBITMAP) ::SelectObject(dc, hBitmap);
int bgIndex = GetBGIndex(); int bgIndex = GetBGIndex();
@@ -377,7 +374,7 @@ wxMask *wxPNGReader::CreateMask(void)
else else
::SetPixel(dc, x, GetHeight() - y - 1, RGB(255, 255, 255)); ::SetPixel(dc, x, GetHeight() - y - 1, RGB(255, 255, 255));
} }
} }
::SelectObject(dc, oldBitmap); ::SelectObject(dc, oldBitmap);
wxMask *mask = new wxMask; wxMask *mask = new wxMask;
@@ -390,138 +387,138 @@ bool wxPNGReader::ReadFile(char * ImageFileName)
int number_passes; int number_passes;
if (ImageFileName) if (ImageFileName)
strcpy(filename, ImageFileName); strcpy(filename, ImageFileName);
FILE *fp; FILE *fp;
png_struct *png_ptr; png_struct *png_ptr;
png_info *info_ptr; png_info *info_ptr;
wxPNGReaderIter iter(this); wxPNGReaderIter iter(this);
/* open the file */ /* open the file */
fp = fopen(filename, "rb"); fp = fopen(filename, "rb");
if (!fp) if (!fp)
return FALSE; return FALSE;
/* allocate the necessary structures */ /* allocate the necessary structures */
png_ptr = new (png_struct); png_ptr = new (png_struct);
if (!png_ptr) if (!png_ptr)
{ {
fclose(fp); fclose(fp);
return FALSE; return FALSE;
} }
info_ptr = new (png_info); info_ptr = new (png_info);
if (!info_ptr) if (!info_ptr)
{ {
fclose(fp); fclose(fp);
delete(png_ptr); delete(png_ptr);
return FALSE; return FALSE;
} }
/* set error handling */ /* set error handling */
if (setjmp(png_ptr->jmpbuf)) if (setjmp(png_ptr->jmpbuf))
{ {
png_read_destroy(png_ptr, info_ptr, (png_info *)0); png_read_destroy(png_ptr, info_ptr, (png_info *)0);
fclose(fp); fclose(fp);
delete(png_ptr); delete(png_ptr);
delete(info_ptr); delete(info_ptr);
/* If we get here, we had a problem reading the file */ /* If we get here, we had a problem reading the file */
return FALSE; return FALSE;
} }
//png_set_error(ima_png_error, NULL); //png_set_error(ima_png_error, NULL);
/* initialize the structures, info first for error handling */ /* initialize the structures, info first for error handling */
png_info_init(info_ptr); png_info_init(info_ptr);
png_read_init(png_ptr); png_read_init(png_ptr);
/* set up the input control */ /* set up the input control */
png_init_io(png_ptr, fp); png_init_io(png_ptr, fp);
/* read the file information */ /* read the file information */
png_read_info(png_ptr, info_ptr); png_read_info(png_ptr, info_ptr);
/* allocate the memory to hold the image using the fields /* allocate the memory to hold the image using the fields
of png_info. */ of png_info. */
png_color_16 my_background={ 0, 31, 127, 255, 0 }; png_color_16 my_background={ 0, 31, 127, 255, 0 };
if (info_ptr->valid & PNG_INFO_bKGD) if (info_ptr->valid & PNG_INFO_bKGD)
{ {
png_set_background(png_ptr, &(info_ptr->background), png_set_background(png_ptr, &(info_ptr->background),
PNG_BACKGROUND_GAMMA_FILE, 1, 1.0); PNG_BACKGROUND_GAMMA_FILE, 1, 1.0);
if ( info_ptr->num_palette > 0 ) if ( info_ptr->num_palette > 0 )
bgindex = info_ptr->background.index; bgindex = info_ptr->background.index;
} }
else { else {
png_set_background(png_ptr, &my_background, png_set_background(png_ptr, &my_background,
PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0); PNG_BACKGROUND_GAMMA_SCREEN, 0, 1.0);
// Added by JACS: guesswork! // Added by JACS: guesswork!
if ( info_ptr->num_trans != 0 ) if ( info_ptr->num_trans != 0 )
bgindex = info_ptr->num_trans - 1 ; bgindex = info_ptr->num_trans - 1 ;
} }
/* tell libpng to strip 16 bit depth files down to 8 bits */ /* tell libpng to strip 16 bit depth files down to 8 bits */
if (info_ptr->bit_depth == 16) if (info_ptr->bit_depth == 16)
png_set_strip_16(png_ptr); png_set_strip_16(png_ptr);
int pixel_depth=(info_ptr->pixel_depth<24) ? info_ptr->pixel_depth: 24; int pixel_depth=(info_ptr->pixel_depth<24) ? info_ptr->pixel_depth: 24;
Create(info_ptr->width, info_ptr->height, pixel_depth, Create(info_ptr->width, info_ptr->height, pixel_depth,
info_ptr->color_type); info_ptr->color_type);
if (info_ptr->num_palette>0) if (info_ptr->num_palette>0)
{ {
SetPalette((int)info_ptr->num_palette, (rgb_color_struct*)info_ptr->palette); SetPalette((int)info_ptr->num_palette, (rgb_color_struct*)info_ptr->palette);
} }
int row_stride = info_ptr->width * ((pixel_depth+7)>>3); int row_stride = info_ptr->width * ((pixel_depth+7)>>3);
// printf("P = %d D = %d RS= %d ", info_ptr->num_palette, info_ptr->pixel_depth,row_stride); // printf("P = %d D = %d RS= %d ", info_ptr->num_palette, info_ptr->pixel_depth,row_stride);
// printf("CT = %d TRS = %d BD= %d ", info_ptr->color_type, info_ptr->valid & PNG_INFO_tRNS,info_ptr->bit_depth); // printf("CT = %d TRS = %d BD= %d ", info_ptr->color_type, info_ptr->valid & PNG_INFO_tRNS,info_ptr->bit_depth);
byte *row_pointers = new byte[row_stride]; byte *row_pointers = new byte[row_stride];
/* turn on interlace handling */ /* turn on interlace handling */
if (info_ptr->interlace_type) if (info_ptr->interlace_type)
number_passes = png_set_interlace_handling(png_ptr); number_passes = png_set_interlace_handling(png_ptr);
else else
number_passes = 1; number_passes = 1;
// printf("NP = %d ", number_passes); // printf("NP = %d ", number_passes);
for (int pass=0; pass< number_passes; pass++) { for (int pass=0; pass< number_passes; pass++) {
iter.upset(); iter.upset();
int y=0; int y=0;
do { do {
// (unsigned char *)iter.GetRow(); // (unsigned char *)iter.GetRow();
if (info_ptr->interlace_type) { if (info_ptr->interlace_type) {
if (pass>0) if (pass>0)
iter.GetRow(row_pointers, row_stride); iter.GetRow(row_pointers, row_stride);
png_read_row(png_ptr, row_pointers, NULL); png_read_row(png_ptr, row_pointers, NULL);
} }
else else
png_read_row(png_ptr, row_pointers, NULL); png_read_row(png_ptr, row_pointers, NULL);
iter.SetRow(row_pointers, row_stride); iter.SetRow(row_pointers, row_stride);
y++; y++;
} while(iter.PrevRow()); } while(iter.PrevRow());
// printf("Y=%d ",y); // printf("Y=%d ",y);
} }
delete[] row_pointers; delete[] row_pointers;
/* read the rest of the file, getting any additional chunks /* read the rest of the file, getting any additional chunks
in info_ptr */ in info_ptr */
png_read_end(png_ptr, info_ptr); png_read_end(png_ptr, info_ptr);
/* clean up after the read, and free any memory allocated */ /* clean up after the read, and free any memory allocated */
png_read_destroy(png_ptr, info_ptr, (png_info *)0); png_read_destroy(png_ptr, info_ptr, (png_info *)0);
/* free the structures */ /* free the structures */
delete(png_ptr); delete(png_ptr);
delete(info_ptr); delete(info_ptr);
/* close the file */ /* close the file */
fclose(fp); fclose(fp);
/* that's it */ /* that's it */
return TRUE; return TRUE;
} }
@@ -530,91 +527,91 @@ bool wxPNGReader::ReadFile(char * ImageFileName)
bool wxPNGReader::SaveFile(char * ImageFileName) bool wxPNGReader::SaveFile(char * ImageFileName)
{ {
if (ImageFileName) if (ImageFileName)
strcpy(filename, ImageFileName); strcpy(filename, ImageFileName);
wxPNGReaderIter iter(this); wxPNGReaderIter iter(this);
FILE *fp; FILE *fp;
png_struct *png_ptr; png_struct *png_ptr;
png_info *info_ptr; png_info *info_ptr;
/* open the file */ /* open the file */
fp = fopen(filename, "wb"); fp = fopen(filename, "wb");
if (!fp) if (!fp)
return FALSE; return FALSE;
/* allocate the necessary structures */ /* allocate the necessary structures */
png_ptr = new (png_struct); png_ptr = new (png_struct);
if (!png_ptr) if (!png_ptr)
{ {
fclose(fp); fclose(fp);
return FALSE; return FALSE;
} }
info_ptr = new (png_info); info_ptr = new (png_info);
if (!info_ptr) if (!info_ptr)
{ {
fclose(fp); fclose(fp);
delete(png_ptr); delete(png_ptr);
return FALSE; return FALSE;
} }
/* set error handling */ /* set error handling */
if (setjmp(png_ptr->jmpbuf)) if (setjmp(png_ptr->jmpbuf))
{ {
png_write_destroy(png_ptr); png_write_destroy(png_ptr);
fclose(fp); fclose(fp);
delete(png_ptr); delete(png_ptr);
delete(info_ptr); delete(info_ptr);
/* If we get here, we had a problem reading the file */ /* If we get here, we had a problem reading the file */
return FALSE; return FALSE;
} }
//png_set_error(ima_png_error, NULL); //png_set_error(ima_png_error, NULL);
// printf("writig pg %s ", filename); // printf("writig pg %s ", filename);
/* initialize the structures */ /* initialize the structures */
png_info_init(info_ptr); png_info_init(info_ptr);
png_write_init(png_ptr); png_write_init(png_ptr);
int row_stride = GetWidth() * ((GetDepth()+7)>>3); int row_stride = GetWidth() * ((GetDepth()+7)>>3);
/* set up the output control */ /* set up the output control */
png_init_io(png_ptr, fp); png_init_io(png_ptr, fp);
/* set the file information here */ /* set the file information here */
info_ptr->width = GetWidth(); info_ptr->width = GetWidth();
info_ptr->height = GetHeight(); info_ptr->height = GetHeight();
info_ptr->pixel_depth = GetDepth(); info_ptr->pixel_depth = GetDepth();
info_ptr->channels = (GetDepth()>8) ? 3: 1; info_ptr->channels = (GetDepth()>8) ? 3: 1;
info_ptr->bit_depth = GetDepth()/info_ptr->channels; info_ptr->bit_depth = GetDepth()/info_ptr->channels;
info_ptr->color_type = GetColorType(); info_ptr->color_type = GetColorType();
info_ptr->compression_type = info_ptr->filter_type = info_ptr->interlace_type=0; info_ptr->compression_type = info_ptr->filter_type = info_ptr->interlace_type=0;
info_ptr->valid = 0; info_ptr->valid = 0;
info_ptr->rowbytes = row_stride; info_ptr->rowbytes = row_stride;
// printf("P = %d D = %d RS= %d GD= %d CH= %d ", info_ptr->pixel_depth, info_ptr->bit_depth, row_stride, GetDepth(), info_ptr->channels); // printf("P = %d D = %d RS= %d GD= %d CH= %d ", info_ptr->pixel_depth, info_ptr->bit_depth, row_stride, GetDepth(), info_ptr->channels);
/* set the palette if there is one */ /* set the palette if there is one */
if ((GetColorType() & COLORTYPE_PALETTE) && GetPalette()) if ((GetColorType() & COLORTYPE_PALETTE) && GetPalette())
{ {
// printf("writing paleta[%d %d %x]",GetColorType() ,COLORTYPE_PALETTE, GetPalette()); // printf("writing paleta[%d %d %x]",GetColorType() ,COLORTYPE_PALETTE, GetPalette());
info_ptr->valid |= PNG_INFO_PLTE; info_ptr->valid |= PNG_INFO_PLTE;
info_ptr->palette = new png_color[256]; info_ptr->palette = new png_color[256];
info_ptr->num_palette = 256; info_ptr->num_palette = 256;
for (int i=0; i<256; i++) for (int i=0; i<256; i++)
GetPalette()->GetRGB(i, &info_ptr->palette[i].red, &info_ptr->palette[i].green, &info_ptr->palette[i].blue); GetPalette()->GetRGB(i, &info_ptr->palette[i].red, &info_ptr->palette[i].green, &info_ptr->palette[i].blue);
} }
// printf("Paleta [%d %d %x]",GetColorType() ,COLORTYPE_PALETTE, GetPalette()); // printf("Paleta [%d %d %x]",GetColorType() ,COLORTYPE_PALETTE, GetPalette());
/* optional significant bit chunk */ /* optional significant bit chunk */
// info_ptr->valid |= PNG_INFO_sBIT; // info_ptr->valid |= PNG_INFO_sBIT;
// info_ptr->sig_bit = true_bit_depth; // info_ptr->sig_bit = true_bit_depth;
/* optional gamma chunk */ /* optional gamma chunk */
// info_ptr->valid |= PNG_INFO_gAMA; // info_ptr->valid |= PNG_INFO_gAMA;
// info_ptr->gamma = gamma; // info_ptr->gamma = gamma;
/* other optional chunks */ /* other optional chunks */
/* write the file information */ /* write the file information */
png_write_info(png_ptr, info_ptr); png_write_info(png_ptr, info_ptr);
@@ -622,14 +619,14 @@ bool wxPNGReader::SaveFile(char * ImageFileName)
/* set up the transformations you want. Note that these are /* set up the transformations you want. Note that these are
all optional. Only call them if you want them */ all optional. Only call them if you want them */
/* shift the pixels up to a legal bit depth and fill in /* shift the pixels up to a legal bit depth and fill in
as appropriate to correctly scale the image */ as appropriate to correctly scale the image */
// png_set_shift(png_ptr, &(info_ptr->sig_bit)); // png_set_shift(png_ptr, &(info_ptr->sig_bit));
/* pack pixels into bytes */ /* pack pixels into bytes */
// png_set_packing(png_ptr); // png_set_packing(png_ptr);
/* flip bgr pixels to rgb */ /* flip bgr pixels to rgb */
// png_set_bgr(png_ptr); // png_set_bgr(png_ptr);
/* swap bytes of 16 bit files to most significant bit first */ /* swap bytes of 16 bit files to most significant bit first */
@@ -640,35 +637,35 @@ bool wxPNGReader::SaveFile(char * ImageFileName)
/* If you are only writing one row at a time, this works */ /* If you are only writing one row at a time, this works */
byte *row_pointers = new byte[row_stride]; byte *row_pointers = new byte[row_stride];
iter.upset(); iter.upset();
do { do {
// (unsigned char *)iter.GetRow(); // (unsigned char *)iter.GetRow();
iter.GetRow(row_pointers, row_stride); iter.GetRow(row_pointers, row_stride);
png_write_row(png_ptr, row_pointers); png_write_row(png_ptr, row_pointers);
} while(iter.PrevRow()); } while(iter.PrevRow());
delete[] row_pointers; delete[] row_pointers;
/* write the rest of the file */ /* write the rest of the file */
png_write_end(png_ptr, info_ptr); png_write_end(png_ptr, info_ptr);
/* clean up after the write, and free any memory allocated */ /* clean up after the write, and free any memory allocated */
png_write_destroy(png_ptr); png_write_destroy(png_ptr);
/* if you malloced the palette, free it here */ /* if you malloced the palette, free it here */
if (info_ptr->palette) if (info_ptr->palette)
delete[] (info_ptr->palette); delete[] (info_ptr->palette);
/* free the structures */ /* free the structures */
delete(png_ptr); delete(png_ptr);
delete(info_ptr); delete(info_ptr);
/* close the file */ /* close the file */
fclose(fp); fclose(fp);
/* that's it */ /* that's it */
return TRUE; return TRUE;
} }
static int Power(int x, int y) static int Power(int x, int y)

7
src/msw/textctrl.cpp
View File

@@ -39,12 +39,9 @@
#include <stdlib.h> #include <stdlib.h>
#if wxUSE_IOSTREAMH #if wxUSE_IOSTREAMH
#include <fstream.h> # include <fstream.h>
#else #else
#include <fstream> # include <fstream>
# ifdef _MSC_VER
using namespace std;
# endif
#endif #endif
#include <sys/types.h> #include <sys/types.h>

290
src/msw/utils.cpp
View File

@@ -68,41 +68,26 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#ifndef __WATCOMC__ #ifndef __WATCOMC__
#if !(defined(_MSC_VER) && (_MSC_VER > 800)) #if !(defined(_MSC_VER) && (_MSC_VER > 800))
#include <errno.h> #include <errno.h>
#endif #endif
#endif #endif
#include <stdarg.h> #include <stdarg.h>
//// BEGIN for console support: VC++ only //// BEGIN for console support: VC++ only
#if defined(__WXDEBUG__) && !defined(__WIN16__) && defined(_MSC_VER) && !defined(__NO_VC_CRTDBG__) #include "wx/msw/msvcrt.h"
#define wxUSE_VC_CRTDBG
#else
#undef wxUSE_VC_CRTDBG
#endif
#ifdef wxUSE_VC_CRTDBG #include <fcntl.h>
// VC++ uses this macro as debug/release mode indicator
#ifndef _DEBUG
#define _DEBUG
#endif
#include <fcntl.h> #include "wx/ioswrap.h"
#if wxUSE_IOSTREAMH #if wxUSE_IOSTREAMH
// N.B. BC++ doesn't have istream.h, ostream.h // N.B. BC++ doesn't have istream.h, ostream.h
# include <iostream.h>
# include <io.h> # include <io.h>
# include <fstream.h> # include <fstream.h>
#else #else
# include <istream>
# include <ostream>
# include <fstream> # include <fstream>
# ifdef _MSC_VER
using namespace std;
# endif
#endif #endif
/* Need to undef new if including crtdbg.h */ /* Need to undef new if including crtdbg.h */
@@ -118,8 +103,6 @@
# define new new(__FILE__,__LINE__) # define new new(__FILE__,__LINE__)
# endif # endif
#endif
/// END for console support /// END for console support
// In the WIN.INI file // In the WIN.INI file
@@ -766,14 +749,14 @@ bool wxDirExists(const wxString& dir)
#endif #endif
#if defined(__WIN32__) #if defined(__WIN32__)
HANDLE h = FindFirstFile((LPTSTR) WXSTRINGCAST dir,(LPWIN32_FIND_DATA)&fileInfo); HANDLE h = FindFirstFile((LPTSTR) WXSTRINGCAST dir,(LPWIN32_FIND_DATA)&fileInfo);
if (h==INVALID_HANDLE_VALUE) if (h==INVALID_HANDLE_VALUE)
return FALSE; return FALSE;
else { else {
FindClose(h); FindClose(h);
return ((fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY); return ((fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) == FILE_ATTRIBUTE_DIRECTORY);
} }
#else #else
// In Borland findfirst has a different argument // In Borland findfirst has a different argument
// ordering from _dos_findfirst. But _dos_findfirst // ordering from _dos_findfirst. But _dos_findfirst
@@ -806,13 +789,13 @@ bool wxIsWild( const wxString& pattern )
wxString tmp = pattern; wxString tmp = pattern;
char *pat = WXSTRINGCAST(tmp); char *pat = WXSTRINGCAST(tmp);
while (*pat) { while (*pat) {
switch (*pat++) { switch (*pat++) {
case '?': case '*': case '[': case '{': case '?': case '*': case '[': case '{':
return TRUE; return TRUE;
case '\\': case '\\':
if (!*pat++) if (!*pat++)
return FALSE; return FALSE;
} }
} }
return FALSE; return FALSE;
}; };
@@ -832,124 +815,124 @@ bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )
// dot_special means '.' only matches '.' // dot_special means '.' only matches '.'
if (dot_special && *str == '.' && *pattern != *str) if (dot_special && *str == '.' && *pattern != *str)
return FALSE; return FALSE;
while ((*pattern != '\0') && (!done) while ((*pattern != '\0') && (!done)
&& (((*str=='\0')&&((*pattern==OB)||(*pattern=='*')))||(*str!='\0'))) { && (((*str=='\0')&&((*pattern==OB)||(*pattern=='*')))||(*str!='\0'))) {
switch (*pattern) { switch (*pattern) {
case '\\': case '\\':
pattern++; pattern++;
if (*pattern != '\0') if (*pattern != '\0')
pattern++; pattern++;
break; break;
case '*': case '*':
pattern++; pattern++;
ret_code = FALSE; ret_code = FALSE;
while ((*str!='\0') while ((*str!='\0')
&& (!(ret_code=wxMatchWild(pattern, str++, FALSE)))) && (!(ret_code=wxMatchWild(pattern, str++, FALSE))))
/*loop*/; /*loop*/;
if (ret_code) { if (ret_code) {
while (*str != '\0') while (*str != '\0')
str++; str++;
while (*pattern != '\0') while (*pattern != '\0')
pattern++; pattern++;
} }
break; break;
case '[': case '[':
pattern++; pattern++;
repeat: repeat:
if ((*pattern == '\0') || (*pattern == ']')) { if ((*pattern == '\0') || (*pattern == ']')) {
done = TRUE; done = TRUE;
break; break;
} }
if (*pattern == '\\') { if (*pattern == '\\') {
pattern++; pattern++;
if (*pattern == '\0') { if (*pattern == '\0') {
done = TRUE; done = TRUE;
break; break;
} }
} }
if (*(pattern + 1) == '-') { if (*(pattern + 1) == '-') {
c = *pattern; c = *pattern;
pattern += 2; pattern += 2;
if (*pattern == ']') { if (*pattern == ']') {
done = TRUE; done = TRUE;
break; break;
} }
if (*pattern == '\\') { if (*pattern == '\\') {
pattern++; pattern++;
if (*pattern == '\0') { if (*pattern == '\0') {
done = TRUE; done = TRUE;
break; break;
} }
} }
if ((*str < c) || (*str > *pattern)) { if ((*str < c) || (*str > *pattern)) {
pattern++; pattern++;
goto repeat; goto repeat;
} }
} else if (*pattern != *str) { } else if (*pattern != *str) {
pattern++; pattern++;
goto repeat; goto repeat;
} }
pattern++; pattern++;
while ((*pattern != ']') && (*pattern != '\0')) { while ((*pattern != ']') && (*pattern != '\0')) {
if ((*pattern == '\\') && (*(pattern + 1) != '\0')) if ((*pattern == '\\') && (*(pattern + 1) != '\0'))
pattern++; pattern++;
pattern++; pattern++;
} }
if (*pattern != '\0') { if (*pattern != '\0') {
pattern++, str++; pattern++, str++;
} }
break; break;
case '?': case '?':
pattern++; pattern++;
str++; str++;
break; break;
case OB: case OB:
pattern++; pattern++;
while ((*pattern != CB) && (*pattern != '\0')) { while ((*pattern != CB) && (*pattern != '\0')) {
cp = str; cp = str;
ok = TRUE; ok = TRUE;
while (ok && (*cp != '\0') && (*pattern != '\0') while (ok && (*cp != '\0') && (*pattern != '\0')
&& (*pattern != ',') && (*pattern != CB)) { && (*pattern != ',') && (*pattern != CB)) {
if (*pattern == '\\') if (*pattern == '\\')
pattern++; pattern++;
ok = (*pattern++ == *cp++); ok = (*pattern++ == *cp++);
} }
if (*pattern == '\0') { if (*pattern == '\0') {
ok = FALSE; ok = FALSE;
done = TRUE; done = TRUE;
break; break;
} else if (ok) { } else if (ok) {
str = cp; str = cp;
while ((*pattern != CB) && (*pattern != '\0')) { while ((*pattern != CB) && (*pattern != '\0')) {
if (*++pattern == '\\') { if (*++pattern == '\\') {
if (*++pattern == CB) if (*++pattern == CB)
pattern++; pattern++;
} }
} }
} else { } else {
while (*pattern!=CB && *pattern!=',' && *pattern!='\0') { while (*pattern!=CB && *pattern!=',' && *pattern!='\0') {
if (*++pattern == '\\') { if (*++pattern == '\\') {
if (*++pattern == CB || *pattern == ',') if (*++pattern == CB || *pattern == ',')
pattern++; pattern++;
} }
} }
} }
if (*pattern != '\0') if (*pattern != '\0')
pattern++; pattern++;
} }
break; break;
default: default:
if (*str == *pattern) { if (*str == *pattern) {
str++, pattern++; str++, pattern++;
} else { } else {
done = TRUE; done = TRUE;
} }
} }
} }
while (*pattern == '*') while (*pattern == '*')
pattern++; pattern++;
return ((*str == '\0') && (*pattern == '\0')); return ((*str == '\0') && (*pattern == '\0'));
}; };
@@ -1089,14 +1072,14 @@ void OutputDebugStringW95(const char* lpOutputString, ...)
#endif #endif
#ifdef wxUSE_VC_CRTDBG #ifdef 0
// maximum mumber of lines the output console should have // maximum mumber of lines the output console should have
static const WORD MAX_CONSOLE_LINES = 500; static const WORD MAX_CONSOLE_LINES = 500;
BOOL WINAPI MyConsoleHandler( DWORD dwCtrlType ) { // control signal type BOOL WINAPI MyConsoleHandler( DWORD dwCtrlType ) { // control signal type
FreeConsole(); FreeConsole();
return TRUE; return TRUE;
} }
void wxRedirectIOToConsole() void wxRedirectIOToConsole()
@@ -1144,8 +1127,7 @@ void wxRedirectIOToConsole()
// point to console as well // point to console as well
ios::sync_with_stdio(); ios::sync_with_stdio();
SetConsoleCtrlHandler(MyConsoleHandler, TRUE); SetConsoleCtrlHandler(MyConsoleHandler, TRUE);
} }
#else #else
// Not supported // Not supported

8
src/msw/utilsexc.cpp
View File

@@ -6,7 +6,7 @@
// Created: 04/01/98 // Created: 04/01/98
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) Julian Smart and Markus Holzem // Copyright: (c) Julian Smart and Markus Holzem
// Licence: wxWindows license // Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #ifdef __GNUG__
@@ -59,9 +59,9 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#ifndef __WATCOMC__ #ifndef __WATCOMC__
#if !(defined(_MSC_VER) && (_MSC_VER > 800)) #if !(defined(_MSC_VER) && (_MSC_VER > 800))
#include <errno.h> #include <errno.h>
#endif #endif
#endif #endif
#include <stdarg.h> #include <stdarg.h>