Added Win95 implementation of OutputDebugString; added to wxVariant class

(just so Vadim hates it even more :-)) git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@1084 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
1998-11-29 21:20:12 +00:00
parent cfbe03c9c3
commit a0a302dcba
9 changed files with 626 additions and 31 deletions
--- a/src/common/log.cpp
+++ b/src/common/log.cpp
@@ -52,6 +52,8 @@

 #ifdef  __WXMSW__
  #include  <windows.h>
+  // Redefines OutputDebugString if necessary
+  #include  "wx/msw/private.h"
 #else   //Unix
  #include  <signal.h>
 #endif  //Win/Unix
--- a/src/common/variant.cpp
+++ b/src/common/variant.cpp
@@ -142,7 +142,7 @@ bool wxVariantDataList::Write(ostream& str) const
 {
    wxString s;
    Write(s);
-    str << s;
+    str << (const char*) s;
    return TRUE;
 }

@@ -243,7 +243,7 @@ bool wxVariantDataStringList::Write(ostream& str) const
 {
    wxString s;
    Write(s);
-    str << s;
+    str << (const char*) s;
    return TRUE;
 }

@@ -329,7 +329,7 @@ bool wxVariantDataLong::Write(ostream& str) const
 {
    wxString s;
    Write(s);
-    str << s;
+    str << (const char*) s;
    return TRUE;
 }

@@ -415,7 +415,7 @@ bool wxVariantDataReal::Write(ostream& str) const
 {
    wxString s;
    Write(s);
-    str << s;
+    str << (const char*) s;
    return TRUE;
 }

@@ -501,7 +501,7 @@ bool wxVariantDataBool::Write(ostream& str) const
 {
    wxString s;
    Write(s);
-    str << s;
+    str << (const char*) s;
    return TRUE;
 }

@@ -588,7 +588,7 @@ bool wxVariantDataChar::Write(ostream& str) const
 {
    wxString s;
    Write(s);
-    str << s;
+    str << (const char*) s;
    return TRUE;
 }

@@ -671,7 +671,7 @@ bool wxVariantDataString::Eq(wxVariantData& data) const

 bool wxVariantDataString::Write(ostream& str) const
 {
-    str << m_value;
+    str << (const char*) m_value;
    return TRUE;
 }

@@ -707,6 +707,233 @@ bool wxVariantDataString::Read(wxString& str)

 IMPLEMENT_DYNAMIC_CLASS(wxVariantDataString, wxVariantData)

