AuroraMiddleware/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

*** empty log message ***

Browse Source 
git-svn-id: https://svn.wxwidgets.org/svn/wx/wxWidgets/trunk@3916 c3d73ce0-8a6f-49c7-b76d-6d57e0e08775
This commit is contained in:
David Webster 1999-10-10 18:36:14 +00:00
parent 89be8239db
commit fb9010ed40
18 changed files with 2958 additions and 269 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
include/wx/os2/brush.h
View File

@ -34,10 +34,7 @@ protected:
int m_style; int m_style;
wxBitmap m_stipple ; wxBitmap m_stipple ;
wxColour m_colour; wxColour m_colour;
/* TODO: implementation
WXHBRUSH m_hBrush; WXHBRUSH m_hBrush;
*/
}; };
#define M_BRUSHDATA ((wxBrushRefData *)m_refData) #define M_BRUSHDATA ((wxBrushRefData *)m_refData)
@ -74,6 +71,10 @@ public:
// Useful helper: create the brush resource // Useful helper: create the brush resource
bool RealizeResource(); bool RealizeResource();
WXHANDLE GetResourceHandle(void) ;
bool FreeResource(bool force = FALSE);
bool IsFree() const;
// When setting properties, we must make sure we're not changing // When setting properties, we must make sure we're not changing
// another object // another object
void Unshare(); void Unshare();

105
include/wx/os2/gsockos2.h Normal file
View File

@ -0,0 +1,105 @@
/* -------------------------------------------------------------------------
* Project: GSocket (Generic Socket) for WX
* Name: gsockos2.h
* Purpose: GSocket OS/2 header
* CVSID: $Id$
* -------------------------------------------------------------------------
*/
#ifndef __GSOCK_OS2_H
#define __GSOCK_OS2_H
#ifndef __GSOCKET_STANDALONE__
#include "wx/setup.h"
#endif
#if wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__)
#ifndef __GSOCKET_STANDALONE__
#include "wx/gsocket.h"
#else
#include "gsocket.h"
#endif
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
#define SIGPIPE 13
/* Definition of GSocket */
struct _GSocket
{
int m_fd;
GAddress *m_local;
GAddress *m_peer;
GSocketError m_error;
bool m_non_blocking;
bool m_server;
bool m_stream;
bool m_oriented;
bool m_establishing;
unsigned long m_timeout;
/* Callbacks */
GSocketEventFlags m_detected;
GSocketCallback m_cbacks[GSOCK_MAX_EVENT];
char *m_data[GSOCK_MAX_EVENT];
char *m_gui_dependent;
};
/* Definition of GAddress */
struct _GAddress
{
struct sockaddr *m_addr;
size_t m_len;
GAddressType m_family;
int m_realfamily;
GSocketError m_error;
};
/* Input / Output */
GSocketError _GSocket_Input_Timeout(GSocket *socket);
GSocketError _GSocket_Output_Timeout(GSocket *socket);
int _GSocket_Recv_Stream(GSocket *socket, char *buffer, int size);
int _GSocket_Recv_Dgram(GSocket *socket, char *buffer, int size);
int _GSocket_Send_Stream(GSocket *socket, const char *buffer, int size);
int _GSocket_Send_Dgram(GSocket *socket, const char *buffer, int size);
/* Callbacks */
void _GSocket_Enable(GSocket *socket, GSocketEvent event);
void _GSocket_Disable(GSocket *socket, GSocketEvent event);
void _GSocket_Detected_Read(GSocket *socket);
void _GSocket_Detected_Write(GSocket *socket);
void _GSocket_GUI_Init(GSocket *socket);
void _GSocket_GUI_Destroy(GSocket *socket);
void _GSocket_Enable_Events(GSocket *socket);
void _GSocket_Disable_Events(GSocket *socket);
void _GSocket_Install_Callback(GSocket *socket, GSocketEvent event);
void _GSocket_Uninstall_Callback(GSocket *socket, GSocketEvent event);
/* GAddress */
GSocketError _GAddress_translate_from(GAddress *address,
struct sockaddr *addr, int len);
GSocketError _GAddress_translate_to(GAddress *address,
struct sockaddr **addr, int *len);
GSocketError _GAddress_Init_INET(GAddress *address);
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* wxUSE_SOCKETS || defined(__GSOCKET_STANDALONE__) */
#endif /* __GSOCK_UNX_H */

30
include/wx/os2/helpxxxx.h → include/wx/os2/helpwin.h
View File

@ -1,33 +1,28 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: helpxxxx.h // Name: helpxxxx.h
// Purpose: Help system: native implementation for your system. Replace // Purpose: Help system: native implementation for your system.
// XXXX with suitable name. // Author: David Webster
// Author: AUTHOR
// Modified by: // Modified by:
// Created: ??/??/98 // Created: 10/09/99
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) AUTHOR // Copyright: (c) David Webster
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_HELPXXXX_H_ #ifndef _WX_HELPWIN_H_
#define _WX_HELPXXXX_H_ #define _WX_HELPWIN_H_
#ifdef __GNUG__
#pragma interface "helpxxxx.h"
#endif
#include "wx/wx.h" #include "wx/wx.h"
#include "wx/helpbase.h" #include "wx/helpbase.h"
class WXDLLEXPORT wxXXXXHelpController: public wxHelpControllerBase class WXDLLEXPORT wxWinHelpController: public wxHelpControllerBase
{ {
DECLARE_CLASS(wxXXXXHelpController) DECLARE_CLASS(wxWinHelpController)
public: public:
wxXXXXHelpController(); wxWinHelpController();
~wxXXXXHelpController(); ~wxWinHelpController();
// Must call this to set the filename and server name // Must call this to set the filename and server name
virtual bool Initialize(const wxString& file); virtual bool Initialize(const wxString& file);
@ -46,7 +41,10 @@ class WXDLLEXPORT wxXXXXHelpController: public wxHelpControllerBase
protected: protected:
wxString m_helpFile; wxString m_helpFile;
private:
// virtual function hiding supression :: do not use
bool Initialize(const wxString& file, int WXUNUSED(server) ) { return(Initialize(file)); }
}; };
#endif #endif
// _WX_HELPXXXX_H_ // _WX_HELPWIN_H_

36
include/wx/os2/icon.h
View File

@ -1,21 +1,17 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: icon.h // Name: icon.h
// Purpose: wxIcon class // Purpose: wxIcon class
// Author: AUTHOR // Author: David Webster
// Modified by: // Modified by:
// Created: ??/??/98 // Created: 10/09/99
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) AUTHOR // Copyright: (c) David Webster
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_ICON_H_ #ifndef _WX_ICON_H_
#define _WX_ICON_H_ #define _WX_ICON_H_
#ifdef __GNUG__
#pragma interface "icon.h"
#endif
#include "wx/bitmap.h" #include "wx/bitmap.h"
class WXDLLEXPORT wxIconRefData: public wxBitmapRefData class WXDLLEXPORT wxIconRefData: public wxBitmapRefData
@ -27,9 +23,7 @@ public:
~wxIconRefData(); ~wxIconRefData();
public: public:
/* TODO: whatever your actual icon handle is WXHICON m_hIcon;
WXHICON m_hIcon;
*/
}; };
#define M_ICONDATA ((wxIconRefData *)m_refData) #define M_ICONDATA ((wxIconRefData *)m_refData)
@ -58,12 +52,9 @@ public:
inline bool operator == (const wxIcon& icon) { return m_refData == icon.m_refData; } inline bool operator == (const wxIcon& icon) { return m_refData == icon.m_refData; }
inline bool operator != (const wxIcon& icon) { return m_refData != icon.m_refData; } inline bool operator != (const wxIcon& icon) { return m_refData != icon.m_refData; }
/* TODO: implementation
void SetHICON(WXHICON ico); void SetHICON(WXHICON ico);
inline WXHICON GetHICON() const { return (M_ICONDATA ? M_ICONDATA->m_hIcon : 0); } inline WXHICON GetHICON() const { return (M_ICONDATA ? M_ICONDATA->m_hIcon : 0); }
*/
/* TODO */
virtual bool Ok() const { return (m_refData != NULL) ; } virtual bool Ok() const { return (m_refData != NULL) ; }
private: private:
// supress virtual function hiding warning // supress virtual function hiding warning
@ -73,7 +64,7 @@ private:
{ return(wxBitmap::LoadFile(name, type)); }; { return(wxBitmap::LoadFile(name, type)); };
}; };
/* Example handlers. TODO: write your own handlers for relevant types. // Example handlers. TODO: write your own handlers for relevant types.
class WXDLLEXPORT wxICOFileHandler: public wxBitmapHandler class WXDLLEXPORT wxICOFileHandler: public wxBitmapHandler
{ {
@ -81,9 +72,9 @@ class WXDLLEXPORT wxICOFileHandler: public wxBitmapHandler
public: public:
inline wxICOFileHandler() inline wxICOFileHandler()
{ {
m_name = "ICO icon file"; m_name = "ICO icon file";
m_extension = "ico"; m_extension = "ico";
m_type = wxBITMAP_TYPE_ICO; m_type = wxBITMAP_TYPE_ICO;
}; };
virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags, virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
@ -96,9 +87,9 @@ class WXDLLEXPORT wxICOResourceHandler: public wxBitmapHandler
public: public:
inline wxICOResourceHandler() inline wxICOResourceHandler()
{ {
m_name = "ICO resource"; m_name = "ICO resource";
m_extension = "ico"; m_extension = "ico";
m_type = wxBITMAP_TYPE_ICO_RESOURCE; m_type = wxBITMAP_TYPE_ICO_RESOURCE;
}; };
virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags, virtual bool LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
@ -106,7 +97,6 @@ public:
}; };
*/
#endif #endif
// _WX_ICON_H_ // _WX_ICON_H_

22
include/wx/os2/imaglist.h
View File

