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