bool wxWindow::LoadNativeDialog (
wxWindow* pParent
, const wxString& rsName
)
{
HWND hWndOwner;
if (pParent)
hWndOwner = GetHwndOf(pParent);
else
hWndOwner = HWND_DESKTOP;
SetName(rsName);
wxWndHook = this;
m_hWnd = ::WinLoadDlg( HWND_DESKTOP
,hWndOwner
,(PFNWP)wxDlgProc
,NULL
,(ULONG)131 // Caption dialog from the resource file
,(PVOID)this
);
wxWndHook = NULL;
if (!m_hWnd)
return FALSE;
SubclassWin(GetHWND());
if (pParent)
pParent->AddChild(this);
else
wxTopLevelWindows.Append(this);
return TRUE;
} // end of wxWindow::LoadNativeDialog
bool wxNonOwnedWindow::Create(wxWindow *parent, WXWindow nativeWindow)
{
if ( parent )
parent->AddChild(this);
SubclassWin(nativeWindow);
return true;
}
bool wxBitmapCheckBox::Create(
wxWindow* pParent
, wxWindowID vId
, const wxBitmap* pLabel
, const wxPoint& rPos
, const wxSize& rSize
, long lStyle
, const wxValidator& rValidator
, const wxString& rsName
)
{
SetName(rsName);
#if wxUSE_VALIDATORS
SetValidator(rValidator);
#endif
if (pParent)
pParent->AddChild(this);
SetBackgroundColour(pParent->GetBackgroundColour()) ;
SetForegroundColour(pParent->GetForegroundColour()) ;
m_windowStyle = lStyle;
if (vId == -1)
m_windowId = NewControlId();
else
m_windowId = vId;
int nX = rPos.x;
int nY = rPos.y;
int nWidth = rSize.x;
int nHeight = rSize.y;
m_nCheckWidth = -1 ;
m_nCheckHeight = -1 ;
// long msStyle = CHECK_FLAGS;
HWND hButton = 0; // TODO: Create the bitmap checkbox
m_hWnd = (WXHWND)hButton;
//
// Subclass again for purposes of dialog editing mode
//
SubclassWin((WXHWND)hButton);
SetSize( nX
,nY
,nWidth
,nHeight
);
::WinShowWindow(hButton, TRUE);
return TRUE;
} // end of wxBitmapCheckBox::Create
bool wxWindow::LoadNativeDialog (
wxWindow* pParent
, wxWindowID& vId
)
{
wxWindow* pChild = NULL;
HWND hWndOwner;
HWND hWndNext = NULLHANDLE;
HENUM hEnum;
if (pParent)
hWndOwner = GetHwndOf(pParent);
else
hWndOwner = HWND_DESKTOP;
m_windowId = vId;
wxWndHook = this;
m_hWnd = ::WinLoadDlg( HWND_DESKTOP
,hWndOwner
,(PFNWP)wxDlgProc
,NULL
,(ULONG)131 // Caption dialog from the resource file
,(PVOID)this
);
wxWndHook = NULL;
if ( !m_hWnd )
return FALSE;
SubclassWin(GetHWND());
if (pParent)
pParent->AddChild(this);
else
wxTopLevelWindows.Append(this);
//
// Enumerate the children
//
hEnum = ::WinBeginEnumWindows(GetHwndOf(pParent));
while ((hWndNext = ::WinGetNextWindow(hEnum)) != NULLHANDLE)
pChild = CreateWindowFromHWND( this
,(WXHWND)hWndNext
);
::WinEndEnumWindows(hEnum);
return TRUE;
} // end of wxWindow::LoadNativeDialog
bool wxMDIClientWindow::CreateClient(wxMDIParentFrame *parent, long style)
{
m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
CLIENTCREATESTRUCT ccs;
m_windowStyle = style;
m_parent = parent;
ccs.hWindowMenu = GetMDIWindowMenu(parent);
ccs.idFirstChild = wxFIRST_MDI_CHILD;
DWORD msStyle = MDIS_ALLCHILDSTYLES | WS_VISIBLE | WS_CHILD |
WS_CLIPCHILDREN | WS_CLIPSIBLINGS;
if ( style & wxHSCROLL )
msStyle |= WS_HSCROLL;
if ( style & wxVSCROLL )
msStyle |= WS_VSCROLL;
#if defined(__WIN95__)
DWORD exStyle = WS_EX_CLIENTEDGE;
#else
DWORD exStyle = 0;
#endif
wxWindowCreationHook hook(this);
m_hWnd = (WXHWND)::CreateWindowEx
(
exStyle,
wxT("MDICLIENT"),
NULL,
msStyle,
0, 0, 0, 0,
GetWinHwnd(parent),
NULL,
wxGetInstance(),
(LPSTR)(LPCLIENTCREATESTRUCT)&ccs);
if ( !m_hWnd )
{
wxLogLastError(wxT("CreateWindowEx(MDI client)"));
return false;
}
SubclassWin(m_hWnd);
return true;
}
bool wxTabCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
long style, const wxString& name)
{
m_imageList = NULL;
m_backgroundColour = *wxWHITE; // TODO: wxColour(GetRValue(GetSysColor(COLOR_BTNFACE)),
// GetGValue(GetSysColor(COLOR_BTNFACE)), GetBValue(GetSysColor(COLOR_BTNFACE)));
m_foregroundColour = *wxBLACK ;
SetName(name);
int x = pos.x;
int y = pos.y;
int width = size.x;
int height = size.y;
m_windowStyle = style;
SetFont(* (wxTheFontList->FindOrCreateFont(11, wxSWISS, wxNORMAL, wxNORMAL)));
SetParent(parent);
if (width <= 0)
width = 100;
if (height <= 0)
height = 30;
if (x < 0)
x = 0;
if (y < 0)
y = 0;
m_windowId = (id < 0 ? NewControlId() : id);
// Create the toolbar control.
HWND hWndTabCtrl = 0;
// TODO: create tab control
m_hWnd = (WXHWND) hWndTabCtrl;
if (parent) parent->AddChild(this);
SubclassWin((WXHWND) hWndTabCtrl);
return false;
}
bool wxToolMenuBar::MSWCreateToolbar(const wxPoint& WXUNUSED(pos), const wxSize& WXUNUSED(size), wxMenuBar* menuBar)
{
SetMenuBar(menuBar);
if (m_menuBar)
m_menuBar->SetToolBar(this);
#if defined(WINCE_WITHOUT_COMMANDBAR)
// Create the menubar.
SHMENUBARINFO mbi;
memset (&mbi, 0, sizeof (SHMENUBARINFO));
mbi.cbSize = sizeof (SHMENUBARINFO);
mbi.hwndParent = (HWND) GetParent()->GetHWND();
#ifdef __SMARTPHONE__
mbi.nToolBarId = 5002;
#else
mbi.nToolBarId = 5000;
#endif
mbi.nBmpId = 0;
mbi.cBmpImages = 0;
mbi.dwFlags = 0 ; // SHCMBF_EMPTYBAR;
mbi.hInstRes = wxGetInstance();
if (!SHCreateMenuBar(&mbi))
{
wxFAIL_MSG( _T("SHCreateMenuBar failed") );
return false;
}
SetHWND((WXHWND) mbi.hwndMB);
#else
HWND hWnd = CommandBar_Create(wxGetInstance(), (HWND) GetParent()->GetHWND(), GetId());
SetHWND((WXHWND) hWnd);
#endif
// install wxWidgets window proc for this window
SubclassWin(m_hWnd);
if (menuBar)
menuBar->Create();
return true;
}
bool
wxNativeWindow::Create(wxWindow* parent,
wxWindowID winid,
wxNativeWindowHandle hwnd)
{
wxCHECK_MSG( hwnd, false, wxS("Invalid null HWND") );
wxCHECK_MSG( parent, false, wxS("Must have a valid parent") );
wxASSERT_MSG( ::GetParent(hwnd) == GetHwndOf(parent),
wxS("The native window has incorrect parent") );
const wxRect r = wxRectFromRECT(wxGetWindowRect(hwnd));
// Skip wxWindow::Create() which would try to create a new HWND, we don't
// want this as we already have one.
if ( !CreateBase(parent, winid,
r.GetPosition(), r.GetSize(),
0, wxDefaultValidator, wxS("nativewindow")) )
return false;
parent->AddChild(this);
SubclassWin(hwnd);
if ( winid == wxID_ANY )
{
// We allocated a new ID to the control, use it at Windows level as
// well because we assume that our and MSW IDs are the same in many
// places and it seems prudent to avoid breaking this assumption.
SetId(GetId());
}
else // We used a fixed ID.
{
// For the same reason as above, check that it's the same as the one
// used by the native HWND.
wxASSERT_MSG( ::GetWindowLong(hwnd, GWL_ID) == winid,
wxS("Mismatch between wx and native IDs") );
}
InheritAttributes();
return true;
}
bool wxNativeContainerWindow::Create(wxNativeContainerWindowHandle hwnd)
{
if ( !::IsWindow(hwnd) )
{
// strictly speaking, the fact that IsWindow() returns true doesn't
// mean that the window handle is valid -- it could be being deleted
// right now, for example
//
// but if it returns false, the handle is definitely invalid
return false;
}
// make this HWND really a wxWindow
SubclassWin(hwnd);
// inherit the other attributes we can from the native HWND
AdoptAttributesFromHWND();
return true;
}
bool wxToolMenuBar::MSWCreateToolbar(const wxPoint& WXUNUSED(pos),
const wxSize& WXUNUSED(size),
wxMenuBar *menuBar)
{
SetMenuBar(menuBar);
if (m_menuBar)
m_menuBar->SetToolBar(this);
HWND hwndParent = GetHwndOf(GetParent());
wxCHECK_MSG( hwndParent, false, wxT("should have valid parent HWND") );
#if defined(WINCE_WITHOUT_COMMANDBAR)
// create the menubar.
WinStruct<SHMENUBARINFO> mbi;
mbi.hwndParent = hwndParent;
mbi.nToolBarId = wxIDM_SHMENU;
mbi.hInstRes = wxGetInstance();
if ( !SHCreateMenuBar(&mbi) )
{
wxFAIL_MSG( wxT("SHCreateMenuBar failed") );
return false;
}
SetHWND((WXHWND) mbi.hwndMB);
#else
HWND hWnd = CommandBar_Create(wxGetInstance(), hwndParent, GetId());
SetHWND((WXHWND) hWnd);
#endif
// install wxWidgets window proc for this window
SubclassWin(m_hWnd);
if (menuBar)
menuBar->Create();
return true;
}
bool wxWindow::LoadNativeDialog(wxWindow* parent, const wxString& name)
{
SetName(name);
wxWindowCreationHook hook(this);
m_hWnd = (WXHWND)::CreateDialog((HINSTANCE) wxGetInstance(),
name.c_str(),
parent ? (HWND)parent->GetHWND() : 0,
(DLGPROC)wxDlgProc);
if ( !m_hWnd )
return false;
SubclassWin(GetHWND());
if ( parent )
parent->AddChild(this);
else
wxTopLevelWindows.Append(this);
// Enumerate all children
HWND hWndNext;
hWndNext = ::GetWindow((HWND) m_hWnd, GW_CHILD);
if (hWndNext)
CreateWindowFromHWND(this, (WXHWND) hWndNext);
while (hWndNext != (HWND) NULL)
{
hWndNext = ::GetWindow(hWndNext, GW_HWNDNEXT);
if (hWndNext)
CreateWindowFromHWND(this, (WXHWND) hWndNext);
}
return true;
}
bool wxTopLevelWindowMSW::CreateDialog(const void *dlgTemplate,
const wxString& title,
const wxPoint& pos,
const wxSize& size)
{
#ifdef __WXMICROWIN__
// no dialogs support under MicroWin yet
return CreateFrame(title, pos, size);
#else // !__WXMICROWIN__
// static cast is valid as we're only ever called for dialogs
wxWindow * const
parent = static_cast<wxDialog *>(this)->GetParentForModalDialog();
m_hWnd = (WXHWND)::CreateDialogIndirect
(
wxGetInstance(),
(DLGTEMPLATE*)dlgTemplate,
parent ? GetHwndOf(parent) : NULL,
(DLGPROC)wxDlgProc
);
if ( !m_hWnd )
{
wxFAIL_MSG(wxT("Failed to create dialog. Incorrect DLGTEMPLATE?"));
wxLogSysError(wxT("Can't create dialog using memory template"));
return false;
}
#if !defined(__WXWINCE__)
// For some reason, the system menu is activated when we use the
// WS_EX_CONTEXTHELP style, so let's set a reasonable icon
if ( HasExtraStyle(wxWS_EX_CONTEXTHELP) )
{
wxFrame *winTop = wxDynamicCast(wxTheApp->GetTopWindow(), wxFrame);
if ( winTop )
{
wxIcon icon = winTop->GetIcon();
if ( icon.IsOk() )
{
::SendMessage(GetHwnd(), WM_SETICON,
(WPARAM)TRUE,
(LPARAM)GetHiconOf(icon));
}
}
}
#endif // !__WXWINCE__
if ( !title.empty() )
{
::SetWindowText(GetHwnd(), title.t_str());
}
SubclassWin(m_hWnd);
#if !defined(__WXWINCE__) || defined(__WINCE_STANDARDSDK__)
// move the dialog to its initial position without forcing repainting
int x, y, w, h;
(void)MSWGetCreateWindowCoords(pos, size, x, y, w, h);
if ( x == (int)CW_USEDEFAULT )
{
// Let the system position the window, just set its size.
::SetWindowPos(GetHwnd(), 0,
0, 0, w, h,
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
}
else // Move the window to the desired location and set its size too.
{
if ( !::MoveWindow(GetHwnd(), x, y, w, h, FALSE) )
{
wxLogLastError(wxT("MoveWindow"));
}
}
#endif // !__WXWINCE__
#ifdef __SMARTPHONE__
// Work around title non-display glitch
Show(false);
#endif
return true;
#endif // __WXMICROWIN__/!__WXMICROWIN__
}
bool wxControl::MSWCreateControl(const wxChar *classname,
WXDWORD style,
const wxPoint& pos,
const wxSize& size,
const wxString& label,
WXDWORD exstyle)
{
// if no extended style given, determine it ourselves
if ( exstyle == (WXDWORD)-1 )
{
exstyle = 0;
(void) MSWGetStyle(GetWindowStyle(), &exstyle);
}
// all controls should have this style
style |= WS_CHILD;
// create the control visible if it's currently shown for wxWidgets
if ( m_isShown )
{
style |= WS_VISIBLE;
}
// choose the position for the control: we have a problem with default size
// here as we can't calculate the best size before the control exists
// (DoGetBestSize() may need to use m_hWnd), so just choose the minimal
// possible but non 0 size because 0 window width/height result in problems
// elsewhere
int x = pos.x == wxDefaultCoord ? 0 : pos.x,
y = pos.y == wxDefaultCoord ? 0 : pos.y,
w = size.x == wxDefaultCoord ? 1 : size.x,
h = size.y == wxDefaultCoord ? 1 : size.y;
// ... and adjust it to account for a possible parent frames toolbar
AdjustForParentClientOrigin(x, y);
m_hWnd = (WXHWND)::CreateWindowEx
(
exstyle, // extended style
classname, // the kind of control to create
label, // the window name
style, // the window style
x, y, w, h, // the window position and size
GetHwndOf(GetParent()), // parent
(HMENU)GetId(), // child id
wxGetInstance(), // app instance
NULL // creation parameters
);
if ( !m_hWnd )
{
#ifdef __WXDEBUG__
wxFAIL_MSG(wxString::Format
(
_T("CreateWindowEx(\"%s\", flags=%08x, ex=%08x) failed"),
classname, (unsigned int)style, (unsigned int)exstyle
));
#endif // __WXDEBUG__
return false;
}
// install wxWidgets window proc for this window
SubclassWin(m_hWnd);
// set up fonts and colours
InheritAttributes();
if (!m_hasFont)
SetFont(GetDefaultAttributes().font);
// set the size now if no initial size specified
SetInitialBestSize(size);
return true;
}
bool wxBitmapButton::Create( wxWindow* pParent,
wxWindowID vId,
const wxBitmap& rBitmap,
const wxPoint& rPos,
const wxSize& rSize,
long lStyle,
const wxValidator& rValidator,
const wxString& rsName )
{
m_bitmaps[State_Normal] = rBitmap;
SetName(rsName);
#if wxUSE_VALIDATORS
SetValidator(rValidator);
#endif
pParent->AddChild(this);
m_backgroundColour = pParent->GetBackgroundColour() ;
m_foregroundColour = pParent->GetForegroundColour() ;
m_windowStyle = lStyle;
if (lStyle & wxBU_AUTODRAW)
{
m_marginX = wxDEFAULT_BUTTON_MARGIN;
m_marginY = wxDEFAULT_BUTTON_MARGIN;
}
int nX = rPos.x;
int nY = rPos.y;
int nWidth = rSize.x;
int nHeight = rSize.y;
if (vId == wxID_ANY)
m_windowId = NewControlId();
else
m_windowId = vId;
if (nWidth == wxDefaultCoord && rBitmap.IsOk())
nWidth = rBitmap.GetWidth() + 4 * m_marginX;
if (nHeight == wxDefaultCoord && rBitmap.IsOk())
nHeight = rBitmap.GetHeight() + 4 * m_marginY;
ULONG ulOS2Style = WS_VISIBLE | WS_TABSTOP | BS_USERBUTTON;
if (m_windowStyle & wxCLIP_SIBLINGS)
ulOS2Style |= WS_CLIPSIBLINGS;
m_hWnd = (WXHWND)::WinCreateWindow( GetHwndOf(pParent)
,WC_BUTTON
,(PSZ)wxEmptyString
,ulOS2Style
,0, 0, 0, 0
,GetHwndOf(pParent)
,HWND_TOP
,m_windowId
,NULL
,NULL
);
//
//Subclass again for purposes of dialog editing mode
//
SubclassWin(m_hWnd);
SetFont(*wxSMALL_FONT);
SetSize( nX
,nY
,nWidth
,nHeight
);
return true;
} // end of wxBitmapButton::Create
bool wxTabCtrl::Create(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size,
long style, const wxString& name)
{
m_imageList = NULL;
m_backgroundColour = wxColour(GetRValue(GetSysColor(COLOR_BTNFACE)),
GetGValue(GetSysColor(COLOR_BTNFACE)), GetBValue(GetSysColor(COLOR_BTNFACE)));
m_foregroundColour = *wxBLACK ;
SetName(name);
int x = pos.x;
int y = pos.y;
int width = size.x;
int height = size.y;
m_windowStyle = style;
SetParent(parent);
if (width <= 0)
width = 100;
if (height <= 0)
height = 30;
if (x < 0)
x = 0;
if (y < 0)
y = 0;
m_windowId = (id < 0 ? NewControlId() : id);
long tabStyle = WS_CHILD | WS_VISIBLE;
if (m_windowStyle & wxTC_MULTILINE)
tabStyle |= TCS_MULTILINE;
if (m_windowStyle & wxTC_RIGHTJUSTIFY)
tabStyle |= TCS_RIGHTJUSTIFY;
if (m_windowStyle & wxTC_FIXEDWIDTH)
tabStyle |= TCS_FIXEDWIDTH;
if (m_windowStyle & wxTC_OWNERDRAW)
tabStyle |= TCS_OWNERDRAWFIXED;
if (m_windowStyle & wxBORDER)
tabStyle |= WS_BORDER;
#ifndef __WXWINCE__
tabStyle |= TCS_TOOLTIPS;
#endif
// Create the toolbar control.
HWND hWndTabCtrl = CreateWindowEx(0L, // No extended styles.
WC_TABCONTROL, // Class name for the tab control
wxEmptyString, // No default text.
tabStyle, // Styles and defaults.
x, y, width, height, // Standard size and position.
(HWND) parent->GetHWND(), // Parent window
(HMENU)m_windowId, // ID.
wxGetInstance(), // Current instance.
NULL ); // No class data.
m_hWnd = (WXHWND) hWndTabCtrl;
if (parent) parent->AddChild(this);
SubclassWin((WXHWND) hWndTabCtrl);
SetFont(wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT));
return true;
}
bool wxMDIChildFrame::Create(wxMDIParentFrame *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
m_mdiParent = parent;
SetName(name);
if ( id != wxID_ANY )
m_windowId = id;
else
m_windowId = NewControlId();
if ( parent )
{
parent->AddChild(this);
}
int x = pos.x;
int y = pos.y;
int width = size.x;
int height = size.y;
MDICREATESTRUCT mcs;
wxString className =
wxApp::GetRegisteredClassName(wxT("wxMDIChildFrame"), COLOR_WINDOW);
if ( !(style & wxFULL_REPAINT_ON_RESIZE) )
className += wxApp::GetNoRedrawClassSuffix();
mcs.szClass = className.wx_str();
mcs.szTitle = title.wx_str();
mcs.hOwner = wxGetInstance();
if (x != wxDefaultCoord)
mcs.x = x;
else
mcs.x = CW_USEDEFAULT;
if (y != wxDefaultCoord)
mcs.y = y;
else
mcs.y = CW_USEDEFAULT;
if (width != wxDefaultCoord)
mcs.cx = width;
else
mcs.cx = CW_USEDEFAULT;
if (height != wxDefaultCoord)
mcs.cy = height;
else
mcs.cy = CW_USEDEFAULT;
DWORD msflags = WS_OVERLAPPED | WS_CLIPCHILDREN;
if (style & wxMINIMIZE_BOX)
msflags |= WS_MINIMIZEBOX;
if (style & wxMAXIMIZE_BOX)
msflags |= WS_MAXIMIZEBOX;
if (style & wxRESIZE_BORDER)
msflags |= WS_THICKFRAME;
if (style & wxSYSTEM_MENU)
msflags |= WS_SYSMENU;
if ((style & wxMINIMIZE) || (style & wxICONIZE))
msflags |= WS_MINIMIZE;
if (style & wxMAXIMIZE)
msflags |= WS_MAXIMIZE;
if (style & wxCAPTION)
msflags |= WS_CAPTION;
mcs.style = msflags;
mcs.lParam = 0;
wxWindowCreationHook hook(this);
m_hWnd = (WXHWND)::SendMessage(GetWinHwnd(parent->GetClientWindow()),
WM_MDICREATE, 0, (LPARAM)&mcs);
if ( !m_hWnd )
{
wxLogLastError(wxT("WM_MDICREATE"));
return false;
}
SubclassWin(m_hWnd);
parent->AddMDIChild(this);
return true;
}
bool wxTextCtrl::Create(
wxWindow* pParent
, wxWindowID vId
, const wxString& rsValue
, const wxPoint& rPos
, const wxSize& rSize
, long lStyle
, const wxValidator& rValidator
, const wxString& rsName
)
{
//
// Base initialization
//
if ( !CreateBase( pParent
,vId
,rPos
,rSize
,lStyle
,rValidator
,rsName
))
return false;
wxPoint vPos = rPos; // The OS/2 position
SWP vSwp;
if (pParent )
{
pParent->AddChild(this);
}
m_windowStyle = lStyle;
m_bIsMLE = false;
m_bSkipUpdate = false;
long lSstyle = WS_VISIBLE | WS_TABSTOP;
//
// Single and multiline edit fields are two different controls in PM
//
if ( m_windowStyle & wxTE_MULTILINE )
{
lSstyle |= MLS_BORDER | MLS_WORDWRAP;
m_bIsMLE = true;
if ((m_windowStyle & wxTE_NO_VSCROLL) == 0)
lSstyle |= MLS_VSCROLL;
if (m_windowStyle & wxHSCROLL)
lSstyle |= MLS_HSCROLL;
if (m_windowStyle & wxTE_READONLY)
lSstyle |= MLS_READONLY;
}
else
{
lSstyle |= ES_LEFT | ES_AUTOSCROLL | ES_MARGIN;
if (m_windowStyle & wxHSCROLL)
lSstyle |= ES_AUTOSCROLL;
if (m_windowStyle & wxTE_READONLY)
lSstyle |= ES_READONLY;
if (m_windowStyle & wxTE_PASSWORD) // hidden input
lSstyle |= ES_UNREADABLE;
}
if (m_bIsMLE)
{
m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
,WC_MLE // Window class
,(PSZ)rsValue.c_str() // Initial Text
,(ULONG)lSstyle // Style flags
,(LONG)0 // X pos of origin
,(LONG)0 // Y pos of origin
,(LONG)0 // field width
,(LONG)0 // field height
,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
,HWND_TOP // initial z position
,(ULONG)vId // Window identifier
,NULL // no control data
,NULL // no Presentation parameters
);
}
else
{
m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
,WC_ENTRYFIELD // Window class
,(PSZ)rsValue.c_str() // Initial Text
,(ULONG)lSstyle // Style flags
,(LONG)0 // X pos of origin
,(LONG)0 // Y pos of origin
,(LONG)0 // field width
,(LONG)0 // field height
,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
,HWND_TOP // initial z position
,(ULONG)vId // Window identifier
,NULL // no control data
,NULL // no Presentation parameters
);
}
if (m_hWnd == 0)
{
return false;
}
SubclassWin(GetHWND());
//
// Set font, position, size and initial value
//
wxFont* pTextFont = new wxFont( 8
,wxMODERN
,wxNORMAL
,wxNORMAL
);
SetFont(*pTextFont);
if (!rsValue.empty())
{
SetValue(rsValue);
}
SetupColours();
//
// If X and/or Y are not zero the difference is the compensation value
// for margins for OS/2 controls.
//
::WinQueryWindowPos(m_hWnd, &vSwp);
SetXComp(vSwp.x);
SetYComp(vSwp.y);
SetSize( vPos.x - GetXComp()
,vPos.y - GetYComp()
,rSize.x
,rSize.y
);
delete pTextFont;
return true;
} // end of wxTextCtrl::Create
bool wxListBox::Create(
wxWindow* pParent
, wxWindowID vId
, const wxPoint& rPos
, const wxSize& rSize
, int n
, const wxString asChoices[]
, long lStyle
, const wxValidator& rValidator
, const wxString& rsName
)
{
m_nNumItems = 0;
m_hWnd = 0;
m_nSelected = 0;
SetName(rsName);
#if wxUSE_VALIDATORS
SetValidator(rValidator);
#endif
if (pParent)
pParent->AddChild(this);
wxSystemSettings vSettings;
SetBackgroundColour(vSettings.GetColour(wxSYS_COLOUR_WINDOW));
SetForegroundColour(pParent->GetForegroundColour());
m_windowId = (vId == -1) ? (int)NewControlId() : vId;
int nX = rPos.x;
int nY = rPos.y;
int nWidth = rSize.x;
int nHeight = rSize.y;
m_windowStyle = lStyle;
lStyle = WS_VISIBLE;
if (m_windowStyle & wxCLIP_SIBLINGS )
lStyle |= WS_CLIPSIBLINGS;
if (m_windowStyle & wxLB_MULTIPLE)
lStyle |= LS_MULTIPLESEL;
else if (m_windowStyle & wxLB_EXTENDED)
lStyle |= LS_EXTENDEDSEL;
if (m_windowStyle & wxLB_HSCROLL)
lStyle |= LS_HORZSCROLL;
if (m_windowStyle & wxLB_OWNERDRAW)
lStyle |= LS_OWNERDRAW;
//
// Without this style, you get unexpected heights, so e.g. constraint layout
// doesn't work properly
//
lStyle |= LS_NOADJUSTPOS;
m_hWnd = (WXHWND)::WinCreateWindow( GetWinHwnd(pParent) // Parent
,WC_LISTBOX // Default Listbox class
,"LISTBOX" // Control's name
,lStyle // Initial Style
,0, 0, 0, 0 // Position and size
,GetWinHwnd(pParent) // Owner
,HWND_TOP // Z-Order
,(HMENU)m_windowId // Id
,NULL // Control Data
,NULL // Presentation Parameters
);
if (m_hWnd == 0)
{
return false;
}
//
// Subclass again for purposes of dialog editing mode
//
SubclassWin(m_hWnd);
LONG lUi;
for (lUi = 0; lUi < (LONG)n; lUi++)
{
Append(asChoices[lUi]);
}
wxFont* pTextFont = new wxFont( 10
,wxMODERN
,wxNORMAL
,wxNORMAL
);
SetFont(*pTextFont);
//
// Set OS/2 system colours for Listbox items and highlighting
//
wxColour vColour;
vColour = wxSystemSettingsNative::GetColour(wxSYS_COLOUR_HIGHLIGHTTEXT);
LONG lColor = (LONG)vColour.GetPixel();
::WinSetPresParam( m_hWnd
,PP_HILITEFOREGROUNDCOLOR
,sizeof(LONG)
,(PVOID)&lColor
);
vColour = wxSystemSettingsNative::GetColour(wxSYS_COLOUR_HIGHLIGHT);
lColor = (LONG)vColour.GetPixel();
::WinSetPresParam( m_hWnd
,PP_HILITEBACKGROUNDCOLOR
,sizeof(LONG)
,(PVOID)&lColor
);
SetSize( nX
,nY
,nWidth
,nHeight
);
delete pTextFont;
return true;
} // end of wxListBox::Create
bool wxStaticBitmap::Create( wxWindow* pParent,
wxWindowID nId,
const wxGDIImage& rBitmap,
const wxPoint& rPos,
const wxSize& WXUNUSED(rSize),
long lStyle,
const wxString& rName )
{
ERRORID vError;
wxString sError;
Init();
SetName(rName);
if (pParent)
pParent->AddChild(this);
if (nId == -1)
m_windowId = (int)NewControlId();
else
m_windowId = nId;
m_windowStyle = lStyle;
int nX= rPos.x;
int nY = rPos.y;
char zId[16];
m_windowStyle = lStyle;
m_bIsIcon = rBitmap.IsKindOf(CLASSINFO(wxIcon));
//
// For now we only support an ICON
//
int nWinstyle = SS_ICON;
m_hWnd = (WXHWND)::WinCreateWindow( pParent->GetHWND()
,(PSZ)wxCanvasClassName
,zId
,nWinstyle | WS_VISIBLE
,0,0,0,0
,pParent->GetHWND()
,HWND_TOP
,m_windowId
,NULL
,NULL
);
if (!m_hWnd)
{
vError = ::WinGetLastError(wxGetInstance());
sError = wxPMErrorToStr(vError);
return false;
}
wxCHECK_MSG( m_hWnd, false, wxT("Failed to create static bitmap") );
m_pImage = ConvertImage(rBitmap);
::WinSendMsg( m_hWnd,
SM_SETHANDLE,
MPFROMHWND(rBitmap.GetHandle()),
(MPARAM)0);
// Subclass again for purposes of dialog editing mode
SubclassWin(m_hWnd);
SetSize(nX, nY, m_pImage->GetWidth(), m_pImage->GetHeight());
return true;
} // end of wxStaticBitmap::Create
bool wxStatusBar95::Create(wxWindow *parent,
wxWindowID id,
long style,
const wxString& name)
{
wxCHECK_MSG( parent, false, wxT("status bar must have a parent") );
SetName(name);
SetWindowStyleFlag(style);
SetParent(parent);
parent->AddChild(this);
m_windowId = id == wxID_ANY ? NewControlId() : id;
DWORD wstyle = WS_CHILD | WS_VISIBLE;
if ( style & wxCLIP_SIBLINGS )
wstyle |= WS_CLIPSIBLINGS;
// setting SBARS_SIZEGRIP is perfectly useless: it's always on by default
// (at least in the version of comctl32.dll I'm using), and the only way to
// turn it off is to use CCS_TOP style - as we position the status bar
// manually anyhow (see DoMoveWindow), use CCS_TOP style if wxST_SIZEGRIP
// is not given
if ( !(style & wxST_SIZEGRIP) )
{
wstyle |= CCS_TOP;
}
else
{
#ifndef __WXWINCE__
// may be some versions of comctl32.dll do need it - anyhow, it won't
// do any harm
wstyle |= SBARS_SIZEGRIP;
#endif
}
m_hWnd = (WXHWND)CreateStatusWindow(wstyle,
wxEmptyString,
GetHwndOf(parent),
m_windowId);
if ( m_hWnd == 0 )
{
wxLogSysError(_("Failed to create a status bar."));
return false;
}
SetFieldsCount(1);
SubclassWin(m_hWnd);
InheritAttributes();
SetBackgroundColour(wxSystemSettings::GetColour(wxSYS_COLOUR_MENUBAR));
// we must refresh the frame size when the statusbar is created, because
// its client area might change
wxFrame *frame = wxDynamicCast(GetParent(), wxFrame);
if ( frame )
{
frame->SendSizeEvent();
}
return true;
}
bool wxBitmapButton::Create(wxWindow *parent, wxWindowID id,
const wxBitmap& bitmap,
const wxPoint& pos,
const wxSize& size, long style,
const wxValidator& wxVALIDATOR_PARAM(validator),
const wxString& name)
{
m_bmpNormal = bitmap;
SetName(name);
#if wxUSE_VALIDATORS
SetValidator(validator);
#endif // wxUSE_VALIDATORS
parent->AddChild(this);
m_windowStyle = style;
if ( style & wxBU_AUTODRAW )
{
m_marginX =
m_marginY = 4;
}
if (id == wxID_ANY)
m_windowId = NewControlId();
else
m_windowId = id;
long msStyle = WS_VISIBLE | WS_TABSTOP | WS_CHILD | BS_OWNERDRAW ;
if ( m_windowStyle & wxCLIP_SIBLINGS )
msStyle |= WS_CLIPSIBLINGS;
#ifdef __WIN32__
if(m_windowStyle & wxBU_LEFT)
msStyle |= BS_LEFT;
if(m_windowStyle & wxBU_RIGHT)
msStyle |= BS_RIGHT;
if(m_windowStyle & wxBU_TOP)
msStyle |= BS_TOP;
if(m_windowStyle & wxBU_BOTTOM)
msStyle |= BS_BOTTOM;
#endif
m_hWnd = (WXHWND) CreateWindowEx(
0,
wxT("BUTTON"),
wxEmptyString,
msStyle,
0, 0, 0, 0,
GetWinHwnd(parent),
(HMENU)m_windowId,
wxGetInstance(),
NULL
);
// Subclass again for purposes of dialog editing mode
SubclassWin(m_hWnd);
SetPosition(pos);
SetInitialSize(size);
return true;
}
bool wxStaticText::Create(
wxWindow* pParent
, wxWindowID vId
, const wxString& rsLabel
, const wxPoint& rPos
, const wxSize& rSize
, long lStyle
, const wxString& rsName
)
{
SetName(rsName);
if (pParent)
pParent->AddChild(this);
SetBackgroundColour(pParent->GetBackgroundColour()) ;
SetForegroundColour(pParent->GetForegroundColour()) ;
if ( vId == -1 )
m_windowId = (int)NewControlId();
else
m_windowId = vId;
int nX = rPos.x;
int nY = rPos.y;
int nWidth = rSize.x;
int nHeight = rSize.y;
m_windowStyle = lStyle;
long lSstyle = 0L;
lSstyle = WS_VISIBLE | SS_TEXT | DT_VCENTER | DT_MNEMONIC;
if (m_windowStyle & wxALIGN_CENTRE)
lSstyle |= DT_CENTER;
else if (m_windowStyle & wxALIGN_RIGHT)
lSstyle |= DT_RIGHT;
else
lSstyle |= DT_LEFT;
wxString sLabel = ::wxPMTextToLabel(rsLabel);
m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
,WC_STATIC // Window class
,(PSZ)sLabel.c_str() // Initial Text
,(ULONG)lSstyle // Style flags
,0L, 0L, 0L, 0L // Origin -- 0 size
,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
,HWND_TOP // initial z position
,(ULONG)m_windowId // Window identifier
,NULL // no control data
,NULL // no Presentation parameters
);
wxCHECK_MSG(m_hWnd, FALSE, wxT("Failed to create static ctrl"));
wxColour vColour;
vColour.Set(wxString(wxT("BLACK")));
LONG lColor = (LONG)vColour.GetPixel();
::WinSetPresParam( m_hWnd
,PP_FOREGROUNDCOLOR
,sizeof(LONG)
,(PVOID)&lColor
);
lColor = (LONG)m_backgroundColour.GetPixel();
::WinSetPresParam( m_hWnd
,PP_BACKGROUNDCOLOR
,sizeof(LONG)
,(PVOID)&lColor
);
SubclassWin(m_hWnd);
SetFont(*wxSMALL_FONT);
SetXComp(0);
SetYComp(0);
SetSize( nX
,nY
,nWidth
,nHeight
);
return TRUE;
} // end of wxStaticText::Create
bool wxSpinButton::Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
// basic initialization
m_windowId = (id == wxID_ANY) ? NewControlId() : id;
SetName(name);
int x = pos.x;
int y = pos.y;
int width = size.x;
int height = size.y;
m_windowStyle = style;
SetParent(parent);
// get the right size for the control
if ( width <= 0 || height <= 0 )
{
wxSize size = DoGetBestSize();
if ( width <= 0 )
width = size.x;
if ( height <= 0 )
height = size.y;
}
if ( x < 0 )
x = 0;
if ( y < 0 )
y = 0;
// translate the styles
DWORD wstyle = WS_VISIBLE | WS_CHILD | WS_TABSTOP | /* WS_CLIPSIBLINGS | */
UDS_NOTHOUSANDS | // never useful, sometimes harmful
UDS_SETBUDDYINT; // it doesn't harm if we don't have buddy
if ( m_windowStyle & wxCLIP_SIBLINGS )
wstyle |= WS_CLIPSIBLINGS;
if ( m_windowStyle & wxSP_HORIZONTAL )
wstyle |= UDS_HORZ;
if ( m_windowStyle & wxSP_ARROW_KEYS )
wstyle |= UDS_ARROWKEYS;
if ( m_windowStyle & wxSP_WRAP )
wstyle |= UDS_WRAP;
// create the UpDown control.
m_hWnd = (WXHWND)CreateUpDownControl
(
wstyle,
x, y, width, height,
GetHwndOf(parent),
m_windowId,
wxGetInstance(),
NULL, // no buddy
m_max, m_min,
m_min // initial position
);
if ( !m_hWnd )
{
wxLogLastError(wxT("CreateUpDownControl"));
return false;
}
if ( parent )
{
parent->AddChild(this);
}
SubclassWin(m_hWnd);
SetInitialSize(size);
return true;
}
bool wxButton::Create( wxWindow* pParent,
wxWindowID vId,
const wxString& rsLbl,
const wxPoint& rPos,
const wxSize& rSize,
long lStyle,
const wxValidator& rValidator,
const wxString& rsName)
{
wxString rsLabel(rsLbl);
if (rsLabel.empty() && wxIsStockID(vId))
rsLabel = wxGetStockLabel(vId);
wxString sLabel = ::wxPMTextToLabel(rsLabel);
SetName(rsName);
#if wxUSE_VALIDATORS
SetValidator(rValidator);
#endif
m_windowStyle = lStyle;
pParent->AddChild((wxButton *)this);
if (vId == -1)
m_windowId = NewControlId();
else
m_windowId = vId;
lStyle = WS_VISIBLE | WS_TABSTOP | BS_PUSHBUTTON;
//
// OS/2 PM does not have Right/Left/Top/Bottom styles.
// We will have to define an additional style when we implement notebooks
// for a notebook page button
//
if (m_windowStyle & wxCLIP_SIBLINGS )
lStyle |= WS_CLIPSIBLINGS;
m_hWnd = (WXHWND)::WinCreateWindow( GetHwndOf(pParent) // Parent handle
,WC_BUTTON // A Button class window
,(PSZ)sLabel.c_str() // Button text
,lStyle // Button style
,0, 0, 0, 0 // Location and size
,GetHwndOf(pParent) // Owner handle
,HWND_TOP // Top of Z-Order
,vId // Identifier
,NULL // No control data
,NULL // No Presentation parameters
);
if (m_hWnd == 0)
{
return false;
}
//
// Subclass again for purposes of dialog editing mode
//
SubclassWin(m_hWnd);
wxFont* pButtonFont = new wxFont( 8
,wxSWISS
,wxNORMAL
,wxNORMAL
);
SetFont(*pButtonFont);
SetXComp(0);
SetYComp(0);
SetSize( rPos.x
,rPos.y
,rSize.x
,rSize.y
);
delete pButtonFont;
return true;
} // end of wxButton::Create
bool wxControl::MSWCreateControl(const wxChar *classname,
WXDWORD style,
const wxPoint& pos,
const wxSize& size,
const wxString& label,
WXDWORD exstyle)
{
// if no extended style given, determine it ourselves
if ( exstyle == (WXDWORD)-1 )
{
exstyle = 0;
(void) MSWGetStyle(GetWindowStyle(), &exstyle);
}
// all controls should have this style
style |= WS_CHILD;
// create the control visible if it's currently shown for wxWidgets
if ( m_isShown )
{
style |= WS_VISIBLE;
}
// choose the position for the control: we have a problem with default size
// here as we can't calculate the best size before the control exists
// (DoGetBestSize() may need to use m_hWnd), so just choose the minimal
// possible but non 0 size because 0 window width/height result in problems
// elsewhere
int x = pos.x == wxDefaultCoord ? 0 : pos.x,
y = pos.y == wxDefaultCoord ? 0 : pos.y,
w = size.x == wxDefaultCoord ? 1 : size.x,
h = size.y == wxDefaultCoord ? 1 : size.y;
// ... and adjust it to account for a possible parent frames toolbar
AdjustForParentClientOrigin(x, y);
m_hWnd = (WXHWND)::CreateWindowEx
(
exstyle, // extended style
classname, // the kind of control to create
label.t_str(), // the window name
style, // the window style
x, y, w, h, // the window position and size
GetHwndOf(GetParent()), // parent
(HMENU)wxUIntToPtr(GetId()), // child id
wxGetInstance(), // app instance
NULL // creation parameters
);
if ( !m_hWnd )
{
wxLogLastError(wxString::Format
(
wxT("CreateWindowEx(\"%s\", flags=%08lx, ex=%08lx)"),
classname, style, exstyle
));
return false;
}
#if !wxUSE_UNICODE
// Text labels starting with the character 0xff (which is a valid character
// in many code pages) don't appear correctly as CreateWindowEx() has some
// special treatment for this case, apparently the strings starting with -1
// are not really strings but something called "ordinals". There is no
// documentation about it but the fact is that the label gets mangled or
// not displayed at all if we don't do this, see #9572.
//
// Notice that 0xffff is not a valid Unicode character so the problem
// doesn't arise in Unicode build.
if ( !label.empty() && label[0] == -1 )
::SetWindowText(GetHwnd(), label.t_str());
#endif // !wxUSE_UNICODE
// saving the label in m_labelOrig to return it verbatim
// later in GetLabel()
m_labelOrig = label;
// install wxWidgets window proc for this window
SubclassWin(m_hWnd);
// set up fonts and colours
InheritAttributes();
if ( !m_hasFont )
{
bool setFont = true;
wxFont font = GetDefaultAttributes().font;
// if we set a font for {list,tree}ctrls and the font size is changed in
// the display properties then the font size for these controls doesn't
// automatically adjust when they receive WM_SETTINGCHANGE
// FIXME: replace the dynamic casts with virtual function calls!!
#if wxUSE_LISTCTRL || wxUSE_TREECTRL
bool testFont = false;
#if wxUSE_LISTCTRL
if ( wxDynamicCastThis(wxListCtrl) )
testFont = true;
#endif // wxUSE_LISTCTRL
#if wxUSE_TREECTRL
if ( wxDynamicCastThis(wxTreeCtrl) )
testFont = true;
#endif // wxUSE_TREECTRL
if ( testFont )
{
// not sure if we need to explicitly set the font here for Win95/NT4
// but we definitely can't do it for any newer version
// see wxGetCCDefaultFont() in src/msw/settings.cpp for explanation
// of why this test works
// TODO: test Win95/NT4 to see if this is needed or breaks the
// font resizing as it does on newer versions
if ( font != wxSystemSettings::GetFont(wxSYS_DEFAULT_GUI_FONT) )
{
setFont = false;
}
}
#endif // wxUSE_LISTCTRL || wxUSE_TREECTRL
if ( setFont )
{
SetFont(GetDefaultAttributes().font);
}
}
// set the size now if no initial size specified
SetInitialSize(size);
return true;
}
bool wxControl::OS2CreateControl( const wxChar* zClassname,
WXDWORD dwStyle,
const wxPoint& rPos,
const wxSize& rSize,
const wxString& rsLabel,
WXDWORD dwExstyle )
{
//
// Doesn't do anything at all under OS/2
//
if (dwExstyle == (WXDWORD)-1)
{
dwExstyle = 0;
(void) OS2GetStyle(GetWindowStyle(), &dwExstyle);
}
//
// All controls should have these styles (wxWidgets creates all controls
// visible by default)
//
if (m_isShown )
dwStyle |= WS_VISIBLE;
wxWindow* pParent = GetParent();
PSZ zClass = "";
if (!pParent)
return false;
if ((wxStrcmp(zClassname, _T("COMBOBOX"))) == 0)
zClass = WC_COMBOBOX;
else if ((wxStrcmp(zClassname, _T("STATIC"))) == 0)
zClass = WC_STATIC;
else if ((wxStrcmp(zClassname, _T("BUTTON"))) == 0)
zClass = WC_BUTTON;
else if ((wxStrcmp(zClassname, _T("NOTEBOOK"))) == 0)
zClass = WC_NOTEBOOK;
else if ((wxStrcmp(zClassname, _T("CONTAINER"))) == 0)
zClass = WC_CONTAINER;
if ((zClass == WC_STATIC) || (zClass == WC_BUTTON))
dwStyle |= DT_MNEMONIC;
m_dwStyle = dwStyle;
m_label = rsLabel;
wxString label;
if (dwStyle & DT_MNEMONIC)
label = ::wxPMTextToLabel(m_label);
else
label = m_label;
// clipping siblings does not yet work
dwStyle &= ~WS_CLIPSIBLINGS;
m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
,(PSZ)zClass // Window class
,(PSZ)label.c_str() // Initial Text
,(ULONG)dwStyle // Style flags
,(LONG)0 // X pos of origin
,(LONG)0 // Y pos of origin
,(LONG)0 // control width
,(LONG)0 // control height
,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
,HWND_TOP // initial z position
,(ULONG)GetId() // Window identifier
,NULL // no control data
,NULL // no Presentation parameters
);
if ( !m_hWnd )
{
#ifdef __WXDEBUG__
wxLogError(wxT("Failed to create a control of class '%s'"), zClassname);
#endif // DEBUG
return false;
}
//
// Subclass again for purposes of dialog editing mode
//
SubclassWin(m_hWnd);
//
// Controls use the same colours as their parent dialog by default
//
InheritAttributes();
//
// All OS/2 ctrls use the small font
//
SetFont(*wxSMALL_FONT);
SetXComp(0);
SetYComp(0);
SetSize( rPos.x, rPos.y, rSize.x, rSize.y );
return true;
} // end of wxControl::OS2CreateControl
bool wxStaticText::Create( wxWindow* pParent,
wxWindowID vId,
const wxString& rsLabel,
const wxPoint& rPos,
const wxSize& rSize,
long lStyle,
const wxString& rsName )
{
SetName(rsName);
if (pParent)
pParent->AddChild(this);
SetBackgroundColour(pParent->GetBackgroundColour()) ;
SetForegroundColour(pParent->GetForegroundColour()) ;
if ( vId == wxID_ANY )
m_windowId = (int)NewControlId();
else
m_windowId = vId;
int nX = rPos.x;
int nY = rPos.y;
int nWidth = rSize.x;
int nHeight = rSize.y;
m_windowStyle = lStyle;
long lSstyle = 0L;
// Used to have DT_VCENTER but that doesn't work correctly with
// multiline strings and DT_WORDBREAK. Accept a reasonable
// compromise for now
lSstyle = WS_VISIBLE | SS_TEXT | DT_WORDBREAK | DT_MNEMONIC;
if (m_windowStyle & wxALIGN_CENTRE)
lSstyle |= DT_CENTER;
else if (m_windowStyle & wxALIGN_RIGHT)
lSstyle |= DT_RIGHT;
else
lSstyle |= DT_LEFT;
m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
,WC_STATIC // Window class
,NULL // Initial Text
,(ULONG)lSstyle // Style flags
,0L, 0L, 0L, 0L // Origin -- 0 size
,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
,HWND_TOP // initial z position
,(ULONG)m_windowId // Window identifier
,NULL // no control data
,NULL // no Presentation parameters
);
wxCHECK_MSG(m_hWnd, false, wxT("Failed to create static ctrl"));
LONG lColor = (LONG)wxBLACK->GetPixel();
::WinSetPresParam( m_hWnd
,PP_FOREGROUNDCOLOR
,sizeof(LONG)
,(PVOID)&lColor
);
lColor = (LONG)m_backgroundColour.GetPixel();
::WinSetPresParam( m_hWnd
,PP_BACKGROUNDCOLOR
,sizeof(LONG)
,(PVOID)&lColor
);
SubclassWin(m_hWnd);
SetFont(*wxSMALL_FONT);
SetXComp(0);
SetYComp(0);
SetSize( nX, nY, nWidth, nHeight );
SetLabel(rsLabel);
return true;
} // end of wxStaticText::Create