@ -3,21 +3,17 @@
// Purpose: wxImageList class. Note: if your GUI doesn't have // Purpose: wxImageList class. Note: if your GUI doesn't have
// an image list equivalent, you can use the generic class // an image list equivalent, you can use the generic class
// in src/generic. // in src/generic.
// Author: AUTHOR // Author: David Webster
// Modified by: // Modified by:
// Created: ??/??/98 // Created: 10/09/99
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) AUTHOR // Copyright: (c) David Webster
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_IMAGLIST_H_ #ifndef _WX_IMAGLIST_H_
#define _WX_IMAGLIST_H_ #define _WX_IMAGLIST_H_
#ifdef __GNUG__
#pragma interface "imaglist.h"
#endif
#include "wx/bitmap.h" #include "wx/bitmap.h"
/* /*
@ -100,13 +96,6 @@ class WXDLLEXPORT wxImageList: public wxObject
// 'bitmap' and 'mask' after calling Replace. // 'bitmap' and 'mask' after calling Replace.
bool Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap); bool Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask = wxNullBitmap);
/* Not supported by Win95
// Replacing a bitmap, using the specified colour to create the mask bitmap
// Note that wxImageList creates new bitmaps, so you may delete
// 'bitmap'.
bool Replace(int index, const wxBitmap& bitmap, const wxColour& maskColour);
*/
// Replaces a bitmap and mask from an icon. // Replaces a bitmap and mask from an icon.
// You can delete 'icon' after calling Replace. // You can delete 'icon' after calling Replace.
bool Replace(int index, const wxIcon& icon); bool Replace(int index, const wxIcon& icon);
@ -128,7 +117,6 @@ class WXDLLEXPORT wxImageList: public wxObject
wxIcon *MakeIcon(int index); wxIcon *MakeIcon(int index);
*/ */
/* TODO
// Implementation // Implementation
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
@ -137,8 +125,6 @@ class WXDLLEXPORT wxImageList: public wxObject
protected: protected:
WXHIMAGELIST m_hImageList; WXHIMAGELIST m_hImageList;
*/
}; };
#endif #endif

119
include/wx/os2/iniconf.h Normal file
View File

@ -0,0 +1,119 @@
///////////////////////////////////////////////////////////////////////////////
// Name: include/wx/msw/iniconf.h
// Purpose: INI-file based wxConfigBase implementation
// Author: David Webster
// Modified by:
// Created: 10/09/99
// Copyright: David Webster
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifndef _INICONF_H
#define _INICONF_H
// ----------------------------------------------------------------------------
// wxIniConfig is a wxConfig implementation which uses MS Windows INI files to
// store the data. Because INI files don't really support arbitrary nesting of
// groups, we do the following:
// (1) in win.ini file we store all entries in the [vendor] section and
// the value group1/group2/key is mapped to the value group1_group2_key
// in this section, i.e. all path separators are replaced with underscore
// (2) in appname.ini file we map group1/group2/group3/key to the entry
// group2_group3_key in [group1]
//
// Of course, it might lead to indesirable results if '_' is also used in key
// names (i.e. group/key is the same as group_key) and also GetPath() result
// may be not what you would expect it to be.
//
// Another limitation: the keys and section names are never case-sensitive
// which might differ from wxFileConfig it it was compiled with
// wxCONFIG_CASE_SENSITIVE option.
// ----------------------------------------------------------------------------
// for this class, "local" file is the file appname.ini and the global file
// is the [vendor] subsection of win.ini (default for "vendor" is to be the
// same as appname). The file name (strAppName parameter) may, in fact,
// contain the full path to the file. If it doesn't, the file is searched for
// in the Windows directory.
class WXDLLEXPORT wxIniConfig : public wxConfigBase
{
public:
// ctor & dtor
// if strAppName doesn't contain the extension and is not an absolute path,
// ".ini" is appended to it. if strVendor is empty, it's taken to be the
// same as strAppName.
wxIniConfig(const wxString& strAppName = wxEmptyString, const wxString& strVendor = wxEmptyString,
const wxString& localFilename = wxEmptyString, const wxString& globalFilename = wxEmptyString, long style = wxCONFIG_USE_LOCAL_FILE);
virtual ~wxIniConfig();
// implement inherited pure virtual functions
virtual void SetPath(const wxString& strPath);
virtual const wxString& GetPath() const;
virtual bool GetFirstGroup(wxString& str, long& lIndex) const;
virtual bool GetNextGroup (wxString& str, long& lIndex) const;
virtual bool GetFirstEntry(wxString& str, long& lIndex) const;
virtual bool GetNextEntry (wxString& str, long& lIndex) const;
virtual size_t GetNumberOfEntries(bool bRecursive = FALSE) const;
virtual size_t GetNumberOfGroups(bool bRecursive = FALSE) const;
virtual bool HasGroup(const wxString& strName) const;
virtual bool HasEntry(const wxString& strName) const;
// return TRUE if the current group is empty
bool IsEmpty() const;
// read/write
bool Read(const wxString& key, wxString *pStr) const;
bool Read(const wxString& key, wxString *pStr, const wxString& szDefault) const;
bool Read(const wxString& key, long *plResult) const;
// The following are necessary to satisfy the compiler
wxString Read(const wxString& key, const wxString& defVal) const
{ return wxConfigBase::Read(key, defVal); }
bool Read(const wxString& key, long *pl, long defVal) const
{ return wxConfigBase::Read(key, pl, defVal); }
long Read(const wxString& key, long defVal) const
{ return wxConfigBase::Read(key, defVal); }
bool Read(const wxString& key, int *pi, int defVal) const
{ return wxConfigBase::Read(key, pi, defVal); }
bool Read(const wxString& key, int *pi) const
{ return wxConfigBase::Read(key, pi); }
bool Read(const wxString& key, double* val) const
{ return wxConfigBase::Read(key, val); }
bool Read(const wxString& key, double* val, double defVal) const
{ return wxConfigBase::Read(key, val, defVal); }
bool Write(const wxString& key, const wxString& szValue);
bool Write(const wxString& key, long lValue);
virtual bool Flush(bool bCurrentOnly = FALSE);
virtual bool RenameEntry(const wxString& oldName, const wxString& newName);
virtual bool RenameGroup(const wxString& oldName, const wxString& newName);
virtual bool DeleteEntry(const wxString& Key, bool bGroupIfEmptyAlso);
virtual bool DeleteGroup(const wxString& szKey);
virtual bool DeleteAll();
private:
// helpers
wxString GetPrivateKeyName(const wxString& szKey) const;
wxString GetKeyName(const wxString& szKey) const;
wxString m_strLocalFilename; // name of the private INI file
wxString m_strGroup, // current group in appname.ini file
m_strPath; // the rest of the path (no trailing '_'!)
// Virtual function hiding
virtual bool Read(const wxString& key, bool* val) const
{ return(wxConfigBase::Read(key, val));};
virtual bool Read(const wxString& key, bool* val, bool defVal) const
{ return(wxConfigBase::Read(key, val, defVal));};
virtual bool Write(const wxString& key, double value)
{ return(wxConfigBase::Write(key, value));};
virtual bool Write(const wxString& key, bool value)
{ return(wxConfigBase::Write(key, value));};
};
#endif //_INICONF_H

12
include/wx/os2/joystick.h
View File

@ -1,21 +1,17 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: joystick.h // Name: joystick.h
// Purpose: wxJoystick class // Purpose: wxJoystick class
// Author: AUTHOR // Author: David Webster
// Modified by: // Modified by:
// Created: ??/??/98 // Created: 10/09/99
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) AUTHOR // Copyright: (c) David Webster
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_JOYSTICK_H_ #ifndef _WX_JOYSTICK_H_
#define _WX_JOYSTICK_H_ #define _WX_JOYSTICK_H_
#ifdef __GNUG__
#pragma interface "joystick.h"
#endif
#include "wx/event.h" #include "wx/event.h"
class WXDLLEXPORT wxJoystick: public wxObject class WXDLLEXPORT wxJoystick: public wxObject

69
include/wx/os2/listbox.h
View File

@ -1,25 +1,30 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: listbox.h // Name: listbox.h
// Purpose: wxListBox class // Purpose: wxListBox class
// Author: AUTHOR // Author: David Webster
// Modified by: // Modified by:
// Created: ??/??/98 // Created: 10/09/99
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) AUTHOR // Copyright: (c) David Webster
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifndef _WX_LISTBOX_H_ #ifndef _WX_LISTBOX_H_
#define _WX_LISTBOX_H_ #define _WX_LISTBOX_H_
#ifdef __GNUG__
#pragma interface "listbox.h"
#endif
#include "wx/control.h" #include "wx/control.h"
WXDLLEXPORT_DATA(extern const char*) wxListBoxNameStr; WXDLLEXPORT_DATA(extern const char*) wxListBoxNameStr;
#if wxUSE_OWNER_DRAWN
class WXDLLEXPORT wxOwnerDrawn;
// define the array of list box items
#include <wx/dynarray.h>
WX_DEFINE_ARRAY(wxOwnerDrawn *, wxListBoxItemsArray);
#endif
// forward decl for GetSelections() // forward decl for GetSelections()
class WXDLLEXPORT wxArrayInt; class WXDLLEXPORT wxArrayInt;
@ -53,6 +58,22 @@ class WXDLLEXPORT wxListBox: public wxControl
~wxListBox(); ~wxListBox();
bool OS2Command(WXUINT param, WXWORD id);
#if wxUSE_OWNER_DRAWN
bool OS2OnMeasure(WXMEASUREITEMSTRUCT *item);
bool OS2OnDraw(WXDRAWITEMSTRUCT *item);
// plug-in for derived classes
virtual wxOwnerDrawn *CreateItem(size_t n);
// allows to get the item and use SetXXX functions to set it's appearance
wxOwnerDrawn *GetItem(size_t n) const { return m_aItems[n]; }
// get the index of the given item
int GetItemIndex(wxOwnerDrawn *item) const { return m_aItems.Index(item); }
#endif // wxUSE_OWNER_DRAWN
virtual void Append(const wxString& item); virtual void Append(const wxString& item);
virtual void Append(const wxString& item, void *clientData); virtual void Append(const wxString& item, void *clientData);
virtual void Set(int n, const wxString* choices, char **clientData = NULL); virtual void Set(int n, const wxString* choices, char **clientData = NULL);
@ -65,15 +86,14 @@ class WXDLLEXPORT wxListBox: public wxControl
// For single choice list item only // For single choice list item only
virtual int GetSelection() const ; virtual int GetSelection() const ;
virtual void Delete(int n); virtual void Delete(int n);
virtual char *GetClientData(int n) const ; virtual void *GetClientData(int n) const ;
virtual void SetClientData(int n, char *clientData); virtual void SetClientData(int n, void *clientData);
virtual void SetString(int n, const wxString& s); virtual void SetString(int n, const wxString& s);
// For single or multiple choice list item // For single or multiple choice list item
virtual int GetSelections(wxArrayInt& aSelections) const; virtual int GetSelections(wxArrayInt& aSelections) const;
virtual bool Selected(int n) const ; virtual bool Selected(int n) const ;
virtual wxString GetString(int n) const ; virtual wxString GetString(int n) const ;
virtual void SetSize(int x, int y, int width, int height, int sizeFlags = wxSIZE_AUTO);
// Set the specified item at the first visible item // Set the specified item at the first visible item
// or scroll to max range. // or scroll to max range.
@ -88,9 +108,34 @@ class WXDLLEXPORT wxListBox: public wxControl
void Command(wxCommandEvent& event); void Command(wxCommandEvent& event);
protected: // OS/2-PM-specific code to set the horizontal extent of
// the listbox, if necessary. If s is non-NULL, it's
// used to calculate the horizontal extent.
// Otherwise, all strings are used.
virtual void SetHorizontalExtent(const wxString& s = wxEmptyString);
virtual WXHBRUSH OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
WXUINT message, WXWPARAM wParam, WXLPARAM lParam);
virtual MRESULT OS2WindowProc(HWND hwnd, WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam);
virtual void SetupColours();
protected:
int m_noItems; int m_noItems;
int m_selected; int m_selected;
virtual wxSize DoGetBestSize();
#if wxUSE_OWNER_DRAWN
// control items
wxListBoxItemsArray m_aItems;
#endif
private:
//Virtual function hiding suppression, do not use
wxControl *CreateItem(const wxItemResource* childResource,
const wxItemResource* parentResource,
const wxResourceTable *table = (const wxResourceTable *) NULL)
{ return(wxWindowBase::CreateItem(childResource, parentResource, table));};
}; };
#endif #endif

