[wxWidgets.git] / src / msw / wince / choicece.cpp

///////////////////////////////////////////////////////////////////////////////
// Name:        src/msw/wince/choicece.cpp
// Purpose:     wxChoice implementation for smart phones driven by WinCE
// Author:      Wlodzimierz ABX Skiba
// Modified by:
// Created:     29.07.2004
// RCS-ID:      $Id$
// Copyright:   (c) Wlodzimierz Skiba
// Licence:     wxWindows licence
///////////////////////////////////////////////////////////////////////////////

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#if wxUSE_CHOICE && defined(__SMARTPHONE__) && defined(__WXWINCE__)

#include "wx/choice.h"

#ifndef WX_PRECOMP
    #include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
#endif

#include "wx/spinbutt.h" // for wxSpinnerBestSize

#define GetBuddyHwnd()      (HWND)(m_hwndBuddy)

#define IsVertical(wxStyle) ( (wxStyle & wxSP_HORIZONTAL) != wxSP_HORIZONTAL )

// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

// the margin between the up-down control and its buddy (can be arbitrary,
// choose what you like - or may be decide during run-time depending on the
// font size?)
static const int MARGIN_BETWEEN = 0;

// ============================================================================
// implementation
// ============================================================================

wxArrayChoiceSpins wxChoice::ms_allChoiceSpins;

// ----------------------------------------------------------------------------
// wnd proc for the buddy text ctrl
// ----------------------------------------------------------------------------

LRESULT APIENTRY _EXPORT wxBuddyChoiceWndProc(HWND hwnd,
                                            UINT message,
                                            WPARAM wParam,
                                            LPARAM lParam)
{
    wxChoice *spin = (wxChoice *)wxGetWindowUserData(hwnd);

    // forward some messages (the key and focus ones only so far) to
    // the spin ctrl
    switch ( message )
    {
        case WM_SETFOCUS:
            // if the focus comes from the spin control itself, don't set it
            // back to it -- we don't want to go into an infinite loop
            if ( (WXHWND)wParam == spin->GetHWND() )
                break;
            //else: fall through

        case WM_KILLFOCUS:
        case WM_CHAR:
        case WM_DEADCHAR:
        case WM_KEYUP:
        case WM_KEYDOWN:
            spin->MSWWindowProc(message, wParam, lParam);

            // The control may have been deleted at this point, so check.
            if ( !::IsWindow(hwnd) || wxGetWindowUserData(hwnd) != spin )
                return 0;
            break;

        case WM_GETDLGCODE:
            // we want to get WXK_RETURN in order to generate the event for it
            return DLGC_WANTCHARS;
    }

    return ::CallWindowProc(CASTWNDPROC spin->GetBuddyWndProc(),
                            hwnd, message, wParam, lParam);
}

wxChoice *wxChoice::GetChoiceForListBox(WXHWND hwndBuddy)
{
    wxChoice *choice = (wxChoice *)wxGetWindowUserData((HWND)hwndBuddy);

    int i = ms_allChoiceSpins.Index(choice);

    if ( i == wxNOT_FOUND )
        return NULL;

    // sanity check
    wxASSERT_MSG( choice->m_hwndBuddy == hwndBuddy,
                  wxT("wxChoice has incorrect buddy HWND!") );

    return choice;
}

// ----------------------------------------------------------------------------
// creation
// ----------------------------------------------------------------------------

bool wxChoice::Create(wxWindow *parent,
                      wxWindowID id,
                      const wxPoint& pos,
                      const wxSize& size,
                      int n, const wxString choices[],
                      long style,
                      const wxValidator& validator,
                      const wxString& name)
{
    return CreateAndInit(parent, id, pos, size, n, choices, style,
                         validator, name);
}