+/*
+ * wxVariantDataTime
+ */
+
+#if wxUSE_TIMEDATE
+
+class wxVariantDataTime: public wxVariantData
+{
+ DECLARE_DYNAMIC_CLASS(wxVariantDataTime)
+public:
+    wxVariantDataTime() { }
+    wxVariantDataTime(const wxTime& value) { m_value = value; }
+
+    inline wxTime GetValue() const { return m_value; }
+    inline void SetValue(const wxTime& value) { m_value = value; }
+
+    virtual void Copy(wxVariantData& data);
+    virtual bool Eq(wxVariantData& data) const;
+    virtual bool Write(ostream& str) const;
+    virtual bool Write(wxString& str) const;
+    virtual bool Read(istream& str);
+    virtual bool Read(wxString& str);
+    virtual wxString GetType() const { return "time"; };
+	virtual wxVariantData* Clone() { return new wxVariantDataTime; }
+
+protected:
+    wxTime m_value;
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxVariantDataTime, wxVariantData)
+
+void wxVariantDataTime::Copy(wxVariantData& data)
+{
+    wxASSERT_MSG( (data.GetType() == "time"), "wxVariantDataTime::Copy: Can't copy to this type of data" );
+
+    wxVariantDataTime& otherData = (wxVariantDataTime&) data;
+
+    otherData.m_value = m_value;
+}
+
+bool wxVariantDataTime::Eq(wxVariantData& data) const
+{
+    wxASSERT_MSG( (data.GetType() == "time"), "wxVariantDataTime::Eq: argument mismatch" );
+
+    wxVariantDataTime& otherData = (wxVariantDataTime&) data;
+
+    return (otherData.m_value == m_value);
+}
+
+bool wxVariantDataTime::Write(ostream& str) const
+{
+    wxString s;
+    Write(s);
+    str << (const char*) s;
+    return TRUE;
+}
+
+bool wxVariantDataTime::Write(wxString& str) const
+{
+    char*s = m_value.FormatTime();
+    str = s;
+    return TRUE;
+}
+
+bool wxVariantDataTime::Read(istream& str)
+{
+    // Not implemented
+    return FALSE;
+}
+
+bool wxVariantDataTime::Read(wxString& str)
+{
+    // Not implemented
+    return FALSE;
+}
+
+/*
+ * wxVariantDataDate
+ */
+
+class wxVariantDataDate: public wxVariantData
+{
+ DECLARE_DYNAMIC_CLASS(wxVariantDataDate)
+public:
+    wxVariantDataDate() { }
+    wxVariantDataDate(const wxDate& value) { m_value = value; }
+
+    inline wxDate GetValue() const { return m_value; }
+    inline void SetValue(const wxDate& value) { m_value = value; }
+
+    virtual void Copy(wxVariantData& data);
+    virtual bool Eq(wxVariantData& data) const;
+    virtual bool Write(ostream& str) const;
+    virtual bool Write(wxString& str) const;
+    virtual bool Read(istream& str);
+    virtual bool Read(wxString& str);
+    virtual wxString GetType() const { return "date"; };
+	virtual wxVariantData* Clone() { return new wxVariantDataDate; }
+
+protected:
+    wxDate m_value;
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxVariantDataDate, wxVariantData)
+
+void wxVariantDataDate::Copy(wxVariantData& data)
+{
+    wxASSERT_MSG( (data.GetType() == "date"), "wxVariantDataDate::Copy: Can't copy to this type of data" );
+
+    wxVariantDataDate& otherData = (wxVariantDataDate&) data;
+
+    otherData.m_value = m_value;
+}
+
+bool wxVariantDataDate::Eq(wxVariantData& data) const
+{
+    wxASSERT_MSG( (data.GetType() == "date"), "wxVariantDataDate::Eq: argument mismatch" );
+
+    wxVariantDataDate& otherData = (wxVariantDataDate&) data;
+
+    return (otherData.m_value == m_value);
+}
+
+bool wxVariantDataDate::Write(ostream& str) const
+{
+    wxString s;
+    Write(s);
+    str << (const char*) s;
+    return TRUE;
+}
+
+bool wxVariantDataDate::Write(wxString& str) const
+{
+    str = m_value.FormatDate();
+    return TRUE;
+}
+
+bool wxVariantDataDate::Read(istream& str)
+{
+    // Not implemented
+    return FALSE;
+}
+
+bool wxVariantDataDate::Read(wxString& str)
+{
+    // Not implemented
+    return FALSE;
+}
+#endif
+  // wxUSE_TIMEDATE
+
+/*
+ * wxVariantDataVoidPtr
+ */
+
+class wxVariantDataVoidPtr: public wxVariantData
+{
+DECLARE_DYNAMIC_CLASS(wxVariantDataVoidPtr)
+public:
+    wxVariantDataVoidPtr() { }
+    wxVariantDataVoidPtr(void* value) { m_value = value; }
+
+    inline void* GetValue() const { return m_value; }
+    inline void SetValue(void* value) { m_value = value; }
+
+    virtual void Copy(wxVariantData& data);
+    virtual bool Eq(wxVariantData& data) const;
+    virtual bool Write(ostream& str) const;
+    virtual bool Write(wxString& str) const;
+    virtual bool Read(istream& str);
+    virtual bool Read(wxString& str);
+    virtual wxString GetType() const { return "void*"; };
+	virtual wxVariantData* Clone() { return new wxVariantDataVoidPtr; }
+
+protected:
+    void* m_value;
+};
+
+IMPLEMENT_DYNAMIC_CLASS(wxVariantDataVoidPtr, wxVariantData)
+
+void wxVariantDataVoidPtr::Copy(wxVariantData& data)
+{
+    wxASSERT_MSG( (data.GetType() == "void*"), "wxVariantDataVoidPtr::Copy: Can't copy to this type of data" );
+
+    wxVariantDataVoidPtr& otherData = (wxVariantDataVoidPtr&) data;
+
+    otherData.m_value = m_value;
+}
+
+bool wxVariantDataVoidPtr::Eq(wxVariantData& data) const
+{
+    wxASSERT_MSG( (data.GetType() == "void*"), "wxVariantDataVoidPtr::Eq: argument mismatch" );
+
+    wxVariantDataVoidPtr& otherData = (wxVariantDataVoidPtr&) data;
+
+    return (otherData.m_value == m_value);
+}
+
+bool wxVariantDataVoidPtr::Write(ostream& str) const
+{
+    wxString s;
+    Write(s);
+    str << (const char*) s;
+    return TRUE;
+}
+
+bool wxVariantDataVoidPtr::Write(wxString& str) const
+{
+    char buf[80];
+    sprintf(buf, "%ld", (long) m_value);
+    str = buf;
+    return TRUE;
+}
+
+bool wxVariantDataVoidPtr::Read(istream& str)
+{
+    // Not implemented
+    return FALSE;
+}
+
+bool wxVariantDataVoidPtr::Read(wxString& str)
+{
+    // Not implemented
+    return FALSE;
+}
+
+
 /*
 * wxVariant
 */