50
src/os2/brush.cpp
View File

@ -81,20 +81,6 @@ wxBrush::wxBrush(const wxBitmap& stipple)
wxTheBrushList->AddBrush(this); wxTheBrushList->AddBrush(this);
} }
void wxBrush::Unshare()
{
// Don't change shared data
if (!m_refData)
{
m_refData = new wxBrushRefData();
}
else
{
wxBrushRefData* ref = new wxBrushRefData(*(wxBrushRefData*)m_refData);
UnRef();
m_refData = ref;
}
}
void wxBrush::SetColour(const wxColour& col) void wxBrush::SetColour(const wxColour& col)
{ {
@ -138,3 +124,39 @@ bool wxBrush::RealizeResource()
return FALSE; return FALSE;
} }
WXHANDLE wxBrush::GetResourceHandle(void)
{
return (WXHANDLE) M_BRUSHDATA->m_hBrush;
}
bool wxBrush::FreeResource(bool WXUNUSED(force))
{
if (M_BRUSHDATA && (M_BRUSHDATA->m_hBrush != 0))
{
// TODO DeleteObject((HBRUSH) M_BRUSHDATA->m_hBrush);
M_BRUSHDATA->m_hBrush = 0;
return TRUE;
}
else return FALSE;
}
bool wxBrush::IsFree() const
{
return (M_BRUSHDATA && (M_BRUSHDATA->m_hBrush == 0));
}
void wxBrush::Unshare()
{
// Don't change shared data
if (!m_refData)
{
m_refData = new wxBrushRefData();
}
else
{
wxBrushRefData* ref = new wxBrushRefData(*(wxBrushRefData*)m_refData);
UnRef();
m_refData = ref;
}
}

1208
src/os2/gsocket.c Normal file
View File

File diff suppressed because it is too large Load Diff

148
src/os2/helpwin.cpp Normal file
View File

@ -0,0 +1,148 @@
/////////////////////////////////////////////////////////////////////////////
// Name: helpwin.cpp
// Purpose: Help system: native implementation
// Author: David Webster
// Modified by:
// Created: 10/09/99
// RCS-ID: $Id$
// Copyright: (c) David Webster
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifndef WX_PRECOMP
#include "wx/defs.h"
#endif
#include "wx/os2/helpwin.h"
#if wxUSE_HELP
#include <time.h>
#include <wx/os2/private.h>
#include <string.h>
// MAX path length
#define _MAXPATHLEN 500
// MAX length of Help descriptor
#define _MAX_HELP_LEN 500
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxWinHelpController, wxHelpControllerBase)
#endif
wxWinHelpController::wxWinHelpController()
{
m_helpFile = "";
}
wxWinHelpController::~wxWinHelpController()
{
}
bool wxWinHelpController::Initialize(const wxString& filename)
{
m_helpFile = filename;
// TODO any other inits
return TRUE;
}
bool wxWinHelpController::LoadFile(const wxString& file)
{
m_helpFile = file;
// TODO
return TRUE;
}
bool wxWinHelpController::DisplayContents()
{
if (m_helpFile == wxT("")) return FALSE;
wxString str = m_helpFile;
size_t len = str.Length();
if (!(str[(size_t)(len-1)] == wxT('p') && str[(size_t)(len-2)] == wxT('l') && str[(size_t)(len-3)] == wxT('h') && str[(size_t)(len-4)] == wxT('.')))
str += wxT(".hlp");
if (wxTheApp->GetTopWindow())
{
// TODO : display the help
return TRUE;
}
return FALSE;
}
bool wxWinHelpController::DisplaySection(int section)
{
// Use context number
if (m_helpFile == wxT("")) return FALSE;
wxString str = m_helpFile;
size_t len = str.Length();
if (!(str[(size_t)(len-1)] == wxT('p') && str[(size_t)(len-2)] == wxT('l') && str[(size_t)(len-3)] == wxT('h') && str[(size_t)(len-4)] == wxT('.')))
str += wxT(".hlp");
if (wxTheApp->GetTopWindow())
{
// TODO ::
// WinHelp((HWND) wxTheApp->GetTopWindow()->GetHWND(), (const wxChar*) str, HELP_CONTEXT, (DWORD)section);
return TRUE;
}
return FALSE;
}
bool wxWinHelpController::DisplayBlock(long block)
{
// Use context number -- a very rough equivalent to block id!
if (m_helpFile == wxT("")) return FALSE;
wxString str = m_helpFile;
size_t len = str.Length();
if (!(str[(size_t)(len-1)] == 'p' && str[(size_t)(len-2)] == 'l' && str[(size_t)(len-3)] == 'h' && str[(size_t)(len-4)] == '.'))
str += wxT(".hlp");
if (wxTheApp->GetTopWindow())
{
// TODO:
// WinHelp((HWND) wxTheApp->GetTopWindow()->GetHWND(), (const wxChar*) str, HELP_CONTEXT, (DWORD)block);
return TRUE;
}
return FALSE;
}
bool wxWinHelpController::KeywordSearch(const wxString& k)
{
if (m_helpFile == "") return FALSE;
wxString str = m_helpFile;
size_t len = str.Length();
if (!(str[(size_t)(len-1)] == wxT('p') && str[(size_t)(len-2)] == wxT('l') && str[(size_t)(len-3)] == wxT('h') && str[(size_t)(len-4)] == wxT('.')))
str += wxT(".hlp");
if (wxTheApp->GetTopWindow())
{
// TODO:
// WinHelp((HWND) wxTheApp->GetTopWindow()->GetHWND(), (const wxChar*) str, HELP_PARTIALKEY, (DWORD)(const wxChar*) k);
return TRUE;
}
return FALSE;
}
// Can't close the help window explicitly in WinHelp
bool wxWinHelpController::Quit()
{
if (wxTheApp->GetTopWindow())
{
// TODO:
// WinHelp((HWND) wxTheApp->GetTopWindow()->GetHWND(), 0, HELP_QUIT, 0L);
return TRUE;
}
else
return FALSE;
}
void wxWinHelpController::OnQuit()
{
}
#endif // wxUSE_HELP

83
src/os2/helpxxxx.cpp
View File

@ -1,83 +0,0 @@
/////////////////////////////////////////////////////////////////////////////
// Name: helpxxxx.cpp
// Purpose: Help system: native implementation
// Author: AUTHOR
// Modified by:
// Created: ??/??/98
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "helpxxxx.h"
#endif
#include "wx/stubs/helpxxxx.h"
#include <string.h>
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxXXXXHelpController, wxHelpControllerBase)
#endif
wxXXXXHelpController::wxXXXXHelpController()
{
m_helpFile = "";
}
wxXXXXHelpController::~wxXXXXHelpController()
{
}
bool wxXXXXHelpController::Initialize(const wxString& filename)
{
m_helpFile = filename;
// TODO any other inits
return TRUE;
}
bool wxXXXXHelpController::LoadFile(const wxString& file)
{
m_helpFile = file;
// TODO
return TRUE;
}
bool wxXXXXHelpController::DisplayContents()
{
// TODO
return FALSE;
}
bool wxXXXXHelpController::DisplaySection(int section)
{
// TODO
return FALSE;
}
bool wxXXXXHelpController::DisplayBlock(long block)
{
// TODO
return FALSE;
}
bool wxXXXXHelpController::KeywordSearch(const wxString& k)
{
if (m_helpFile == "") return FALSE;
// TODO
return FALSE;
}
// Can't close the help window explicitly in WinHelp
bool wxXXXXHelpController::Quit()
{
// TODO
return FALSE;
}
void wxXXXXHelpController::OnQuit()
{
}

102
src/os2/icon.cpp
View File