bool wxChoice::CreateAndInit(wxWindow *parent,
                             wxWindowID id,
                             const wxPoint& pos,
                             const wxSize& size,
                             int n, const wxString choices[],
                             long style,
                             const wxValidator& validator,
                             const wxString& name)
{
    if ( !(style & wxSP_VERTICAL) )
        style |= wxSP_HORIZONTAL;

    if ( (style & wxBORDER_MASK) == wxBORDER_DEFAULT )
        style |= wxBORDER_SIMPLE;

    style |= wxSP_ARROW_KEYS;

    SetWindowStyle(style);

    WXDWORD exStyle = 0;
    WXDWORD msStyle = MSWGetStyle(GetWindowStyle(), & exStyle) ;

    wxSize sizeText(size), sizeBtn(size);
    sizeBtn.x = GetBestSpinnerSize(IsVertical(style)).x;

    if ( sizeText.x == wxDefaultCoord )
    {
        // DEFAULT_ITEM_WIDTH is the default width for the text control
        sizeText.x = DEFAULT_ITEM_WIDTH + MARGIN_BETWEEN + sizeBtn.x;
    }

    sizeText.x -= sizeBtn.x + MARGIN_BETWEEN;
    if ( sizeText.x <= 0 )
    {
        wxLogDebug(wxT("not enough space for wxSpinCtrl!"));
    }

    wxPoint posBtn(pos);
    posBtn.x += sizeText.x + MARGIN_BETWEEN;

    // we must create the list control before the spin button for the purpose
    // of the dialog navigation: if there is a static text just before the spin
    // control, activating it by Alt-letter should give focus to the text
    // control, not the spin and the dialog navigation code will give focus to
    // the next control (at Windows level), not the one after it

    // create the text window

    m_hwndBuddy = (WXHWND)::CreateWindowEx
                    (
                     exStyle,                // sunken border
                     wxT("LISTBOX"),         // window class
                     NULL,                   // no window title
                     msStyle,                // style (will be shown later)
                     pos.x, pos.y,           // position
                     0, 0,                   // size (will be set later)
                     GetHwndOf(parent),      // parent
                     (HMENU)-1,              // control id
                     wxGetInstance(),        // app instance
                     NULL                    // unused client data
                    );

    if ( !m_hwndBuddy )
    {
        wxLogLastError(wxT("CreateWindow(buddy text window)"));

        return false;
    }

    // initialize wxControl
    if ( !CreateControl(parent, id, posBtn, sizeBtn, style, validator, name) )
        return false;

    // now create the real HWND
    WXDWORD spiner_style = WS_VISIBLE |
                           UDS_ALIGNRIGHT |
                           UDS_ARROWKEYS |
                           UDS_SETBUDDYINT |
                           UDS_EXPANDABLE;

    if ( !IsVertical(style) )
        spiner_style |= UDS_HORZ;

    if ( style & wxSP_WRAP )
        spiner_style |= UDS_WRAP;

    if ( !MSWCreateControl(UPDOWN_CLASS, spiner_style, posBtn, sizeBtn, wxEmptyString, 0) )
        return false;

    // subclass the text ctrl to be able to intercept some events
    wxSetWindowUserData(GetBuddyHwnd(), this);
    m_wndProcBuddy = (WXFARPROC)wxSetWindowProc(GetBuddyHwnd(),
                                                wxBuddyChoiceWndProc);

    // set up fonts and colours  (This is nomally done in MSWCreateControl)
    InheritAttributes();
    if (!m_hasFont)
        SetFont(GetDefaultAttributes().font);

    // set the size of the text window - can do it only now, because we
    // couldn't call DoGetBestSize() before as font wasn't set
    if ( sizeText.y <= 0 )
    {
        int cx, cy;
        wxGetCharSize(GetHWND(), &cx, &cy, GetFont());

        sizeText.y = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
    }

    SetInitialSize(size);

    (void)::ShowWindow(GetBuddyHwnd(), SW_SHOW);

    // associate the list window with the spin button
    (void)::SendMessage(GetHwnd(), UDM_SETBUDDY, (WPARAM)GetBuddyHwnd(), 0);

    // do it after finishing with m_hwndBuddy creation to avoid generating
    // initial wxEVT_COMMAND_TEXT_UPDATED message
    ms_allChoiceSpins.Add(this);

    // initialize the controls contents
    for ( int i = 0; i < n; i++ )
    {
        Append(choices[i]);
    }

    return true;
}

bool wxChoice::Create(wxWindow *parent,
                      wxWindowID id,
                      const wxPoint& pos,
                      const wxSize& size,
                      const wxArrayString& choices,
                      long style,
                      const wxValidator& validator,
                      const wxString& name)
{
    wxCArrayString chs(choices);
    return Create(parent, id, pos, size, chs.GetCount(), chs.GetStrings(),
                  style, validator, name);
}

WXDWORD wxChoice::MSWGetStyle(long style, WXDWORD *exstyle) const
{
    // we never have an external border
    WXDWORD msStyle = wxControl::MSWGetStyle
                      (
                        (style & ~wxBORDER_MASK) | wxBORDER_NONE, exstyle
                      );

    msStyle |= WS_VISIBLE;

    // wxChoice-specific styles
    msStyle |= LBS_NOINTEGRALHEIGHT;
    if ( style & wxCB_SORT )
        msStyle |= LBS_SORT;

    msStyle |= LBS_NOTIFY;

    return msStyle;
}

bool wxChoice::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
{
    if ( param != LBN_SELCHANGE)
    {
        // "selection changed" is the only event we're after
        return false;
    }

    int n = GetSelection();
    if (n > -1)
    {
        wxCommandEvent event(wxEVT_COMMAND_CHOICE_SELECTED, m_windowId);
        event.SetInt(n);
        event.SetEventObject(this);
        event.SetString(GetStringSelection());
        if ( HasClientObjectData() )
            event.SetClientObject( GetClientObject(n) );
        else if ( HasClientUntypedData() )
            event.SetClientData( GetClientData(n) );
        ProcessCommand(event);
    }

    return true;
}

wxChoice::~wxChoice()
{
    Clear();
}

