Amebis/wxWidgets
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects 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
Download Patch File Download Diff File Expand all files Collapse all files

50
src/os2/brush.cpp
View File

@@ -81,20 +81,6 @@ wxBrush::wxBrush(const wxBitmap& stipple)
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)
{
@@ -138,3 +124,39 @@ bool wxBrush::RealizeResource()
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
// Purpose: wxIcon class
// Author: AUTHOR
// Author: David Webster
// Modified by:
// Created: ??/??/98
// Created: 10/09/99
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
// Copyright: (c) David Webster
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "icon.h"
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#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"
#if !USE_SHARED_LIBRARIES
IMPLEMENT_DYNAMIC_CLASS(wxIcon, wxBitmap)
IMPLEMENT_DYNAMIC_CLASS(wxICOFileHandler, wxBitmapHandler)
IMPLEMENT_DYNAMIC_CLASS(wxICOResourceHandler, wxBitmapHandler)
#endif
/*
* Icons
*/
wxIconRefData::wxIconRefData()
{
// TODO: init icon handle
m_hIcon = (WXHICON) NULL ;
}
wxIconRefData::~wxIconRefData()
{
// TODO: destroy icon handle
if ( m_hIcon )
return;
// TODO ::DestroyIcon((HICON) m_hIcon);
}
wxIcon::wxIcon()
@@ -63,8 +81,70 @@ bool wxIcon::LoadFile(const wxString& filename, long type,
wxBitmapHandler *handler = FindHandler(type);
if ( handler )
return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight);
return handler->LoadFile(this, filename, type, desiredWidth, desiredHeight);
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
// Purpose: wxImageList. You may wish to use the generic version.
// Author: AUTHOR
// Author: David Webster
// Modified by:
// Created: ??/??/98
// Created: 10/09/99
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
// Copyright: (c) David Webster
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "imaglist.h"
// For compilers that support precompilation, includes "wx.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
#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
IMPLEMENT_DYNAMIC_CLASS(wxImageList, wxObject)
@@ -21,23 +33,25 @@ IMPLEMENT_DYNAMIC_CLASS(wxImageList, wxObject)
wxImageList::wxImageList()
{
// TODO: init image list handle, if any
m_hImageList = 0;
}
wxImageList::~wxImageList()
{
// TODO: destroy image list handle, if any
if ( m_hImageList )
return;
// TODO: ImageList_Destroy((HIMAGELIST) m_hImageList);
m_hImageList = 0;
}
// Attributes
////////////////////////////////////////////////////////////////////////////
// Returns the number of images in the image list.
int wxImageList::GetImageCount() const
{
// TODO
return 0;
// TODO:: return ImageList_GetImageCount((HIMAGELIST) m_hImageList);
return 0;
}
// Operations
@@ -46,8 +60,13 @@ int wxImageList::GetImageCount() const
// Creates an image list
bool wxImageList::Create(int width, int height, bool mask, int initial)
{
// TODO
return FALSE;
UINT flags = 0;
// 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.
@@ -55,8 +74,17 @@ bool wxImageList::Create(int width, int height, bool mask, int initial)
// 'bitmap' and 'mask'.
int wxImageList::Add(const wxBitmap& bitmap, const wxBitmap& mask)
{
// TODO
return 0;
HBITMAP hBitmap1 = (HBITMAP) bitmap.GetHBITMAP();
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
@@ -64,15 +92,19 @@ int wxImageList::Add(const wxBitmap& bitmap, const wxBitmap& mask)
// 'bitmap'.
int wxImageList::Add(const wxBitmap& bitmap, const wxColour& maskColour)
{
// TODO
return 0;
HBITMAP hBitmap1 = (HBITMAP) bitmap.GetHBITMAP();
//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.
int wxImageList::Add(const wxIcon& icon)
{
// TODO
return 0;
HICON hIcon = (HICON) icon.GetHICON();
// TODO: return ImageList_AddIcon((HIMAGELIST) GetHIMAGELIST(), hIcon);
return 0;
}
// Replaces a bitmap, optionally passing a mask bitmap.
@@ -80,29 +112,38 @@ int wxImageList::Add(const wxIcon& icon)
// 'bitmap' and 'mask'.
bool wxImageList::Replace(int index, const wxBitmap& bitmap, const wxBitmap& mask)
{
// TODO
return 0;
HBITMAP hBitmap1 = (HBITMAP) bitmap.GetHBITMAP();
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.
bool wxImageList::Replace(int index, const wxIcon& icon)
{
// TODO
return 0;
HICON hIcon = (HICON) icon.GetHICON();
// TODO: return (ImageList_ReplaceIcon((HIMAGELIST) GetHIMAGELIST(), index, hIcon) != 0);
return FALSE;
}
// Removes the image at the given index.
bool wxImageList::Remove(int index)
{
// TODO
// TODO return (ImageList_Remove((HIMAGELIST) GetHIMAGELIST(), index) != 0);
return FALSE;
}
// Remove all images
bool wxImageList::RemoveAll()
bool wxImageList::RemoveAll(void)
{
// TODO
return FALSE;
// TODO: Is this correct?
while ( GetImageCount() > 0 )
{
Remove(0);
}
return TRUE;
}
// 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,
int flags, bool solidBackground)
{
// TODO
HDC hDC = (HDC) dc.GetHDC();
if ( !hDC )
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
// Purpose: wxJoystick class
// Author: AUTHOR
// Author: David Webster
// Modified by:
// Created: ??/??/98
// Created: 10/09/99
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Licence: wxWindows licence
// Copyright: (c) David Webster
// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "joystick.h"
#endif
#include "wx/string.h"
#define INCL_PM
#include "os2.h"
#include "wx/os2/private.h"
#define NO_JOYGETPOSEX
#include <wx/window.h>
#include <wx/joystick.h>
IMPLEMENT_DYNAMIC_CLASS(wxJoystick, wxObject)

594
src/os2/listbox.cpp
View File

@@ -1,31 +1,110 @@
///////////////////////////////////////////////////////////////////////////////
// Name: listbox.cpp
// Purpose: wxListBox
// Author: AUTHOR
// Author: David Webster
// Modified by:
// Created: ??/??/98
// Created: 10/09/99
// RCS-ID: $Id$
// Copyright: (c) AUTHOR
// Copyright: (c) David Webster
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
#ifdef __GNUG__
#pragma implementation "listbox.h"
#endif
// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"
#include "wx/window.h"
#include "wx/os2/private.h"
#ifndef WX_PRECOMP
#include "wx/listbox.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/log.h"
#if wxUSE_OWNER_DRAWN
#include "wx/ownerdrw.h"
#endif
#if !USE_SHARED_LIBRARY
IMPLEMENT_DYNAMIC_CLASS(wxListBox, wxControl)
#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
// ============================================================================
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
wxListBox::wxListBox()
{
@@ -42,6 +121,7 @@ bool wxListBox::Create(wxWindow *parent, wxWindowID id,
const wxString& name)
{
m_noItems = n;
m_hWnd = 0;
m_selected = 0;
SetName(name);
@@ -51,92 +131,285 @@ bool wxListBox::Create(wxWindow *parent, wxWindowID id,
wxSystemSettings settings;
SetBackgroundColour(wxSystemSettings::GetSystemColour(wxSYS_COLOUR_WINDOW));
SetForegroundColour(parent->GetForegroundColour());
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
/*
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;
}
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)
{
// 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)
{
// TODO
int N = FindString(s) ;
if ( N >= 0 )
SetFirstItem(N) ;
}
void wxListBox::Delete(int N)
{
m_noItems --;
// TODO
wxCHECK_RET( N >= 0 && N < m_noItems,
wxT("invalid index in wxListBox::Delete") );
// TODO SendMessage(GetHwnd(), LB_DELETESTRING, N, 0);
m_noItems --;
SetHorizontalExtent("");
}
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)
{
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
{
// TODO
return -1;
int pos; // = ListBox_FindStringExact(GetHwnd(), (WPARAM)-1, s);
// if (pos == LB_ERR)
// return -1;
// else
return pos;
}
void wxListBox::Clear()
{
m_noItems = 0;
// TODO
// ListBox_ResetContent(GetHwnd());
#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)
{
// 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
{
// 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;
}
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;
}
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
@@ -144,59 +417,169 @@ int wxListBox::GetSelections(wxArrayInt& aSelections) const
{
aSelections.Empty();
/* TODO
if ((m_windowStyle & wxLB_MULTIPLE) || (m_windowStyle & wxLB_EXTENDED))
{
int no_sel = ??
for ( int n = 0; n < no_sel; n++ )
aSelections.Add(??);
int no_sel; // = ListBox_GetSelCount(GetHwnd());
if (no_sel != 0) {
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;
}
else // single-selection listbox
{
aSelections.Add(??);
// aSelections.Add(ListBox_GetCurSel(GetHwnd()));
return 1;
}
*/
return 0;
}
// Get single selection, for single choice list items
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;
}
// Find string for position
wxString wxListBox::GetString(int N) const
{
// TODO
return wxString("");
wxCHECK_MSG( N >= 0 && N < m_noItems, "",
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)
{
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;
// TODO
SetHorizontalExtent(wxT(""));
}
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
{
return m_noItems;
return m_noItems;
}
// For single selection items only
@@ -221,6 +604,35 @@ bool wxListBox::SetStringSelection (const wxString& s, bool flag)
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)
{
if (event.m_extraLong)
@@ -233,3 +645,97 @@ void wxListBox::Command (wxCommandEvent & 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 $<
<<
{..\os2}.c{..\os2\$D}.obj:
@echo $<
icc @<<
$(CPPFLAGS) /Fo$@ /Tp $<
<<
{..\html}.cpp{..\html\$D}.obj:
@echo $<
icc @<<
@@ -313,6 +319,13 @@ OS2OBJS = \
..\os2\$D\frame.obj \
..\os2\$D\gauge.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
@@ -347,6 +360,13 @@ OS2LIBOBJS = \
frame.obj \
gauge.obj \
gdiobj.obj \
gsocket.obj \
helpwin.obj \
icon.obj \
imaglist.obj \
iniconf.obj \
joystick.obj \
listbox.obj \
window.obj
HTMLOBJS = \
@@ -524,6 +544,13 @@ $(OS2LIBOBJS):
copy ..\os2\$D\frame.obj
copy ..\os2\$D\gauge.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
# wxWindows library as DLL