@ -1,37 +1,55 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: icon.cpp // Name: icon.cpp
// Purpose: wxIcon class // Purpose: wxIcon class
// Author: AUTHOR // Author: David Webster
// Modified by: // Modified by:
// Created: ??/??/98 // Created: 10/09/99
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) AUTHOR // Copyright: (c) David Webster
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ // For compilers that support precompilation, includes "wx.h".
#pragma implementation "icon.h" #include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif #endif
#ifndef WX_PRECOMP
#include <stdio.h>
#include "wx/setup.h"
#include "wx/list.h"
#include "wx/utils.h"
#include "wx/app.h"
#include "wx/icon.h"
#endif
#include "wx/os2/private.h"
#include "assert.h"
#include "wx/icon.h" #include "wx/icon.h"
#if !USE_SHARED_LIBRARIES #if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap) IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxBitmapHandler)
#endif #endif
/* /*
* Icons * Icons
*/ */
wxIconRefData::wxIconRefData() wxIconRefData::wxIconRefData()
{ {
// TODO: init icon handle m_hIcon = (WXHICON) NULL ;
} }
wxIconRefData::~wxIconRefData() wxIconRefData::~wxIconRefData()
{ {
// TODO: destroy icon handle if ( m_hIcon )
return;
// TODO ::DestroyIcon((HICON) m_hIcon);
} }
wxIcon::wxIcon() wxIcon::wxIcon()
@ -63,8 +81,70 @@ bool wxIcon::LoadFile(const wxString& filename, long type,
wxBitmapHandler *handler = FindHandler(type); wxBitmapHandler *handler = FindHandler(type);
if ( handler ) if ( handler )
return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight); return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight);
else else
return FALSE; return FALSE;
}
void wxIcon::SetHICON(WXHICON ico)
{
if ( !M_ICONDATA )
m_refData = new wxIconRefData;
M_ICONDATA->m_hIcon = ico;
}
bool wxICOFileHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
int desiredWidth, int desiredHeight)
{
return FALSE;
}
bool wxICOResourceHandler::LoadFile(wxBitmap *bitmap, const wxString& name, long flags,
int desiredWidth, int desiredHeight)
{
// TODO
/*
if ( bitmap->IsKindOf(CLASSINFO(wxIcon)) )
{
if (desiredWidth > -1 && desiredHeight > -1)
{
M_ICONHANDLERDATA->m_hIcon = (WXHICON) ::LoadImage(wxGetInstance(), name, IMAGE_ICON, desiredWidth, desiredHeight, LR_DEFAULTCOLOR);
}
else
{
M_ICONHANDLERDATA->m_hIcon = (WXHICON) ::LoadIcon(wxGetInstance(), name);
}
ICONINFO info ;
if (::GetIconInfo((HICON) M_ICONHANDLERDATA->m_hIcon, &info))
{
HBITMAP ms_bitmap = info.hbmMask ;
if (ms_bitmap)
{
BITMAP bm;
::GetObject(ms_bitmap, sizeof(BITMAP), (LPSTR) &bm);
M_ICONHANDLERDATA->m_width = bm.bmWidth;
M_ICONHANDLERDATA->m_height = bm.bmHeight;
}
if (info.hbmMask)
::DeleteObject(info.hbmMask) ;
if (info.hbmColor)
::DeleteObject(info.hbmColor) ;
}
}
// Override the found values with desired values
if (desiredWidth > -1 && desiredHeight > -1)
{
M_ICONHANDLERDATA->m_width = desiredWidth;
M_ICONHANDLERDATA->m_height = desiredHeight;
}
M_ICONHANDLERDATA->m_ok = (M_ICONHANDLERDATA->m_hIcon != 0);
return M_ICONHANDLERDATA->m_ok;
}
else
*/
return FALSE;
} }

134
src/os2/imaglist.cpp
View File

@ -1,19 +1,31 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: imaglist.cpp // Name: imaglist.cpp
// Purpose: wxImageList. You may wish to use the generic version. // Purpose: wxImageList. You may wish to use the generic version.
// Author: AUTHOR // Author: David Webster
// Modified by: // Modified by:
// Created: ??/??/98 // Created: 10/09/99
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) AUTHOR // Copyright: (c) David Webster
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ // For compilers that support precompilation, includes "wx.h".
#pragma implementation "imaglist.h" #include "wx/wxprec.h"
#ifndef WX_PRECOMP
#include <stdio.h>
#include "wx/setup.h"
#include "wx/window.h"
#include "wx/icon.h"
#include "wx/dc.h"
#include "wx/string.h"
#endif #endif
#include "wx/stubs/imaglist.h" #include "wx/log.h"
#include "wx/intl.h"
#include "wx/os2/imaglist.h"
#include "wx/os2/private.h"
#if !USE_SHARED_LIBRARY #if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxImageList, wxObject) IMPLEMENT_DYNAMIC_CLASS(wxImageList, wxObject)
@ -21,23 +33,25 @@ IMPLEMENT_DYNAMIC_CLASS(wxImageList, wxObject)
wxImageList::wxImageList() wxImageList::wxImageList()
{ {
// TODO: init image list handle, if any m_hImageList = 0;
} }
wxImageList::~wxImageList() wxImageList::~wxImageList()
{ {
// TODO: destroy image list handle, if any if ( m_hImageList )
return;
// TODO: ImageList_Destroy((HIMAGELIST) m_hImageList);
m_hImageList = 0;
} }
// Attributes // Attributes
//////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////
// Returns the number of images in the image list. // Returns the number of images in the image list.
int wxImageList::GetImageCount() const int wxImageList::GetImageCount() const
{ {
// TODO // TODO:: return ImageList_GetImageCount((HIMAGELIST) m_hImageList);
return 0; return 0;
} }
// Operations // Operations
@ -46,8 +60,13 @@ int wxImageList::GetImageCount() const
// Creates an image list // Creates an image list
bool wxImageList::Create(int width, int height, bool mask, int initial) bool wxImageList::Create(int width, int height, bool mask, int initial)
{ {
// TODO UINT flags = 0;
return FALSE; // if ( mask )
// TODO flags |= ILC_MASK;
// Grow by 1, I guess this is reasonable behaviour most of the time
// m_hImageList = (WXHIMAGELIST) ImageList_Create(width, height, flags, initial, 1);
return (m_hImageList != 0);
} }
// Adds a bitmap, and optionally a mask bitmap. // Adds a bitmap, and optionally a mask bitmap.
@ -55,8 +74,17 @@ bool wxImageList::Create(int width, int height, bool mask, int initial)
// 'bitmap' and 'mask'. // 'bitmap' and 'mask'.
int wxImageList::Add(const wxBitmap& bitmap, const wxBitmap& mask) int wxImageList::Add(const wxBitmap& bitmap, const wxBitmap& mask)
{ {
// TODO HBITMAP hBitmap1 = (HBITMAP) bitmap.GetHBITMAP();
return 0; HBITMAP hBitmap2 = 0;
if ( mask.Ok() )
hBitmap2 = (HBITMAP) mask.GetHBITMAP();
int index; // = ImageList_Add((HIMAGELIST) GetHIMAGELIST(), hBitmap1, hBitmap2);
if ( index == -1 )
{
wxLogError(wxT("Couldn't add an image to the image list."));
}
return index;
} }
// Adds a bitmap, using the specified colour to create the mask bitmap // Adds a bitmap, using the specified colour to create the mask bitmap
@ -64,15 +92,19 @@ int wxImageList::Add(const wxBitmap& bitmap, const wxBitmap& mask)
// 'bitmap'. // 'bitmap'.
int wxImageList::Add(const wxBitmap& bitmap, const wxColour& maskColour) int wxImageList::Add(const wxBitmap& bitmap, const wxColour& maskColour)
{ {
// TODO HBITMAP hBitmap1 = (HBITMAP) bitmap.GetHBITMAP();
return 0; //TODO:
// COLORREF colorRef = PALETTERGB(maskColour.Red(), maskColour.Green(), maskColour.Blue());
// return ImageList_AddMasked((HIMAGELIST) GetHIMAGELIST(), hBitmap1, colorRef);
return 0;
} }
// Adds a bitmap and mask from an icon. // Adds a bitmap and mask from an icon.
int wxImageList::Add(const wxIcon& icon) int wxImageList::Add(const wxIcon& icon)
{ {
// TODO HICON hIcon = (HICON) icon.GetHICON();
return 0; // TODO: return ImageList_AddIcon((HIMAGELIST) GetHIMAGELIST(), hIcon);
return 0;
} }
// Replaces a bitmap, optionally passing a mask bitmap. // Replaces a bitmap, optionally passing a mask bitmap.
@ -80,29 +112,38 @@ int wxImageList::Add(const wxIcon& icon)
// 'bitmap' and 'mask'. // 'bitmap' and 'mask'.
bool wxImageList::Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask) bool wxImageList::Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask)
{ {
// TODO HBITMAP hBitmap1 = (HBITMAP) bitmap.GetHBITMAP();
return 0; HBITMAP hBitmap2 = 0;
if ( mask.Ok() )
hBitmap2 = (HBITMAP) mask.GetHBITMAP();
// TODO: return (ImageList_Replace((HIMAGELIST) GetHIMAGELIST(), index, hBitmap1, hBitmap2) != 0);
return TRUE;
} }
// Replaces a bitmap and mask from an icon. // Replaces a bitmap and mask from an icon.
bool wxImageList::Replace(int index, const wxIcon& icon) bool wxImageList::Replace(int index, const wxIcon& icon)
{ {
// TODO HICON hIcon = (HICON) icon.GetHICON();
return 0; // TODO: return (ImageList_ReplaceIcon((HIMAGELIST) GetHIMAGELIST(), index, hIcon) != 0);
return FALSE;
} }
// Removes the image at the given index. // Removes the image at the given index.
bool wxImageList::Remove(int index) bool wxImageList::Remove(int index)
{ {
// TODO // TODO return (ImageList_Remove((HIMAGELIST) GetHIMAGELIST(), index) != 0);
return FALSE; return FALSE;
} }
// Remove all images bool wxImageList::RemoveAll(void)
bool wxImageList::RemoveAll()
{ {
// TODO // TODO: Is this correct?
return FALSE; while ( GetImageCount() > 0 )
{
Remove(0);
}
return TRUE;
} }
// Draws the given image on a dc at the specified position. // Draws the given image on a dc at the specified position.
@ -112,7 +153,40 @@ bool wxImageList::RemoveAll()
bool wxImageList::Draw(int index, wxDC& dc, int x, int y, bool wxImageList::Draw(int index, wxDC& dc, int x, int y,
int flags, bool solidBackground) int flags, bool solidBackground)
{ {
// TODO HDC hDC = (HDC) dc.GetHDC();
if ( !hDC )
return FALSE; return FALSE;
if ( solidBackground )
{
wxBrush *brush = & dc.GetBackground();
if ( brush && brush->Ok())
{
wxColour col(brush->GetColour());
// ImageList_SetBkColor((HIMAGELIST) GetHIMAGELIST(),
// PALETTERGB(col.Red(), col.Green(), col.Blue()));
}
// else
// ImageList_SetBkColor((HIMAGELIST) GetHIMAGELIST(),
// CLR_NONE);
}
// else
// ImageList_SetBkColor((HIMAGELIST) GetHIMAGELIST(),
// CLR_NONE);
UINT style = 0;
/*
if ( flags & wxIMAGELIST_DRAW_NORMAL )
style |= ILD_NORMAL;
if ( flags & wxIMAGELIST_DRAW_TRANSPARENT )
style |= ILD_TRANSPARENT;
if ( flags & wxIMAGELIST_DRAW_SELECTED )
style |= ILD_SELECTED;
if ( flags & wxIMAGELIST_DRAW_FOCUSED )
style |= ILD_FOCUS;
return (ImageList_Draw((HIMAGELIST) GetHIMAGELIST(), index, hDC,
x, y, style) != 0);
*/
return TRUE;
} }