// ----------------------------------------------------------------------------
// adding/deleting items to/from the list
// ----------------------------------------------------------------------------

int wxChoice::DoInsertItems(const wxArrayStringsAdapter& items,
                            unsigned int pos,
                            void **clientData,
                            wxClientDataType type)
{
    MSWAllocStorage(items, LB_INITSTORAGE);

    const bool append = pos == GetCount();
    const unsigned msg = append ? LB_ADDSTRING : LB_INSERTSTRING;
    if ( append )
        pos = 0;

    int n = wxNOT_FOUND;

    const unsigned int numItems = items.GetCount();
    for ( unsigned int i = 0; i < numItems; ++i )
    {
        n = MSWInsertOrAppendItem(pos, items[i], msg);
        if ( !append )
            pos++;

        AssignNewItemClientData(n, clientData, i, type);
    }

    return n;
}

void wxChoice::DoDeleteOneItem(unsigned int n)
{
    wxCHECK_RET( IsValid(n), wxT("invalid item index in wxChoice::Delete") );

    ::SendMessage(GetBuddyHwnd(), LB_DELETESTRING, n, 0);
}

void wxChoice::DoClear()
{
    ::SendMessage(GetBuddyHwnd(), LB_RESETCONTENT, 0, 0);
}

// ----------------------------------------------------------------------------
// selection
// ----------------------------------------------------------------------------

int wxChoice::GetSelection() const
{
    return (int)::SendMessage(GetBuddyHwnd(), LB_GETCURSEL, 0, 0);
}

void wxChoice::SetSelection(int n)
{
    ::SendMessage(GetBuddyHwnd(), LB_SETCURSEL, n, 0);
}

// ----------------------------------------------------------------------------
// string list functions
// ----------------------------------------------------------------------------

unsigned int wxChoice::GetCount() const
{
    return (unsigned int)::SendMessage(GetBuddyHwnd(), LB_GETCOUNT, 0, 0);
}

int wxChoice::FindString(const wxString& s, bool bCase) const
{
    // back to base class search for not native search type
    if (bCase)
       return wxItemContainerImmutable::FindString( s, bCase );

    int pos = (int)::SendMessage(GetBuddyHwnd(), LB_FINDSTRINGEXACT,
                               (WPARAM)-1, (LPARAM)s.c_str());

    return pos == LB_ERR ? wxNOT_FOUND : pos;
}

void wxChoice::SetString(unsigned int n, const wxString& s)
{
    wxCHECK_RET( IsValid(n),
                 wxT("invalid item index in wxChoice::SetString") );

    // we have to delete and add back the string as there is no way to change a
    // string in place

    // we need to preserve the client data
    void *data;
    if ( m_clientDataItemsType != wxClientData_None )
    {
        data = DoGetItemClientData(n);
    }
    else // no client data
    {
        data = NULL;
    }

    ::SendMessage(GetBuddyHwnd(), LB_DELETESTRING, n, 0);
    ::SendMessage(GetBuddyHwnd(), LB_INSERTSTRING, n, (LPARAM)s.c_str() );

    if ( data )
    {
        DoSetItemClientData(n, data);
    }
    //else: it's already NULL by default
}

wxString wxChoice::GetString(unsigned int n) const
{
    int len = (int)::SendMessage(GetBuddyHwnd(), LB_GETTEXTLEN, n, 0);

    wxString str;
    if ( len != LB_ERR && len > 0 )
    {
        if ( ::SendMessage
               (
                GetBuddyHwnd(),
                LB_GETTEXT,
                n,
                (LPARAM)(wxChar *)wxStringBuffer(str, len)
                ) == LB_ERR )
        {
            wxLogLastError(wxT("SendMessage(LB_GETLBTEXT)"));
        }
    }

    return str;
}

// ----------------------------------------------------------------------------
// client data
// ----------------------------------------------------------------------------

void wxChoice::DoSetItemClientData(unsigned int n, void* clientData)
{
    if ( ::SendMessage(GetHwnd(), LB_SETITEMDATA,
                       n, (LPARAM)clientData) == LB_ERR )
    {
        wxLogLastError(wxT("LB_SETITEMDATA"));
    }
}

void* wxChoice::DoGetItemClientData(unsigned int n) const
{
    LPARAM rc = ::SendMessage(GetHwnd(), LB_GETITEMDATA, n, 0);
    if ( rc == LB_ERR )
    {
        wxLogLastError(wxT("LB_GETITEMDATA"));

        // unfortunately, there is no way to return an error code to the user
        rc = (LPARAM) NULL;
    }

    return (void *)rc;
}

// ----------------------------------------------------------------------------
// size calculations
// ----------------------------------------------------------------------------