@@ -717,48 +944,75 @@ IMPLEMENT_DYNAMIC_CLASS(wxVariant, wxObject)
 wxVariant::wxVariant()
 {
    m_data = (wxVariantData*) NULL;
+    m_name = wxEmptyString;
 }

-wxVariant::wxVariant(double val)
+wxVariant::wxVariant(double val, const wxString& name)
 {
    m_data = new wxVariantDataReal(val);
+    m_name = name;
 }

-wxVariant::wxVariant(long val)
+wxVariant::wxVariant(long val, const wxString& name)
 {
    m_data = new wxVariantDataLong(val);
+    m_name = name;
 }

-wxVariant::wxVariant(bool val)
+wxVariant::wxVariant(bool val, const wxString& name)
 {
    m_data = new wxVariantDataBool(val);
+    m_name = name;
 }

-wxVariant::wxVariant(char val)
+wxVariant::wxVariant(char val, const wxString& name)
 {
    m_data = new wxVariantDataChar(val);
+    m_name = name;
 }

-wxVariant::wxVariant(const wxString& val)
+wxVariant::wxVariant(const wxString& val, const wxString& name)
 {
    m_data = new wxVariantDataString(val);
+    m_name = name;
 }

-wxVariant::wxVariant(const char* val)
+wxVariant::wxVariant(const char* val, const wxString& name)
 {
    m_data = new wxVariantDataString(wxString(val));
+    m_name = name;
 }

-/* Causes ambiguity
-wxVariant::wxVariant(const wxStringList& val)
+wxVariant::wxVariant(const wxStringList& val, const wxString& name)
 {
    m_data = new wxVariantDataStringList(val);
+    m_name = name;
 }
-*/

-wxVariant::wxVariant(const wxList& val) // List of variants
+wxVariant::wxVariant(const wxList& val, const wxString& name) // List of variants
 {
    m_data = new wxVariantDataList(val);
+    m_name = name;
+}
+
+#if wxUSE_TIMEDATE
+wxVariant::wxVariant(const wxTime& val, const wxString& name) // Time
+{
+    m_data = new wxVariantDataTime(val);
+    m_name = name;
+}
+
+wxVariant::wxVariant(const wxDate& val, const wxString& name) // Date
+{
+    m_data = new wxVariantDataDate(val);
+    m_name = name;
+}
+#endif
+
+wxVariant::wxVariant(void* val, const wxString& name) // Void ptr
+{
+    m_data = new wxVariantDataVoidPtr(val);
+    m_name = name;
 }

 wxVariant::wxVariant(const wxVariant& variant)
@@ -770,11 +1024,13 @@ wxVariant::wxVariant(const wxVariant& variant)
    }
    else
        m_data = (wxVariantData*) NULL;
+    m_name = variant.m_name;
 }

-wxVariant::wxVariant(wxVariantData* data) // User-defined data
+wxVariant::wxVariant(wxVariantData* data, const wxString& name) // User-defined data
 {
    m_data = data;
+    m_name = name;
 }

 wxVariant::~wxVariant()
@@ -1041,6 +1297,87 @@ void wxVariant::operator= (const wxList& value)
    }
 }