463
src/os2/iniconf.cpp Normal file
View File

@ -0,0 +1,463 @@
///////////////////////////////////////////////////////////////////////////////
// Name: src/os2/iniconf.cpp
// Purpose: implementation of wxIniConfig class
// Author: David Webster
// Modified by:
// Created: 10/09/99
// Copyright: David Webster
// Licence: wxWindows license
///////////////////////////////////////////////////////////////////////////////
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifndef WX_PRECOMP
#include <wx/string.h>
#include <wx/intl.h>
#include <wx/event.h>
#include <wx/app.h>
#include <wx/utils.h>
#endif //WX_PRECOMP
#include <wx/dynarray.h>
#include <wx/log.h>
#include <wx/config.h>
#include <wx/os2/iniconf.h>
#define INCL_PM
#include <os2.h>
// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------
// we replace all path separators with this character
#define PATH_SEP_REPLACE '_'
// ============================================================================
// implementation
// ============================================================================
// ----------------------------------------------------------------------------
// ctor & dtor
// ----------------------------------------------------------------------------
wxIniConfig::wxIniConfig(const wxString& strAppName,
const wxString& strVendor,
const wxString& localFilename,
const wxString& globalFilename,
long style)
: wxConfigBase(!strAppName && wxTheApp ? wxTheApp->GetAppName()
: strAppName,
!strVendor ? (wxTheApp ? wxTheApp->GetVendorName()
: strAppName)
: strVendor,
localFilename, globalFilename, style)
{
m_strLocalFilename = localFilename;
if (m_strLocalFilename.IsEmpty())
{
m_strLocalFilename = GetAppName() + ".ini";
}
// append the extension if none given and it's not an absolute file name
// (otherwise we assume that they know what they're doing)
if ( !wxIsPathSeparator(m_strLocalFilename[0u]) &&
m_strLocalFilename.Find('.') == wxNOT_FOUND )
{
m_strLocalFilename << ".ini";
}
// set root path
SetPath("");
}
wxIniConfig::~wxIniConfig()
{
}
// ----------------------------------------------------------------------------
// path management
// ----------------------------------------------------------------------------
void wxIniConfig::SetPath(const wxString& strPath)
{
wxArrayString aParts;
if ( strPath.IsEmpty() ) {
// nothing
}
else if ( strPath[0u] == wxCONFIG_PATH_SEPARATOR ) {
// absolute path
wxSplitPath(aParts, strPath);
}
else {
// relative path, combine with current one
wxString strFullPath = GetPath();
strFullPath << wxCONFIG_PATH_SEPARATOR << strPath;
wxSplitPath(aParts, strFullPath);
}
size_t nPartsCount = aParts.Count();
m_strPath.Empty();
if ( nPartsCount == 0 ) {
// go to the root
m_strGroup = PATH_SEP_REPLACE;
}
else {
// translate
m_strGroup = aParts[0u];
for ( size_t nPart = 1; nPart < nPartsCount; nPart++ ) {
if ( nPart > 1 )
m_strPath << PATH_SEP_REPLACE;
m_strPath << aParts[nPart];
}
}
// other functions assume that all this is true, i.e. there are no trailing
// underscores at the end except if the group is the root one
wxASSERT( (m_strPath.IsEmpty() || m_strPath.Last() != PATH_SEP_REPLACE) &&
(m_strGroup == wxString(PATH_SEP_REPLACE) ||
m_strGroup.Last() != PATH_SEP_REPLACE) );
}
const wxString& wxIniConfig::GetPath() const
{
static wxString s_str;
// always return abs path
s_str = wxCONFIG_PATH_SEPARATOR;
if ( m_strGroup == wxString(PATH_SEP_REPLACE) ) {
// we're at the root level, nothing to do
}
else {
s_str << m_strGroup;
if ( !m_strPath.IsEmpty() )
s_str << wxCONFIG_PATH_SEPARATOR;
for ( const char *p = m_strPath; *p != '\0'; p++ ) {
s_str << (*p == PATH_SEP_REPLACE ? wxCONFIG_PATH_SEPARATOR : *p);
}
}
return s_str;
}
wxString wxIniConfig::GetPrivateKeyName(const wxString& szKey) const
{
wxString strKey;
if ( !m_strPath.IsEmpty() )
strKey << m_strPath << PATH_SEP_REPLACE;
strKey << szKey;
return strKey;
}
wxString wxIniConfig::GetKeyName(const wxString& szKey) const
{
wxString strKey;
if ( m_strGroup != wxString(PATH_SEP_REPLACE) )
strKey << m_strGroup << PATH_SEP_REPLACE;
if ( !m_strPath.IsEmpty() )
strKey << m_strPath << PATH_SEP_REPLACE;
strKey << szKey;
return strKey;
}
// ----------------------------------------------------------------------------
// enumeration
// ----------------------------------------------------------------------------
// not implemented
bool wxIniConfig::GetFirstGroup(wxString& str, long& lIndex) const
{
wxFAIL_MSG("not implemented");
return FALSE;
}
bool wxIniConfig::GetNextGroup (wxString& str, long& lIndex) const
{
wxFAIL_MSG("not implemented");
return FALSE;
}
bool wxIniConfig::GetFirstEntry(wxString& str, long& lIndex) const
{
wxFAIL_MSG("not implemented");
return FALSE;
}
bool wxIniConfig::GetNextEntry (wxString& str, long& lIndex) const
{
wxFAIL_MSG("not implemented");
return FALSE;
}
// ----------------------------------------------------------------------------
// misc info
// ----------------------------------------------------------------------------
// not implemented
size_t wxIniConfig::GetNumberOfEntries(bool bRecursive) const
{
wxFAIL_MSG("not implemented");
return (size_t)-1;
}
size_t wxIniConfig::GetNumberOfGroups(bool bRecursive) const
{
wxFAIL_MSG("not implemented");
return (size_t)-1;
}
bool wxIniConfig::HasGroup(const wxString& strName) const
{
wxFAIL_MSG("not implemented");
return FALSE;
}
bool wxIniConfig::HasEntry(const wxString& strName) const
{
wxFAIL_MSG("not implemented");
return FALSE;
}
// is current group empty?
bool wxIniConfig::IsEmpty() const
{
char szBuf[1024];
// GetPrivateProfileString(m_strGroup, NULL, "",
// szBuf, WXSIZEOF(szBuf), m_strLocalFilename);
if ( !::IsEmpty(szBuf) )
return FALSE;
// GetProfileString(m_strGroup, NULL, "", szBuf, WXSIZEOF(szBuf));
// if ( !::IsEmpty(szBuf) )
return FALSE;
return TRUE;
}
// ----------------------------------------------------------------------------
// read/write
// ----------------------------------------------------------------------------
bool wxIniConfig::Read(const wxString& szKey, wxString *pstr) const
{
wxConfigPathChanger path(this, szKey);
wxString strKey = GetPrivateKeyName(path.Name());
char szBuf[1024]; // @@ should dynamically allocate memory...
// first look in the private INI file
// NB: the lpDefault param to GetPrivateProfileString can't be NULL
// GetPrivateProfileString(m_strGroup, strKey, "",
// szBuf, WXSIZEOF(szBuf), m_strLocalFilename);
if ( ::IsEmpty(szBuf) ) {
// now look in win.ini
wxString strKey = GetKeyName(path.Name());
// GetProfileString(m_strGroup, strKey, "", szBuf, WXSIZEOF(szBuf));
}
if ( ::IsEmpty(szBuf) ) {
return FALSE;
}
else {
*pstr = szBuf ;
return TRUE;
}
}
bool wxIniConfig::Read(const wxString& szKey, wxString *pstr,
const wxString& szDefault) const
{
wxConfigPathChanger path(this, szKey);
wxString strKey = GetPrivateKeyName(path.Name());
char szBuf[1024]; // @@ should dynamically allocate memory...
// first look in the private INI file
// NB: the lpDefault param to GetPrivateProfileString can't be NULL
// GetPrivateProfileString(m_strGroup, strKey, "",
// szBuf, WXSIZEOF(szBuf), m_strLocalFilename);
if ( ::IsEmpty(szBuf) ) {
// now look in win.ini
wxString strKey = GetKeyName(path.Name());
// GetProfileString(m_strGroup, strKey, "", szBuf, WXSIZEOF(szBuf));
}
if ( ::IsEmpty(szBuf) ) {
*pstr = szDefault;
return FALSE;
}
else {
*pstr = szBuf ;
return TRUE;
}
}
bool wxIniConfig::Read(const wxString& szKey, long *pl) const
{
wxConfigPathChanger path(this, szKey);
wxString strKey = GetPrivateKeyName(path.Name());
// hack: we have no mean to know if it really found the default value or
// didn't find anything, so we call it twice
static const int nMagic = 17; // 17 is some "rare" number
static const int nMagic2 = 28; // arbitrary number != nMagic
long lVal; // = GetPrivateProfileInt(m_strGroup, strKey, nMagic, m_strLocalFilename);
if ( lVal != nMagic ) {
// the value was read from the file
*pl = lVal;
return TRUE;
}
// is it really nMagic?
// lVal = GetPrivateProfileInt(m_strGroup, strKey, nMagic2, m_strLocalFilename);
if ( lVal == nMagic2 ) {
// the nMagic it returned was indeed read from the file
*pl = lVal;
return TRUE;
}
// no, it was just returning the default value, so now look in win.ini
// *pl = GetProfileInt(GetVendorName(), GetKeyName(szKey), *pl);
return TRUE;
}
bool wxIniConfig::Write(const wxString& szKey, const wxString& szValue)
{
wxConfigPathChanger path(this, szKey);
wxString strKey = GetPrivateKeyName(path.Name());
bool bOk; // = WritePrivateProfileString(m_strGroup, strKey,
// szValue, m_strLocalFilename) != 0;
if ( !bOk )
wxLogLastError("WritePrivateProfileString");
return bOk;
}
bool wxIniConfig::Write(const wxString& szKey, long lValue)
{
// ltoa() is not ANSI :-(
char szBuf[40]; // should be good for sizeof(long) <= 16 (128 bits)
sprintf(szBuf, "%ld", lValue);
return Write(szKey, szBuf);
}
bool wxIniConfig::Flush(bool /* bCurrentOnly */)
{
// this is just the way it works
// return WritePrivateProfileString(NULL, NULL, NULL, m_strLocalFilename) != 0;
return FALSE;
}
// ----------------------------------------------------------------------------
// delete
// ----------------------------------------------------------------------------
bool wxIniConfig::DeleteEntry(const wxString& szKey, bool bGroupIfEmptyAlso)
{
// passing NULL as value to WritePrivateProfileString deletes the key
// if ( !Write(szKey, (const char *)NULL) )
// return FALSE;
wxConfigPathChanger path(this, szKey);
wxString strKey = GetPrivateKeyName(path.Name());
// if (WritePrivateProfileString(m_strGroup, szKey,
// (const char*) NULL, m_strLocalFilename) == 0)
// return FALSE;
if ( !bGroupIfEmptyAlso || !IsEmpty() )
return TRUE;
// delete the current group too
bool bOk; // = WritePrivateProfileString(m_strGroup, NULL,
// NULL, m_strLocalFilename) != 0;
if ( !bOk )
wxLogLastError("WritePrivateProfileString");
return bOk;
}
bool wxIniConfig::DeleteGroup(const wxString& szKey)
{
wxConfigPathChanger path(this, szKey);
// passing NULL as section name to WritePrivateProfileString deletes the
// whole section according to the docs
bool bOk; // = WritePrivateProfileString(path.Name(), NULL,
// NULL, m_strLocalFilename) != 0;
if ( !bOk )
wxLogLastError("WritePrivateProfileString");
return bOk;
}
#ifndef MAX_PATH
#define MAX_PATH 256
#endif
bool wxIniConfig::DeleteAll()
{
// first delete our group in win.ini
// WriteProfileString(GetVendorName(), NULL, NULL);
// then delete our own ini file
char szBuf[MAX_PATH];
size_t nRc; // = GetWindowsDirectory(szBuf, WXSIZEOF(szBuf));
if ( nRc == 0 )
{
wxLogLastError("GetWindowsDirectory");
}
else if ( nRc > WXSIZEOF(szBuf) )
{
wxFAIL_MSG("buffer is too small for Windows directory.");
}
wxString strFile = szBuf;
strFile << '\\' << m_strLocalFilename;
if ( !wxRemoveFile(strFile) ) {
wxLogSysError(_("Can't delete the INI file '%s'"), strFile.c_str());
return FALSE;
}
return TRUE;
}
bool wxIniConfig::RenameEntry(const wxString& oldName, const wxString& newName)
{
// Not implemented
return FALSE;
}
bool wxIniConfig::RenameGroup(const wxString& oldName, const wxString& newName)
{
// Not implemented
return FALSE;
}