wxSize wxChoice::DoGetBestSize() const
{
    wxSize sizeBtn = GetBestSpinnerSize(IsVertical(GetWindowStyle()));
    sizeBtn.x += DEFAULT_ITEM_WIDTH + MARGIN_BETWEEN;

    int y;
    wxGetCharSize(GetHWND(), NULL, &y, GetFont());
    y = EDIT_HEIGHT_FROM_CHAR_HEIGHT(y);

    // JACS: we should always use the height calculated
    // from above, because otherwise we'll get a spin control
    // that's too big. So never use the height calculated
    // from wxSpinButton::DoGetBestSize().

    // if ( sizeBtn.y < y )
    {
        // make the text tall enough
        sizeBtn.y = y;
    }

    return sizeBtn;
}

void wxChoice::DoMoveWindow(int x, int y, int width, int height)
{
    int widthBtn = GetBestSpinnerSize(IsVertical(GetWindowStyle())).x;
    int widthText = width - widthBtn - MARGIN_BETWEEN;
    if ( widthText <= 0 )
    {
        wxLogDebug(wxT("not enough space for wxSpinCtrl!"));
    }

    if ( !::MoveWindow(GetBuddyHwnd(), x, y, widthText, height, TRUE) )
    {
        wxLogLastError(wxT("MoveWindow(buddy)"));
    }

    x += widthText + MARGIN_BETWEEN;
    if ( !::MoveWindow(GetHwnd(), x, y, widthBtn, height, TRUE) )
    {
        wxLogLastError(wxT("MoveWindow"));
    }
}

// get total size of the control
void wxChoice::DoGetSize(int *x, int *y) const
{
    RECT spinrect, textrect, ctrlrect;
    GetWindowRect(GetHwnd(), &spinrect);
    GetWindowRect(GetBuddyHwnd(), &textrect);
    UnionRect(&ctrlrect, &textrect, &spinrect);

    if ( x )
        *x = ctrlrect.right - ctrlrect.left;
    if ( y )
        *y = ctrlrect.bottom - ctrlrect.top;
}

void wxChoice::DoGetPosition(int *x, int *y) const
{
    // hack: pretend that our HWND is the text control just for a moment
    WXHWND hWnd = GetHWND();
    wxConstCast(this, wxChoice)->m_hWnd = m_hwndBuddy;

    wxChoiceBase::DoGetPosition(x, y);

    wxConstCast(this, wxChoice)->m_hWnd = hWnd;
}

#endif // wxUSE_CHOICE && __SMARTPHONE__ && __WXWINCE__
Commit	Line	Data
1550d5f8 WS	1	///////////////////////////////////////////////////////////////////////////////
1550d5f8 WS	2	// Name: src/msw/wince/choicece.cpp
8300f815	3	// Purpose: wxChoice implementation for smart phones driven by WinCE
1550d5f8 WS	4	// Author: Wlodzimierz ABX Skiba
	5	// Modified by:
	6	// Created: 29.07.2004
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Wlodzimierz Skiba
526954c5	9	// Licence: wxWindows licence
1550d5f8 WS	10	///////////////////////////////////////////////////////////////////////////////
1550d5f8 WS	11
1550d5f8 WS	12	// ============================================================================
	13	// declarations
	14	// ============================================================================
	15
	16	// ----------------------------------------------------------------------------
	17	// headers
	18	// ----------------------------------------------------------------------------
	19
1550d5f8 WS	20	// For compilers that support precompilation, includes "wx.h".
	21	#include "wx/wxprec.h"
	22
	23	#ifdef __BORLANDC__
	24	#pragma hdrstop
	25	#endif
	26
8228b893 WS	27	#if wxUSE_CHOICE && defined(__SMARTPHONE__) && defined(__WXWINCE__)
8228b893 WS	28
b36e08d0 WS	29	#include "wx/choice.h"
b36e08d0 WS	30
1550d5f8	31	#ifndef WX_PRECOMP
57bd4c60	32	#include "wx/msw/wrapcctl.h" // include <commctrl.h> "properly"
1550d5f8 WS	33	#endif
	34
	35	#include "wx/spinbutt.h" // for wxSpinnerBestSize
	36