+#if wxUSE_TIMEDATE
+bool wxVariant::operator== (const wxTime& value) const
+{
+    wxTime thisValue;
+    if (!Convert(&thisValue))
+        return FALSE;
+    else
+        return (value == thisValue);
+}
+
+bool wxVariant::operator!= (const wxTime& value) const
+{
+    return (!((*this) == value));
+}
+
+void wxVariant::operator= (const wxTime& value)
+{
+    if (GetType() == "time")
+    {
+        ((wxVariantDataTime*)GetData())->SetValue(value);
+    }
+    else
+    {
+        if (m_data)
+            delete m_data;
+        m_data = new wxVariantDataTime(value);
+    }
+}
+
+bool wxVariant::operator== (const wxDate& value) const
+{
+    wxDate thisValue;
+    if (!Convert(&thisValue))
+        return FALSE;
+    else
+        return (value == thisValue);
+}
+
+bool wxVariant::operator!= (const wxDate& value) const
+{
+    return (!((*this) == value));
+}
+
+void wxVariant::operator= (const wxDate& value)
+{
+    if (GetType() == "date")
+    {
+        ((wxVariantDataTime*)GetData())->SetValue(value);
+    }
+    else
+    {
+        if (m_data)
+            delete m_data;
+        m_data = new wxVariantDataDate(value);
+    }
+}
+#endif
+
+bool wxVariant::operator== (void* value) const
+{
+    return (value == ((wxVariantDataVoidPtr*)GetData())->GetValue());
+}
+
+bool wxVariant::operator!= (void* value) const
+{
+    return (!((*this) == value));
+}
+
+void wxVariant::operator= (void* value)
+{
+    if (GetType() == "void*")
+    {
+        ((wxVariantDataVoidPtr*)GetData())->SetValue(value);
+    }
+    else
+    {
+        if (m_data)
+            delete m_data;
+        m_data = new wxVariantDataVoidPtr(value);
+    }
+}

 // Treat a list variant as an array
 wxVariant wxVariant::operator[] (size_t idx) const
@@ -1193,6 +1530,39 @@ wxString wxVariant::GetString() const
    }
 }

+#if wxUSE_TIMEDATE
+wxTime wxVariant::GetTime() const
+{
+    wxTime value;
+    if (Convert(& value))
+        return value;
+    else
+    {
+        wxFAIL_MSG("Could not convert to a time");
+        return wxTime();
+    }
+}
+
+wxDate wxVariant::GetDate() const
+{
+    wxDate value;
+    if (Convert(& value))
+        return value;
+    else
+    {
+        wxFAIL_MSG("Could not convert to a date");
+        return wxDate();
+    }
+}
+#endif
+
+void* wxVariant::GetVoidPtr() const
+{
+    wxASSERT( (GetType() == "void*") );
+
+    return (void*) ((wxVariantDataVoidPtr*) m_data)->GetValue();
+}
+
 wxList& wxVariant::GetList() const
 {
    wxASSERT( (GetType() == "list") );
@@ -1352,3 +1722,29 @@ bool wxVariant::Convert(wxString* value) const
    return TRUE;
 }

+#if wxUSE_TIMEDATE
+bool wxVariant::Convert(wxTime* value) const
+{
+    wxString type(GetType());
+    if (type == "time")
+        *value = ((wxVariantDataTime*)GetData())->GetValue();
+    else if (type == "date")
+        *value = wxTime(((wxVariantDataDate*)GetData())->GetValue());
+    else
+        return FALSE;
+
+    return TRUE;
+}
+
+bool wxVariant::Convert(wxDate* value) const
+{
+    wxString type(GetType());
+    if (type == "date")
+        *value = ((wxVariantDataDate*)GetData())->GetValue();
+    else
+        return FALSE;
+
+    return TRUE;
+}
+#endif
+ // wxUSE_TIMEDATE
--- a/src/msw/dcclient.cpp
+++ b/src/msw/dcclient.cpp
@@ -124,8 +124,8 @@ wxPaintDC::~wxPaintDC()
    if ( !--ms_PaintCount ) {
      ::EndPaint((HWND)m_canvas->GetHWND(), &g_paintStruct);
      m_hDCCount--;
-      m_hDC = NULL;
-      ms_PaintHDC = NULL;
+      m_hDC = (WXHDC) NULL;
+      ms_PaintHDC = (WXHDC) NULL;
    }
    else { }//: ms_PaintHDC still in use
  }
--- a/src/msw/utils.cpp
+++ b/src/msw/utils.cpp
@@ -894,3 +894,130 @@ bool wxMatchWild( const wxString& pat, const wxString& text, bool dot_special )

 #endif