18
src/os2/joystick.cpp
View File

@ -1,18 +1,22 @@
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
// Name: joystick.cpp // Name: joystick.cpp
// Purpose: wxJoystick class // Purpose: wxJoystick class
// Author: AUTHOR // Author: David Webster
// Modified by: // Modified by:
// Created: ??/??/98 // Created: 10/09/99
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) AUTHOR // Copyright: (c) David Webster
// Licence: wxWindows licence // Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ #include "wx/string.h"
#pragma implementation "joystick.h" #define INCL_PM
#endif #include "os2.h"
#include "wx/os2/private.h"
#define NO_JOYGETPOSEX
#include <wx/window.h>
#include <wx/joystick.h> #include <wx/joystick.h>
IMPLEMENT_DYNAMIC_CLASS(wxJoystick, wxObject) IMPLEMENT_DYNAMIC_CLASS(wxJoystick, wxObject)

594
src/os2/listbox.cpp
View File

@ -1,31 +1,110 @@
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
// Name: listbox.cpp // Name: listbox.cpp
// Purpose: wxListBox // Purpose: wxListBox
// Author: AUTHOR // Author: David Webster
// Modified by: // Modified by:
// Created: ??/??/98 // Created: 10/09/99
// RCS-ID: $Id$ // RCS-ID: $Id$
// Copyright: (c) AUTHOR // Copyright: (c) David Webster
// Licence: wxWindows licence // Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////// ///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__ // For compilers that support precompilation, includes "wx.h".
#pragma implementation "listbox.h" #include "wx/wxprec.h"
#endif
#include "wx/window.h"
#include "wx/os2/private.h"
#ifndef WX_PRECOMP
#include "wx/listbox.h" #include "wx/listbox.h"
#include "wx/settings.h" #include "wx/settings.h"
#include "wx/brush.h"
#include "wx/font.h"
#include "wx/dc.h"
#include "wx/utils.h"
#endif
#define INCL_M
#include <os2.h>
#include "wx/dynarray.h" #include "wx/dynarray.h"
#include "wx/log.h" #include "wx/log.h"
#if wxUSE_OWNER_DRAWN
#include "wx/ownerdrw.h"
#endif
#if !USE_SHARED_LIBRARY #if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControl) IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControl)
#endif #endif
// ============================================================================
// list box item declaration and implementation
// ============================================================================
#if wxUSE_OWNER_DRAWN
class wxListBoxItem : public wxOwnerDrawn
{
public:
wxListBoxItem(const wxString& str = "");
};
wxListBoxItem::wxListBoxItem(const wxString& str) : wxOwnerDrawn(str, FALSE)
{
// no bitmaps/checkmarks
SetMarginWidth(0);
}
wxOwnerDrawn *wxListBox::CreateItem(size_t n)
{
return new wxListBoxItem();
}
#endif //USE_OWNER_DRAWN
// ============================================================================ // ============================================================================
// list box control implementation // list box control implementation
// ============================================================================ // ============================================================================
bool wxListBox::OS2Command(WXUINT param, WXWORD WXUNUSED(id))
{
/*
if (param == LBN_SELCHANGE)
{
wxCommandEvent event(wxEVT_COMMAND_LISTBOX_SELECTED, m_windowId);
wxArrayInt aSelections;
int count = GetSelections(aSelections);
if ( count > 0 )
{
event.m_commandInt = aSelections[0] ;
event.m_clientData = GetClientData(event.m_commandInt);
wxString str(GetString(event.m_commandInt));
if (str != wxT(""))
{
event.m_commandString = str;
}
}
else
{
event.m_commandInt = -1 ;
event.m_commandString.Empty();
}
event.SetEventObject( this );
ProcessCommand(event);
return TRUE;
}
else if (param == LBN_DBLCLK)
{
wxCommandEvent event(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, m_windowId);
event.SetEventObject( this );
GetEventHandler()->ProcessEvent(event) ;
return TRUE;
}
*/
return FALSE;
}
// Listbox item // Listbox item
wxListBox::wxListBox() wxListBox::wxListBox()
{ {
@ -42,6 +121,7 @@ bool wxListBox::Create(wxWindow *parent, wxWindowID id,
const wxString& name) const wxString& name)
{ {
m_noItems = n; m_noItems = n;
m_hWnd = 0;
m_selected = 0; m_selected = 0;
SetName(name); SetName(name);
@ -51,92 +131,285 @@ bool wxListBox::Create(wxWindow *parent, wxWindowID id,
wxSystemSettings settings; wxSystemSettings settings;
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW)); SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
SetForegroundColour(parent->GetForegroundColour());
m_windowId = ( id == -1 ) ? (int)NewControlId() : id; m_windowId = ( id == -1 ) ? (int)NewControlId() : id;
int x = pos.x;
int y = pos.y;
int width = size.x;
int height = size.y;
m_windowStyle = style;
// TODO create listbox // TODO create listbox
/*
DWORD wstyle = WS_VISIBLE | WS_VSCROLL | WS_TABSTOP |
LBS_NOTIFY | LBS_HASSTRINGS;
if (m_windowStyle & wxLB_MULTIPLE)
wstyle |= LBS_MULTIPLESEL;
else if (m_windowStyle & wxLB_EXTENDED)
wstyle |= LBS_EXTENDEDSEL;
if (m_windowStyle & wxLB_ALWAYS_SB)
wstyle |= LBS_DISABLENOSCROLL ;
if (m_windowStyle & wxLB_HSCROLL)
wstyle |= WS_HSCROLL;
if (m_windowStyle & wxLB_SORT)
wstyle |= LBS_SORT;
#if wxUSE_OWNER_DRAWN
if ( m_windowStyle & wxLB_OWNERDRAW ) {
// we don't support LBS_OWNERDRAWVARIABLE yet
wstyle |= LBS_OWNERDRAWFIXED;
}
#endif
// Without this style, you get unexpected heights, so e.g. constraint layout
// doesn't work properly
wstyle |= LBS_NOINTEGRALHEIGHT;
bool want3D;
WXDWORD exStyle = Determine3DEffects(WS_EX_CLIENTEDGE, &want3D) ;
// Even with extended styles, need to combine with WS_BORDER
// for them to look right.
if ( want3D || wxStyleHasBorder(m_windowStyle) )
{
wstyle |= WS_BORDER;
}
m_hWnd = (WXHWND)::CreateWindowEx(exStyle, wxT("LISTBOX"), NULL,
wstyle | WS_CHILD,
0, 0, 0, 0,
(HWND)parent->GetHWND(), (HMENU)m_windowId,
wxGetInstance(), NULL);
#if wxUSE_CTL3D
if (want3D)
{
Ctl3dSubclassCtl(GetHwnd());
m_useCtl3D = TRUE;
}
#endif
// Subclass again to catch messages
SubclassWin(m_hWnd);
size_t ui;
for (ui = 0; ui < (size_t)n; ui++) {
Append(choices[ui]);
}
if ( (m_windowStyle & wxLB_MULTIPLE) == 0 )
SendMessage(GetHwnd(), LB_SETCURSEL, 0, 0);
SetFont(parent->GetFont());
SetSize(x, y, width, height);
Show(TRUE);
*/
return FALSE; return FALSE;
} }
wxListBox::~wxListBox() wxListBox::~wxListBox()
{ {
#if wxUSE_OWNER_DRAWN
size_t uiCount = m_aItems.Count();
while ( uiCount-- != 0 ) {
delete m_aItems[uiCount];
}
#endif // wxUSE_OWNER_DRAWN
}
void wxListBox::SetupColours()
{
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
SetForegroundColour(GetParent()->GetForegroundColour());
} }
void wxListBox::SetFirstItem(int N) void wxListBox::SetFirstItem(int N)
{ {
// TODO wxCHECK_RET( N >= 0 && N < m_noItems,
wxT("invalid index in wxListBox::SetFirstItem") );
// TODO SendMessage(GetHwnd(),LB_SETTOPINDEX,(WPARAM)N,(LPARAM)0) ;
} }
void wxListBox::SetFirstItem(const wxString& s) void wxListBox::SetFirstItem(const wxString& s)
{ {
// TODO int N = FindString(s) ;
if ( N >= 0 )
SetFirstItem(N) ;
} }
void wxListBox::Delete(int N) void wxListBox::Delete(int N)
{ {
m_noItems --; wxCHECK_RET( N >= 0 && N < m_noItems,
// TODO wxT("invalid index in wxListBox::Delete") );
// TODO SendMessage(GetHwnd(), LB_DELETESTRING, N, 0);
m_noItems --;
SetHorizontalExtent("");
} }
void wxListBox::Append(const wxString& item) void wxListBox::Append(const wxString& item)
{ {
m_noItems ++; int index=0; // TODO = ListBox_AddString(GetHwnd(), item);
m_noItems ++;
// TODO #if wxUSE_OWNER_DRAWN
if ( m_windowStyle & wxLB_OWNERDRAW ) {
wxOwnerDrawn *pNewItem = CreateItem(index); // dummy argument
pNewItem->SetName(item);
m_aItems.Add(pNewItem);
// ListBox_SetItemData(GetHwnd(), index, pNewItem);
}
#endif
SetHorizontalExtent(item);
} }
void wxListBox::Append(const wxString& item, char *Client_data) void wxListBox::Append(const wxString& item, void *Client_data)
{ {
m_noItems ++; int index; // TODO = ListBox_AddString(GetHwnd(), item);
m_noItems ++;
// TODO #if wxUSE_OWNER_DRAWN
if ( m_windowStyle & wxLB_OWNERDRAW ) {
// client data must be pointer to wxOwnerDrawn, otherwise we would crash
// in OnMeasure/OnDraw.
wxFAIL_MSG(wxT("Can't use client data with owner-drawn listboxes"));
}
else
#endif
// TODO ListBox_SetItemData(GetHwnd(), index, Client_data);
SetHorizontalExtent(item);
} }
void wxListBox::Set(int n, const wxString *choices, char** clientData) void wxListBox::Set(int n, const wxString *choices, char** clientData)
{ {
m_noItems = n; // ShowWindow(GetHwnd(), SW_HIDE);
// ListBox_ResetContent(GetHwnd());
int i;
for (i = 0; i < n; i++)
{
// ListBox_AddString(GetHwnd(), choices[i]);
// if ( clientData )
// ListBox_SetItemData(GetHwnd(), i, clientData[i]);
}
m_noItems = n;
// TODO #if wxUSE_OWNER_DRAWN
if ( m_windowStyle & wxLB_OWNERDRAW ) {
// first delete old items
size_t ui = m_aItems.Count();
while ( ui-- != 0 ) {
delete m_aItems[ui];
}
m_aItems.Empty();
// then create new ones
for (ui = 0; ui < (size_t)n; ui++) {
wxOwnerDrawn *pNewItem = CreateItem(ui);
pNewItem->SetName(choices[ui]);
m_aItems.Add(pNewItem);
// ListBox_SetItemData(GetHwnd(), ui, pNewItem);
wxASSERT_MSG(clientData[ui] == NULL,
wxT("Can't use client data with owner-drawn listboxes"));
}
}
#endif
SetHorizontalExtent("");
// ShowWindow(GetHwnd(), SW_SHOW);
} }
int wxListBox::FindString(const wxString& s) const int wxListBox::FindString(const wxString& s) const
{ {
// TODO int pos; // = ListBox_FindStringExact(GetHwnd(), (WPARAM)-1, s);
return -1; // if (pos == LB_ERR)
// return -1;
// else
return pos;
} }
void wxListBox::Clear() void wxListBox::Clear()
{ {
m_noItems = 0; // ListBox_ResetContent(GetHwnd());
// TODO
#if wxUSE_OWNER_DRAWN
size_t uiCount = m_aItems.Count();
while ( uiCount-- != 0 ) {
delete m_aItems[uiCount];
}
m_aItems.Clear();
#endif // wxUSE_OWNER_DRAWN
m_noItems = 0;
// ListBox_GetHorizontalExtent(GetHwnd());
} }
void wxListBox::SetSelection(int N, bool select) void wxListBox::SetSelection(int N, bool select)
{ {
// TODO wxCHECK_RET( N >= 0 && N < m_noItems,
wxT("invalid index in wxListBox::SetSelection") );
if ((m_windowStyle & wxLB_MULTIPLE) || (m_windowStyle & wxLB_EXTENDED))
{
// SendMessage(GetHwnd(), LB_SETSEL, select, N);
}
else
{
int N1 = N;
if (!select)
N1 = -1;
// SendMessage(GetHwnd(), LB_SETCURSEL, N1, 0);
}
} }
bool wxListBox::Selected(int N) const bool wxListBox::Selected(int N) const
{ {
// TODO wxCHECK_MSG( N >= 0 && N < m_noItems, FALSE,
wxT("invalid index in wxListBox::Selected") );
// return SendMessage(GetHwnd(), LB_GETSEL, N, 0) == 0 ? FALSE : TRUE;
return FALSE; return FALSE;
} }
void wxListBox::Deselect(int N) void wxListBox::Deselect(int N)
{ {
// TODO wxCHECK_RET( N >= 0 && N < m_noItems,
wxT("invalid index in wxListBox::Deselect") );
if ((m_windowStyle & wxLB_MULTIPLE) || (m_windowStyle & wxLB_EXTENDED))
{
// SendMessage(GetHwnd(), LB_SETSEL, FALSE, N);
}
} }
char *wxListBox::GetClientData(int N) const void *wxListBox::GetClientData(int N) const
{ {
// TODO wxCHECK_MSG( N >= 0 && N < m_noItems, NULL,
wxT("invalid index in wxListBox::GetClientData") );
// return (void *)SendMessage(GetHwnd(), LB_GETITEMDATA, N, 0);
return (char *)NULL; return (char *)NULL;
} }
void wxListBox::SetClientData(int N, char *Client_data) void wxListBox::SetClientData(int N, void *Client_data)
{ {
// TODO wxCHECK_RET( N >= 0 && N < m_noItems,
wxT("invalid index in wxListBox::SetClientData") );
// if ( ListBox_SetItemData(GetHwnd(), N, Client_data) == LB_ERR )
// wxLogDebug(wxT("LB_SETITEMDATA failed"));
} }
// Return number of selections and an array of selected integers // Return number of selections and an array of selected integers
@ -144,59 +417,169 @@ int wxListBox::GetSelections(wxArrayInt& aSelections) const
{ {
aSelections.Empty(); aSelections.Empty();
/* TODO
if ((m_windowStyle & wxLB_MULTIPLE) || (m_windowStyle & wxLB_EXTENDED)) if ((m_windowStyle & wxLB_MULTIPLE) || (m_windowStyle & wxLB_EXTENDED))
{ {
int no_sel = ?? int no_sel; // = ListBox_GetSelCount(GetHwnd());
for ( int n = 0; n < no_sel; n++ ) if (no_sel != 0) {
aSelections.Add(??); int *selections = new int[no_sel];
// if ( ListBox_GetSelItems(GetHwnd(), no_sel, selections) == LB_ERR ) {
// wxFAIL_MSG(wxT("This listbox can't have single-selection style!"));
// }
aSelections.Alloc(no_sel);
for ( int n = 0; n < no_sel; n++ )
aSelections.Add(selections[n]);
delete [] selections;
}
return no_sel; return no_sel;
} }
else // single-selection listbox else // single-selection listbox
{ {
aSelections.Add(??); // aSelections.Add(ListBox_GetCurSel(GetHwnd()));
return 1; return 1;
} }
*/
return 0;
} }
// Get single selection, for single choice list items // Get single selection, for single choice list items
int wxListBox::GetSelection() const int wxListBox::GetSelection() const
{ {
// TODO wxCHECK_MSG( !(m_windowStyle & wxLB_MULTIPLE) &&
!(m_windowStyle & wxLB_EXTENDED),
-1,
wxT("GetSelection() can't be used with multiple-selection "
"listboxes, use GetSelections() instead.") );
// return ListBox_GetCurSel(GetHwnd());
return -1; return -1;
} }
// Find string for position // Find string for position
wxString wxListBox::GetString(int N) const wxString wxListBox::GetString(int N) const
{ {
// TODO wxCHECK_MSG( N >= 0 && N < m_noItems, "",
return wxString(""); wxT("invalid index in wxListBox::GetClientData") );
// int len = ListBox_GetTextLen(GetHwnd(), N);
// +1 for terminating NUL
wxString result;
// ListBox_GetText(GetHwnd(), N, result.GetWriteBuf(len + 1));
result.UngetWriteBuf();
return result;
} }
void wxListBox::SetSize(int x, int y, int width, int height, int sizeFlags) // OS/2-PM-specific code to set the horizontal extent of the listbox, if
// necessary. If s is non-NULL, it's used to calculate the horizontal extent.
// Otherwise, all strings are used.
void wxListBox::SetHorizontalExtent(const wxString& s)
{ {
// TODO /*
} // Only necessary if we want a horizontal scrollbar
if (!(m_windowStyle & wxHSCROLL))
return;
TEXTMETRIC lpTextMetric;
if (s != wxT(""))
{
int existingExtent = (int)SendMessage(GetHwnd(), LB_GETHORIZONTALEXTENT, 0, 0L);
HDC dc = GetWindowDC(GetHwnd());
HFONT oldFont = 0;
if (GetFont().Ok() && GetFont().GetResourceHandle())
oldFont = (HFONT) ::SelectObject(dc, (HFONT) GetFont().GetResourceHandle());
GetTextMetrics(dc, &lpTextMetric);
SIZE extentXY;
::GetTextExtentPoint(dc, (LPTSTR) (const wxChar *)s, s.Length(), &extentXY);
int extentX = (int)(extentXY.cx + lpTextMetric.tmAveCharWidth);
if (oldFont)
::SelectObject(dc, oldFont);
ReleaseDC(GetHwnd(), dc);
if (extentX > existingExtent)
SendMessage(GetHwnd(), LB_SETHORIZONTALEXTENT, LOWORD(extentX), 0L);
return;
}
else
{
int largestExtent = 0;
HDC dc = GetWindowDC(GetHwnd());
HFONT oldFont = 0;
if (GetFont().Ok() && GetFont().GetResourceHandle())
oldFont = (HFONT) ::SelectObject(dc, (HFONT) GetFont().GetResourceHandle());
GetTextMetrics(dc, &lpTextMetric);
int i;
for (i = 0; i < m_noItems; i++)
{
int len = (int)SendMessage(GetHwnd(), LB_GETTEXT, i, (LONG)wxBuffer);
wxBuffer[len] = 0;
SIZE extentXY;
::GetTextExtentPoint(dc, (LPTSTR)wxBuffer, len, &extentXY);
int extentX = (int)(extentXY.cx + lpTextMetric.tmAveCharWidth);
if (extentX > largestExtent)
largestExtent = extentX;
}
if (oldFont)
::SelectObject(dc, oldFont);
ReleaseDC(GetHwnd(), dc);
SendMessage(GetHwnd(), LB_SETHORIZONTALEXTENT, LOWORD(largestExtent), 0L);
}
*/
}
void wxListBox::InsertItems(int nItems, const wxString items[], int pos) void wxListBox::InsertItems(int nItems, const wxString items[], int pos)
{ {
wxCHECK_RET( pos >= 0 && pos <= m_noItems,
wxT("invalid index in wxListBox::InsertItems") );
int i;
// for (i = 0; i < nItems; i++)
// ListBox_InsertString(GetHwnd(), i + pos, items[i]);
m_noItems += nItems; m_noItems += nItems;
// TODO SetHorizontalExtent(wxT(""));
} }
void wxListBox::SetString(int N, const wxString& s) void wxListBox::SetString(int N, const wxString& s)
{ {
// TODO wxCHECK_RET( N >= 0 && N < m_noItems,
wxT("invalid index in wxListBox::SetString") );
int sel = -1;
if (!(m_windowStyle & wxLB_MULTIPLE) && !(m_windowStyle & wxLB_EXTENDED))
sel = GetSelection();
void *oldData = wxListBox::GetClientData(N);
// SendMessage(GetHwnd(), LB_DELETESTRING, N, 0);
int newN = N;
if (N == (m_noItems - 1))
newN = -1;
// SendMessage(GetHwnd(), LB_INSERTSTRING, newN, (LPARAM) (const wxChar *)s);
if (oldData)
wxListBox::SetClientData(N, oldData);
// Selection may have changed
if (sel >= 0)
SetSelection(sel);
#if wxUSE_OWNER_DRAWN
if ( m_windowStyle & wxLB_OWNERDRAW )
// update item's text
m_aItems[N]->SetName(s);
#endif //USE_OWNER_DRAWN
} }
int wxListBox::Number () const int wxListBox::Number () const
{ {
return m_noItems; return m_noItems;
} }
// For single selection items only // For single selection items only
@ -221,6 +604,35 @@ bool wxListBox::SetStringSelection (const wxString& s, bool flag)
return FALSE; return FALSE;
} }
wxSize wxListBox::DoGetBestSize()
{
// find the widest string
int wLine;
int wListbox = 0;
for ( int i = 0; i < m_noItems; i++ )
{
wxString str(GetString(i));
GetTextExtent(str, &wLine, NULL);
if ( wLine > wListbox )
wListbox = wLine;
}
// give it some reasonable default value if there are no strings in the
// list
if ( wListbox == 0 )
wListbox = 100;
// the listbox should be slightly larger than the widest string
int cx, cy;
wxGetCharSize(GetHWND(), &cx, &cy, &GetFont());
wListbox += 3*cx;
int hListbox = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy)*(wxMax(m_noItems, 7));
return wxSize(wListbox, hListbox);
}
void wxListBox::Command (wxCommandEvent & event) void wxListBox::Command (wxCommandEvent & event)
{ {
if (event.m_extraLong) if (event.m_extraLong)
@ -233,3 +645,97 @@ void wxListBox::Command (wxCommandEvent & event)
ProcessCommand (event); ProcessCommand (event);
} }
WXHBRUSH wxListBox::OnCtlColor(WXHDC pDC, WXHWND pWnd, WXUINT nCtlColor,
WXUINT message, WXWPARAM wParam, WXLPARAM lParam)
{
/*
#if wxUSE_CTL3D
if ( m_useCtl3D )
{
HBRUSH hbrush = Ctl3dCtlColorEx(message, wParam, lParam);
return (WXHBRUSH) hbrush;
}
#endif
if (GetParent()->GetTransparentBackground())
SetBkMode((HDC) pDC, TRANSPARENT);
else
SetBkMode((HDC) pDC, OPAQUE);
::SetBkColor((HDC) pDC, RGB(GetBackgroundColour().Red(), GetBackgroundColour().Green(), GetBackgroundColour().Blue()));
::SetTextColor((HDC) pDC, RGB(GetForegroundColour().Red(), GetForegroundColour().Green(), GetForegroundColour().Blue()));
wxBrush *backgroundBrush = wxTheBrushList->FindOrCreateBrush(GetBackgroundColour(), wxSOLID);
// Note that this will be cleaned up in wxApp::OnIdle, if backgroundBrush
// has a zero usage count.
backgroundBrush->RealizeResource();
*/
wxBrush *backgroundBrush = wxTheBrushList->FindOrCreateBrush(GetBackgroundColour(), wxSOLID);
return (WXHBRUSH) backgroundBrush->GetResourceHandle();
}
MRESULT wxListBox::OS2WindowProc(HWND hwnd, WXUINT nMsg, WXWPARAM wParam, WXLPARAM lParam)
{
return wxControl::OS2WindowProc(hwnd, nMsg, wParam, lParam);
}
#if wxUSE_OWNER_DRAWN
// drawing
// -------
// space beneath/above each row in pixels
// "standard" checklistbox use 1 here, some might prefer 2. 0 is ugly.
#define OWNER_DRAWN_LISTBOX_EXTRA_SPACE (1)
// the height is the same for all items
// TODO should be changed for LBS_OWNERDRAWVARIABLE style listboxes
// NB: can't forward this to wxListBoxItem because LB_SETITEMDATA
// message is not yet sent when we get here!
bool wxListBox::OS2OnMeasure(WXMEASUREITEMSTRUCT *item)
{
// only owner-drawn control should receive this message
wxCHECK( ((m_windowStyle & wxLB_OWNERDRAW) == wxLB_OWNERDRAW), FALSE );
// MEASUREITEMSTRUCT *pStruct = (MEASUREITEMSTRUCT *)item;
wxDC dc;
// TODO: dc.SetHDC((WXHDC)CreateIC(wxT("DISPLAY"), NULL, NULL, 0));
dc.SetFont(wxSystemSettings::GetSystemFont(wxSYS_ANSI_VAR_FONT));
// pStruct->itemHeight = dc.GetCharHeight() + 2*OWNER_DRAWN_LISTBOX_EXTRA_SPACE;
// pStruct->itemWidth = dc.GetCharWidth();
return TRUE;
}
// forward the message to the appropriate item
bool wxListBox::OS2OnDraw(WXDRAWITEMSTRUCT *item)
{
// only owner-drawn control should receive this message
wxCHECK( ((m_windowStyle & wxLB_OWNERDRAW) == wxLB_OWNERDRAW), FALSE );
/*
DRAWITEMSTRUCT *pStruct = (DRAWITEMSTRUCT *)item;
long data = ListBox_GetItemData(GetHwnd(), pStruct->itemID);
wxCHECK( data && (data != LB_ERR), FALSE );
wxListBoxItem *pItem = (wxListBoxItem *)data;
wxDC dc;
dc.SetHDC((WXHDC)pStruct->hDC, FALSE);
wxRect rect(wxPoint(pStruct->rcItem.left, pStruct->rcItem.top),
wxPoint(pStruct->rcItem.right, pStruct->rcItem.bottom));
return pItem->OnDrawItem(dc, rect,
(wxOwnerDrawn::wxODAction)pStruct->itemAction,
(wxOwnerDrawn::wxODStatus)pStruct->itemState);
*/
return FALSE;
}
#endif
// wxUSE_OWNER_DRAWN