1550d5f8 WS	37	#define GetBuddyHwnd() (HWND)(m_hwndBuddy)
	38
	39	#define IsVertical(wxStyle) ( (wxStyle & wxSP_HORIZONTAL) != wxSP_HORIZONTAL )
	40
	41	// ----------------------------------------------------------------------------
	42	// constants
	43	// ----------------------------------------------------------------------------
	44
	45	// the margin between the up-down control and its buddy (can be arbitrary,
	46	// choose what you like - or may be decide during run-time depending on the
	47	// font size?)
	48	static const int MARGIN_BETWEEN = 0;
	49
	50	// ============================================================================
	51	// implementation
	52	// ============================================================================
	53
	54	wxArrayChoiceSpins wxChoice::ms_allChoiceSpins;
	55
	56	// ----------------------------------------------------------------------------
	57	// wnd proc for the buddy text ctrl
	58	// ----------------------------------------------------------------------------
	59
	60	LRESULT APIENTRY _EXPORT wxBuddyChoiceWndProc(HWND hwnd,
	61	UINT message,
	62	WPARAM wParam,
	63	LPARAM lParam)
	64	{
	65	wxChoice spin = (wxChoice )wxGetWindowUserData(hwnd);
	66
	67	// forward some messages (the key and focus ones only so far) to
	68	// the spin ctrl
	69	switch ( message )
	70	{
	71	case WM_SETFOCUS:
	72	// if the focus comes from the spin control itself, don't set it
	73	// back to it -- we don't want to go into an infinite loop
	74	if ( (WXHWND)wParam == spin->GetHWND() )
	75	break;
	76	//else: fall through
	77
	78	case WM_KILLFOCUS:
	79	case WM_CHAR:
	80	case WM_DEADCHAR:
	81	case WM_KEYUP:
	82	case WM_KEYDOWN:
	83	spin->MSWWindowProc(message, wParam, lParam);
	84
	85	// The control may have been deleted at this point, so check.
	86	if ( !::IsWindow(hwnd) \|\| wxGetWindowUserData(hwnd) != spin )
	87	return 0;
	88	break;
	89
	90	case WM_GETDLGCODE:
	91	// we want to get WXK_RETURN in order to generate the event for it
	92	return DLGC_WANTCHARS;
	93	}
	94
	95	return ::CallWindowProc(CASTWNDPROC spin->GetBuddyWndProc(),
	96	hwnd, message, wParam, lParam);
	97	}
	98
01d2bf4d WS	99	wxChoice *wxChoice::GetChoiceForListBox(WXHWND hwndBuddy)
	100	{
	101	wxChoice choice = (wxChoice )wxGetWindowUserData((HWND)hwndBuddy);
	102
	103	int i = ms_allChoiceSpins.Index(choice);
	104
	105	if ( i == wxNOT_FOUND )
	106	return NULL;
	107
	108	// sanity check
	109	wxASSERT_MSG( choice->m_hwndBuddy == hwndBuddy,
9a83f860	110	wxT("wxChoice has incorrect buddy HWND!") );
01d2bf4d WS	111
	112	return choice;
	113	}
	114