+#if defined(__WIN95__) && defined(__WXDEBUG__) && wxUSE_DBWIN32
+
+/*
+When I started programming with Visual C++ v4.0, I missed one of my favorite
+tools -- DBWIN.  Finding the code for a simple debug trace utility, DBMON,
+on MSDN was a step in the right direction, but it is a console application
+and thus has limited features and extensibility.  DBWIN32 is my creation
+to solve this problem.
+
+The code is essentially a merging of a stripped down version of the DBWIN code 
+from VC 1.5 and DBMON.C with a few 32 bit changes.
+
+As of version 1.2B, DBWIN32 supports both Win95 and NT.  The NT support is 
+built into the operating system and works just by running DBWIN32.  The Win95
+team decided not to support this hook, so I have provided code that will do
+this for you.  See the file WIN95.TXT for instructions on installing this.
+
+If you have questions, problems or suggestions about DBWIN32, I welcome your
+feedback and plan to actively maintain the code.
+
+Andrew Tucker
+ast@halcyon.com
+
+To download dbwin32, see e.g.:
+
+http://ftp.digital.com/pub/micro/NT/WinSite/programr/dbwin32.zip
+*/
+
+#include <process.h>
+
+void OutputDebugStringW95(const char* lpOutputString, ...)
+{
+    HANDLE heventDBWIN;  /* DBWIN32 synchronization object */
+    HANDLE heventData;   /* data passing synch object */
+    HANDLE hSharedFile;  /* memory mapped file shared data */
+    LPSTR lpszSharedMem;
+    char achBuffer[500];
+
+    /* create the output buffer */
+    va_list args;
+    va_start(args, lpOutputString);
+    vsprintf(achBuffer, lpOutputString, args);
+    va_end(args);
+
+    /* 
+        Do a regular OutputDebugString so that the output is 
+        still seen in the debugger window if it exists.
+
+        This ifdef is necessary to avoid infinite recursion 
+        from the inclusion of W95TRACE.H
+    */
+#ifdef _UNICODE
+    ::OutputDebugStringW(achBuffer);
+#else
+    ::OutputDebugStringA(achBuffer);
+#endif
+
+    /* bail if it's not Win95 */
+    {
+        OSVERSIONINFO VerInfo;
+        VerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+        GetVersionEx(&VerInfo);
+        if ( VerInfo.dwPlatformId != VER_PLATFORM_WIN32_WINDOWS )
+            return;
+    }
+
+    /* make sure DBWIN is open and waiting */
+    heventDBWIN = OpenEvent(EVENT_MODIFY_STATE, FALSE, "DBWIN_BUFFER_READY");
+    if ( !heventDBWIN )
+    {
+        //MessageBox(NULL, "DBWIN_BUFFER_READY nonexistent", NULL, MB_OK);
+        return;            
+    }
+
+    /* get a handle to the data synch object */
+    heventData = OpenEvent(EVENT_MODIFY_STATE, FALSE, "DBWIN_DATA_READY");
+    if ( !heventData )
+    {
+        // MessageBox(NULL, "DBWIN_DATA_READY nonexistent", NULL, MB_OK);
+        CloseHandle(heventDBWIN);
+        return;            
+    }
+    
+    hSharedFile = CreateFileMapping((HANDLE)-1, NULL, PAGE_READWRITE, 0, 4096, "DBWIN_BUFFER");
+    if (!hSharedFile) 
+    {
+        //MessageBox(NULL, "DebugTrace: Unable to create file mapping object DBWIN_BUFFER", "Error", MB_OK);
+        CloseHandle(heventDBWIN);
+        CloseHandle(heventData);
+        return;
+    }
+
+    lpszSharedMem = (LPSTR)MapViewOfFile(hSharedFile, FILE_MAP_WRITE, 0, 0, 512);
+    if (!lpszSharedMem) 
+    {
+        //MessageBox(NULL, "DebugTrace: Unable to map shared memory", "Error", MB_OK);
+        CloseHandle(heventDBWIN);
+        CloseHandle(heventData);
+        return;
+    }
+
+    /* wait for buffer event */
+    WaitForSingleObject(heventDBWIN, INFINITE);
+
+    /* write it to the shared memory */
+#ifdef __BORLANDC__
+    *((LPDWORD)lpszSharedMem) = getpid();
+#else
+    *((LPDWORD)lpszSharedMem) = _getpid();
+#endif
+
+    wsprintf(lpszSharedMem + sizeof(DWORD), "%s", achBuffer);
+
+    /* signal data ready event */
+    SetEvent(heventData);
+
+    /* clean up handles */
+    CloseHandle(hSharedFile);
+    CloseHandle(heventData);
+    CloseHandle(heventDBWIN);
+
+    return;
+}
+
+
+#endif
+