27
src/os2/makefile.va
View File

@ -67,6 +67,12 @@ $(CPPFLAGS) /Fo$@ /Tp $<
$(CPPFLAGS) /Fo$@ /Tp $< $(CPPFLAGS) /Fo$@ /Tp $<
<< <<
{..\os2}.c{..\os2\$D}.obj:
@echo $<
icc @<<
$(CPPFLAGS) /Fo$@ /Tp $<
<<
{..\html}.cpp{..\html\$D}.obj: {..\html}.cpp{..\html\$D}.obj:
@echo $< @echo $<
icc @<< icc @<<
@ -313,6 +319,13 @@ OS2OBJS = \
..\os2\$D\frame.obj \ ..\os2\$D\frame.obj \
..\os2\$D\gauge.obj \ ..\os2\$D\gauge.obj \
..\os2\$D\gdiobj.obj \ ..\os2\$D\gdiobj.obj \
..\os2\$D\gsocket.obj \
..\os2\$D\helpwin.obj \
..\os2\$D\icon.obj \
..\os2\$D\imaglist.obj \
..\os2\$D\iniconf.obj \
..\os2\$D\joystick.obj \
..\os2\$D\listbox.obj \
..\os2\$D\window.obj ..\os2\$D\window.obj
@ -347,6 +360,13 @@ OS2LIBOBJS = \
frame.obj \ frame.obj \
gauge.obj \ gauge.obj \
gdiobj.obj \ gdiobj.obj \
gsocket.obj \
helpwin.obj \
icon.obj \
imaglist.obj \
iniconf.obj \
joystick.obj \
listbox.obj \
window.obj window.obj
HTMLOBJS = \ HTMLOBJS = \
@ -524,6 +544,13 @@ $(OS2LIBOBJS):
copy ..\os2\$D\frame.obj copy ..\os2\$D\frame.obj
copy ..\os2\$D\gauge.obj copy ..\os2\$D\gauge.obj
copy ..\os2\$D\gdiobj.obj copy ..\os2\$D\gdiobj.obj
copy ..\os2\$D\gsocket.obj
copy ..\os2\$D\helpwin.obj
copy ..\os2\$D\icon.obj
copy ..\os2\$D\imaglist.obj
copy ..\os2\$D\iniconf.obj
copy ..\os2\$D\joystick.obj
copy ..\os2\$D\listbox.obj
copy ..\os2\$D\window.obj copy ..\os2\$D\window.obj
# wxWindows library as DLL # wxWindows library as DLL