1550d5f8 WS	115	// ----------------------------------------------------------------------------
	116	// creation
	117	// ----------------------------------------------------------------------------
	118
	119	bool wxChoice::Create(wxWindow *parent,
	120	wxWindowID id,
	121	const wxPoint& pos,
	122	const wxSize& size,
	123	int n, const wxString choices[],
	124	long style,
	125	const wxValidator& validator,
	126	const wxString& name)
	127	{
	128	return CreateAndInit(parent, id, pos, size, n, choices, style,
	129	validator, name);
	130	}
	131
	132	bool wxChoice::CreateAndInit(wxWindow *parent,
	133	wxWindowID id,
	134	const wxPoint& pos,
	135	const wxSize& size,
	136	int n, const wxString choices[],
	137	long style,
	138	const wxValidator& validator,
	139	const wxString& name)
	140	{
	141	if ( !(style & wxSP_VERTICAL) )
	142	style \|= wxSP_HORIZONTAL;
	143
	144	if ( (style & wxBORDER_MASK) == wxBORDER_DEFAULT )
	145	style \|= wxBORDER_SIMPLE;
	146
	147	style \|= wxSP_ARROW_KEYS;
	148
	149	SetWindowStyle(style);
	150
	151	WXDWORD exStyle = 0;
	152	WXDWORD msStyle = MSWGetStyle(GetWindowStyle(), & exStyle) ;
	153
	154	wxSize sizeText(size), sizeBtn(size);
5aaabb37	155	sizeBtn.x = GetBestSpinnerSize(IsVertical(style)).x;
1550d5f8	156
1550d5f8 WS	157	if ( sizeText.x == wxDefaultCoord )
	158	{
	159	// DEFAULT_ITEM_WIDTH is the default width for the text control
	160	sizeText.x = DEFAULT_ITEM_WIDTH + MARGIN_BETWEEN + sizeBtn.x;
	161	}
	162
	163	sizeText.x -= sizeBtn.x + MARGIN_BETWEEN;
	164	if ( sizeText.x <= 0 )
	165	{
9a83f860	166	wxLogDebug(wxT("not enough space for wxSpinCtrl!"));
1550d5f8 WS	167	}
	168
	169	wxPoint posBtn(pos);
	170	posBtn.x += sizeText.x + MARGIN_BETWEEN;
	171
	172	// we must create the list control before the spin button for the purpose
	173	// of the dialog navigation: if there is a static text just before the spin
	174	// control, activating it by Alt-letter should give focus to the text
	175	// control, not the spin and the dialog navigation code will give focus to
	176	// the next control (at Windows level), not the one after it
	177
	178	// create the text window
	179
	180	m_hwndBuddy = (WXHWND)::CreateWindowEx
	181	(
	182	exStyle, // sunken border
9a83f860	183	wxT("LISTBOX"), // window class
1550d5f8 WS	184	NULL, // no window title
	185	msStyle, // style (will be shown later)
	186	pos.x, pos.y, // position
	187	0, 0, // size (will be set later)
	188	GetHwndOf(parent), // parent
	189	(HMENU)-1, // control id
	190	wxGetInstance(), // app instance
	191	NULL // unused client data
	192	);
	193
	194	if ( !m_hwndBuddy )
	195	{
	196	wxLogLastError(wxT("CreateWindow(buddy text window)"));
	197
	198	return false;
	199	}
	200
	201	// initialize wxControl
	202	if ( !CreateControl(parent, id, posBtn, sizeBtn, style, validator, name) )
	203	return false;
	204
	205	// now create the real HWND
	206	WXDWORD spiner_style = WS_VISIBLE \|
	207	UDS_ALIGNRIGHT \|
	208	UDS_ARROWKEYS \|
	209	UDS_SETBUDDYINT \|
	210	UDS_EXPANDABLE;
	211
	212	if ( !IsVertical(style) )
	213	spiner_style \|= UDS_HORZ;
	214
	215	if ( style & wxSP_WRAP )
	216	spiner_style \|= UDS_WRAP;
	217
11e62fe6	218	if ( !MSWCreateControl(UPDOWN_CLASS, spiner_style, posBtn, sizeBtn, wxEmptyString, 0) )
1550d5f8 WS	219	return false;
	220
	221	// subclass the text ctrl to be able to intercept some events
	222	wxSetWindowUserData(GetBuddyHwnd(), this);
	223	m_wndProcBuddy = (WXFARPROC)wxSetWindowProc(GetBuddyHwnd(),
	224	wxBuddyChoiceWndProc);
	225
	226	// set up fonts and colours (This is nomally done in MSWCreateControl)
	227	InheritAttributes();
	228	if (!m_hasFont)
	229	SetFont(GetDefaultAttributes().font);
	230
	231	// set the size of the text window - can do it only now, because we
	232	// couldn't call DoGetBestSize() before as font wasn't set
	233	if ( sizeText.y <= 0 )
	234	{
	235	int cx, cy;
	236	wxGetCharSize(GetHWND(), &cx, &cy, GetFont());
	237
	238	sizeText.y = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
	239	}
	240
170acdc9	241	SetInitialSize(size);
1550d5f8 WS	242
	243	(void)::ShowWindow(GetBuddyHwnd(), SW_SHOW);
	244
	245	// associate the list window with the spin button
	246	(void)::SendMessage(GetHwnd(), UDM_SETBUDDY, (WPARAM)GetBuddyHwnd(), 0);
	247
	248	// do it after finishing with m_hwndBuddy creation to avoid generating
	249	// initial wxEVT_COMMAND_TEXT_UPDATED message
	250	ms_allChoiceSpins.Add(this);
	251
	252	// initialize the controls contents
	253	for ( int i = 0; i < n; i++ )
	254	{
	255	Append(choices[i]);
	256	}
	257
	258	return true;
	259	}
	260
	261	bool wxChoice::Create(wxWindow *parent,
	262	wxWindowID id,
	263	const wxPoint& pos,
	264	const wxSize& size,
	265	const wxArrayString& choices,
	266	long style,
	267	const wxValidator& validator,
	268	const wxString& name)
	269	{
	270	wxCArrayString chs(choices);
	271	return Create(parent, id, pos, size, chs.GetCount(), chs.GetStrings(),
	272	style, validator, name);
	273	}
	274
	275	WXDWORD wxChoice::MSWGetStyle(long style, WXDWORD *exstyle) const
	276	{
	277	// we never have an external border
	278	WXDWORD msStyle = wxControl::MSWGetStyle
	279	(
	280	(style & ~wxBORDER_MASK) \| wxBORDER_NONE, exstyle
	281	);
	282
	283	msStyle \|= WS_VISIBLE;
	284
	285	// wxChoice-specific styles
	286	msStyle \|= LBS_NOINTEGRALHEIGHT;
	287	if ( style & wxCB_SORT )
	288	msStyle \|= LBS_SORT;
	289
01d2bf4d WS	290	msStyle \|= LBS_NOTIFY;
01d2bf4d WS	291
1550d5f8 WS	292	return msStyle;
	293	}
	294
01d2bf4d WS	295	bool wxChoice::MSWCommand(WXUINT param, WXWORD WXUNUSED(id))
	296	{
	297	if ( param != LBN_SELCHANGE)
	298	{
	299	// "selection changed" is the only event we're after
	300	return false;
	301	}
	302
	303	int n = GetSelection();
	304	if (n > -1)
	305	{
	306	wxCommandEvent event(wxEVT_COMMAND_CHOICE_SELECTED, m_windowId);
	307	event.SetInt(n);
	308	event.SetEventObject(this);
	309	event.SetString(GetStringSelection());
	310	if ( HasClientObjectData() )
	311	event.SetClientObject( GetClientObject(n) );
	312	else if ( HasClientUntypedData() )
	313	event.SetClientData( GetClientData(n) );
	314	ProcessCommand(event);
	315	}
	316
	317	return true;
	318	}
	319
1550d5f8 WS	320	wxChoice::~wxChoice()
1550d5f8 WS	321	{
a236aa20	322	Clear();
1550d5f8 WS	323	}
	324
	325	// ----------------------------------------------------------------------------
	326	// adding/deleting items to/from the list
	327	// ----------------------------------------------------------------------------
	328
a236aa20 VZ	329	int wxChoice::DoInsertItems(const wxArrayStringsAdapter& items,
	330	unsigned int pos,
	331	void **clientData,
	332	wxClientDataType type)
1550d5f8	333	{
a236aa20	334	MSWAllocStorage(items, LB_INITSTORAGE);
1550d5f8	335
a236aa20 VZ	336	const bool append = pos == GetCount();
	337	const unsigned msg = append ? LB_ADDSTRING : LB_INSERTSTRING;
	338	if ( append )
	339	pos = 0;
1550d5f8	340
a236aa20	341	int n = wxNOT_FOUND;
1550d5f8	342
a236aa20 VZ	343	const unsigned int numItems = items.GetCount();
a236aa20 VZ	344	for ( unsigned int i = 0; i < numItems; ++i )
1550d5f8	345	{
a236aa20 VZ	346	n = MSWInsertOrAppendItem(pos, items[i], msg);
	347	if ( !append )
	348	pos++;
	349
	350	AssignNewItemClientData(n, clientData, i, type);
1550d5f8 WS	351	}
	352
	353	return n;
	354	}
	355
a236aa20	356	void wxChoice::DoDeleteOneItem(unsigned int n)
1550d5f8	357	{
8228b893	358	wxCHECK_RET( IsValid(n), wxT("invalid item index in wxChoice::Delete") );
1550d5f8	359
39fc096d	360	::SendMessage(GetBuddyHwnd(), LB_DELETESTRING, n, 0);
1550d5f8 WS	361	}
1550d5f8 WS	362
a236aa20	363	void wxChoice::DoClear()
1550d5f8	364	{
39fc096d	365	::SendMessage(GetBuddyHwnd(), LB_RESETCONTENT, 0, 0);
1550d5f8 WS	366	}
1550d5f8 WS	367
1550d5f8 WS	368	// ----------------------------------------------------------------------------
	369	// selection
	370	// ----------------------------------------------------------------------------
	371
	372	int wxChoice::GetSelection() const
	373	{
39fc096d	374	return (int)::SendMessage(GetBuddyHwnd(), LB_GETCURSEL, 0, 0);
1550d5f8 WS	375	}
	376
	377	void wxChoice::SetSelection(int n)
	378	{
39fc096d	379	::SendMessage(GetBuddyHwnd(), LB_SETCURSEL, n, 0);
1550d5f8 WS	380	}
	381
	382	// ----------------------------------------------------------------------------
	383	// string list functions
	384	// ----------------------------------------------------------------------------
	385
aa61d352	386	unsigned int wxChoice::GetCount() const
1550d5f8	387	{
aa61d352	388	return (unsigned int)::SendMessage(GetBuddyHwnd(), LB_GETCOUNT, 0, 0);
1550d5f8 WS	389	}
1550d5f8 WS	390
11e62fe6	391	int wxChoice::FindString(const wxString& s, bool bCase) const
1550d5f8	392	{
11e62fe6 WS	393	// back to base class search for not native search type
	394	if (bCase)
	395	return wxItemContainerImmutable::FindString( s, bCase );
	396
39fc096d	397	int pos = (int)::SendMessage(GetBuddyHwnd(), LB_FINDSTRINGEXACT,
1550d5f8 WS	398	(WPARAM)-1, (LPARAM)s.c_str());
	399
	400	return pos == LB_ERR ? wxNOT_FOUND : pos;
	401	}
	402
aa61d352	403	void wxChoice::SetString(unsigned int n, const wxString& s)
1550d5f8	404	{
8228b893	405	wxCHECK_RET( IsValid(n),
1550d5f8 WS	406	wxT("invalid item index in wxChoice::SetString") );
	407
	408	// we have to delete and add back the string as there is no way to change a
	409	// string in place
	410
	411	// we need to preserve the client data
	412	void *data;
	413	if ( m_clientDataItemsType != wxClientData_None )
	414	{
	415	data = DoGetItemClientData(n);
	416	}
	417	else // no client data
	418	{
	419	data = NULL;
	420	}
	421
	422	::SendMessage(GetBuddyHwnd(), LB_DELETESTRING, n, 0);
	423	::SendMessage(GetBuddyHwnd(), LB_INSERTSTRING, n, (LPARAM)s.c_str() );
	424
	425	if ( data )
	426	{
	427	DoSetItemClientData(n, data);
	428	}
	429	//else: it's already NULL by default
	430	}
	431
aa61d352	432	wxString wxChoice::GetString(unsigned int n) const
1550d5f8 WS	433	{
	434	int len = (int)::SendMessage(GetBuddyHwnd(), LB_GETTEXTLEN, n, 0);
	435
	436	wxString str;
	437	if ( len != LB_ERR && len > 0 )
	438	{
	439	if ( ::SendMessage
	440	(
	441	GetBuddyHwnd(),
	442	LB_GETTEXT,
	443	n,
	444	(LPARAM)(wxChar *)wxStringBuffer(str, len)
	445	) == LB_ERR )
	446	{
	447	wxLogLastError(wxT("SendMessage(LB_GETLBTEXT)"));
	448	}
	449	}
	450
	451	return str;
	452	}
	453
	454	// ----------------------------------------------------------------------------
	455	// client data
	456	// ----------------------------------------------------------------------------
	457
aa61d352	458	void wxChoice::DoSetItemClientData(unsigned int n, void* clientData)
1550d5f8 WS	459	{
	460	if ( ::SendMessage(GetHwnd(), LB_SETITEMDATA,
	461	n, (LPARAM)clientData) == LB_ERR )
	462	{
	463	wxLogLastError(wxT("LB_SETITEMDATA"));
	464	}
	465	}
	466
aa61d352	467	void* wxChoice::DoGetItemClientData(unsigned int n) const
1550d5f8	468	{
39fc096d	469	LPARAM rc = ::SendMessage(GetHwnd(), LB_GETITEMDATA, n, 0);
1550d5f8 WS	470	if ( rc == LB_ERR )
	471	{
	472	wxLogLastError(wxT("LB_GETITEMDATA"));
	473
	474	// unfortunately, there is no way to return an error code to the user
	475	rc = (LPARAM) NULL;
	476	}
	477
	478	return (void *)rc;
	479	}
	480
1550d5f8 WS	481	// ----------------------------------------------------------------------------
	482	// size calculations
	483	// ----------------------------------------------------------------------------
	484
	485	wxSize wxChoice::DoGetBestSize() const
	486	{
5aaabb37	487	wxSize sizeBtn = GetBestSpinnerSize(IsVertical(GetWindowStyle()));
1550d5f8 WS	488	sizeBtn.x += DEFAULT_ITEM_WIDTH + MARGIN_BETWEEN;
	489
	490	int y;
	491	wxGetCharSize(GetHWND(), NULL, &y, GetFont());
	492	y = EDIT_HEIGHT_FROM_CHAR_HEIGHT(y);
	493
	494	// JACS: we should always use the height calculated
	495	// from above, because otherwise we'll get a spin control
	496	// that's too big. So never use the height calculated
	497	// from wxSpinButton::DoGetBestSize().
	498
	499	// if ( sizeBtn.y < y )
	500	{
	501	// make the text tall enough
	502	sizeBtn.y = y;
	503	}
	504
	505	return sizeBtn;
	506	}
	507
	508	void wxChoice::DoMoveWindow(int x, int y, int width, int height)
	509	{
5aaabb37	510	int widthBtn = GetBestSpinnerSize(IsVertical(GetWindowStyle())).x;
1550d5f8 WS	511	int widthText = width - widthBtn - MARGIN_BETWEEN;
	512	if ( widthText <= 0 )
	513	{
9a83f860	514	wxLogDebug(wxT("not enough space for wxSpinCtrl!"));
1550d5f8 WS	515	}
	516
	517	if ( !::MoveWindow(GetBuddyHwnd(), x, y, widthText, height, TRUE) )
	518	{
	519	wxLogLastError(wxT("MoveWindow(buddy)"));
	520	}
	521
	522	x += widthText + MARGIN_BETWEEN;
	523	if ( !::MoveWindow(GetHwnd(), x, y, widthBtn, height, TRUE) )
	524	{
	525	wxLogLastError(wxT("MoveWindow"));
	526	}
	527	}
	528
	529	// get total size of the control
	530	void wxChoice::DoGetSize(int x, int y) const
	531	{
	532	RECT spinrect, textrect, ctrlrect;
	533	GetWindowRect(GetHwnd(), &spinrect);
	534	GetWindowRect(GetBuddyHwnd(), &textrect);
	535	UnionRect(&ctrlrect, &textrect, &spinrect);
	536
	537	if ( x )
	538	*x = ctrlrect.right - ctrlrect.left;
	539	if ( y )
	540	*y = ctrlrect.bottom - ctrlrect.top;
	541	}
	542
	543	void wxChoice::DoGetPosition(int x, int y) const
	544	{
	545	// hack: pretend that our HWND is the text control just for a moment
	546	WXHWND hWnd = GetHWND();
	547	wxConstCast(this, wxChoice)->m_hWnd = m_hwndBuddy;
	548
	549	wxChoiceBase::DoGetPosition(x, y);
	550
	551	wxConstCast(this, wxChoice)->m_hWnd = hWnd;
	552	}
	553
8300f815	554	#endif // wxUSE_CHOICE && __SMARTPHONE__ && __WXWINCE__