bool wxRadioBox::Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
int n,
const wxString choices[],
int majorDim,
long style,
const wxValidator& val,
const wxString& name)
{
// common initialization
if ( !wxStaticBox::Create(parent, id, title, pos, size, style, name) )
return false;
// the code elsewhere in this file supposes that either wxRA_SPECIFY_COLS
// or wxRA_SPECIFY_ROWS is set, ensure that this is indeed the case
if ( !(style & (wxRA_SPECIFY_ROWS | wxRA_SPECIFY_COLS)) )
style |= wxRA_SPECIFY_COLS;
#if wxUSE_VALIDATORS
SetValidator(val);
#else
wxUnusedVar(val);
#endif // wxUSE_VALIDATORS/!wxUSE_VALIDATORS
// We need an extra one to keep track of the 'dummy' item we
// create to end the radio group, so it will be destroyed and
// it's id will be released. But we want it separate from the
// other buttons since the wxSubwindows will operate on it as
// well and we just want to ignore it until destroying it.
// For instance, we don't want the bounding box of the radio
// buttons to include the dummy button
m_radioButtons = new wxSubwindows(n);
m_radioWidth = new int[n];
m_radioHeight = new int[n];
for ( int i = 0; i < n; i++ )
{
m_radioWidth[i] =
m_radioHeight[i] = wxDefaultCoord;
long styleBtn = BS_AUTORADIOBUTTON | WS_TABSTOP | WS_CHILD | WS_VISIBLE;
if ( i == 0 )
styleBtn |= WS_GROUP;
wxWindowIDRef subid = NewControlId();
HWND hwndBtn = ::CreateWindow(wxT("BUTTON"),
choices[i].wx_str(),
styleBtn,
0, 0, 0, 0, // will be set in SetSize()
GetHwndOf(parent),
(HMENU)wxUIntToPtr(subid.GetValue()),
wxGetInstance(),
NULL);
if ( !hwndBtn )
{
wxLogLastError(wxT("CreateWindow(radio btn)"));
return false;
}
// Keep track of the subwindow
m_radioButtons->Set(i, hwndBtn, subid);
SubclassRadioButton((WXHWND)hwndBtn);
// Also, make it a subcontrol of this control
m_subControls.Add(subid);
}
// Create a dummy radio control to end the group.
m_dummyId = NewControlId();
m_dummyHwnd = (WXHWND)::CreateWindow(wxT("BUTTON"),
wxEmptyString,
WS_GROUP | BS_AUTORADIOBUTTON | WS_CHILD,
0, 0, 0, 0, GetHwndOf(parent),
(HMENU)wxUIntToPtr(m_dummyId.GetValue()),
wxGetInstance(), NULL);
m_radioButtons->SetFont(GetFont());
#ifdef __WXWINCE__
// Set the z-order correctly
SetWindowPos(GetHwnd(), HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE|SWP_NOSIZE);
#endif
SetMajorDim(majorDim == 0 ? n : majorDim, style);
SetSelection(0);
SetSize(pos.x, pos.y, size.x, size.y);
// Now that we have items determine what is the best size and set it.
SetInitialSize(size);
// And update all the buttons positions to match it.
const wxSize actualSize = GetSize();
PositionAllButtons(pos.x, pos.y, actualSize.x, actualSize.y);
return true;
}
bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
{
// Find out which MSW item before which we'll be inserting before
// wxMenuBarBase::Insert is called and GetMenu(pos) is the new menu.
// If IsAttached() is false this won't be used anyway
bool isAttached =
#if defined(WINCE_WITHOUT_COMMANDBAR)
IsAttached();
#else
(GetHmenu() != 0);
#endif
int mswpos = (!isAttached || (pos == m_menus.GetCount()))
? -1 // append the menu
: MSWPositionForWxMenu(GetMenu(pos),pos);
if ( !wxMenuBarBase::Insert(pos, menu, title) )
return false;
menu->wxMenuBase::SetTitle(title);
if ( isAttached )
{
#if defined(WINCE_WITHOUT_COMMANDBAR)
if (!GetToolBar())
return false;
TBBUTTON tbButton;
memset(&tbButton, 0, sizeof(TBBUTTON));
tbButton.iBitmap = I_IMAGENONE;
tbButton.fsState = TBSTATE_ENABLED;
tbButton.fsStyle = TBSTYLE_DROPDOWN | TBSTYLE_NO_DROPDOWN_ARROW | TBSTYLE_AUTOSIZE;
HMENU hPopupMenu = (HMENU) menu->GetHMenu() ;
tbButton.dwData = (DWORD)hPopupMenu;
wxString label = wxStripMenuCodes(title);
tbButton.iString = (int) label.wx_str();
tbButton.idCommand = NewControlId();
if (!::SendMessage((HWND) GetToolBar()->GetHWND(), TB_INSERTBUTTON, pos, (LPARAM)&tbButton))
{
wxLogLastError(wxT("TB_INSERTBUTTON"));
return false;
}
wxUnusedVar(mswpos);
#else
if ( !::InsertMenu(GetHmenu(), mswpos,
MF_BYPOSITION | MF_POPUP | MF_STRING,
(UINT_PTR)GetHmenuOf(menu), title.wx_str()) )
{
wxLogLastError(wxT("InsertMenu"));
}
#endif
#if wxUSE_ACCEL
if ( menu->HasAccels() )
{
// need to rebuild accell table
RebuildAccelTable();
}
#endif // wxUSE_ACCEL
if (IsAttached())
Refresh();
}
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 wxTopLevelWindowX11::Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
// init our fields
Init();
m_windowStyle = style;
m_parent = parent;
SetName(name);
m_windowId = id == wxID_ANY ? NewControlId() : id;
if (parent)
parent->AddChild(this);
wxTopLevelWindows.Append(this);
Display *xdisplay = wxGlobalDisplay();
int xscreen = DefaultScreen( xdisplay );
Visual *xvisual = DefaultVisual( xdisplay, xscreen );
Window xparent = RootWindow( xdisplay, xscreen );
Colormap cm = DefaultColormap( xdisplay, xscreen );
if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_BTNFACE);
else
m_backgroundColour = wxSystemSettings::GetColour(wxSYS_COLOUR_APPWORKSPACE);
m_backgroundColour.CalcPixel( (WXColormap) cm );
m_hasBgCol = true;
m_x = pos.x;
if (m_x < -1)
m_x = 10;
m_y = pos.y;
if (m_y < 0)
m_y = 10;
m_width = size.x;
if (m_width < 0)
m_width = 500;
m_height = size.y;
if (m_height < 0)
m_height = 380;
#if !wxUSE_NANOX
XSetWindowAttributes xattributes;
long xattributes_mask =
CWBorderPixel | CWBackPixel;
xattributes.background_pixel = m_backgroundColour.GetPixel();
xattributes.border_pixel = BlackPixel( xdisplay, xscreen );
if (HasFlag( wxNO_BORDER ))
{
xattributes_mask |= CWOverrideRedirect;
xattributes.override_redirect = True;
}
if (!HasFlag( wxFULL_REPAINT_ON_RESIZE ))
{
xattributes_mask |= CWBitGravity;
xattributes.bit_gravity = NorthWestGravity;
}
xattributes_mask |= CWEventMask;
xattributes.event_mask =
ExposureMask | KeyPressMask | KeyReleaseMask | ButtonPressMask | ButtonReleaseMask |
ButtonMotionMask | EnterWindowMask | LeaveWindowMask | PointerMotionMask |
KeymapStateMask | FocusChangeMask | ColormapChangeMask | StructureNotifyMask |
PropertyChangeMask;
Window xwindow = XCreateWindow( xdisplay, xparent, m_x, m_y, m_width, m_height,
0, DefaultDepth(xdisplay,xscreen), InputOutput, xvisual, xattributes_mask, &xattributes );
#else
long backColor, foreColor;
backColor = GR_RGB(m_backgroundColour.Red(), m_backgroundColour.Green(), m_backgroundColour.Blue());
foreColor = GR_RGB(m_foregroundColour.Red(), m_foregroundColour.Green(), m_foregroundColour.Blue());
Window xwindow = XCreateWindowWithColor( xdisplay, xparent, m_x, m_y, m_width, m_height,
0, 0, InputOutput, xvisual, backColor, foreColor);
#endif
m_mainWindow = (WXWindow) xwindow;
m_clientWindow = (WXWindow) xwindow;
wxAddWindowToTable( xwindow, (wxWindow*) this );
#if wxUSE_NANOX
XSelectInput( xdisplay, xwindow,
GR_EVENT_MASK_CLOSE_REQ |
ExposureMask |
KeyPressMask |
KeyReleaseMask |
ButtonPressMask |
ButtonReleaseMask |
ButtonMotionMask |
EnterWindowMask |
LeaveWindowMask |
PointerMotionMask |
KeymapStateMask |
FocusChangeMask |
ColormapChangeMask |
StructureNotifyMask |
PropertyChangeMask
);
#endif
// Set background to None which will prevent X11 from clearing the
// background completely.
XSetWindowBackgroundPixmap( xdisplay, xwindow, None );
#if !wxUSE_NANOX
if (HasFlag( wxSTAY_ON_TOP ))
{
Window xroot = RootWindow( xdisplay, xscreen );
XSetTransientForHint( xdisplay, xwindow, xroot );
}
else
{
if (GetExtraStyle() & wxTOPLEVEL_EX_DIALOG)
{
if (GetParent() && GetParent()->X11GetMainWindow())
{
Window xparentwindow = (Window) GetParent()->X11GetMainWindow();
XSetTransientForHint( xdisplay, xwindow, xparentwindow );
}
}
}
XSizeHints size_hints;
size_hints.flags = PSize | PPosition | PWinGravity;
size_hints.x = m_x;
size_hints.y = m_y;
size_hints.width = m_width;
size_hints.height = m_height;
size_hints.win_gravity = NorthWestGravity;
XSetWMNormalHints( xdisplay, xwindow, &size_hints);
XWMHints wm_hints;
wm_hints.flags = InputHint | StateHint;
if (GetParent())
{
wm_hints.flags |= WindowGroupHint;
wm_hints.window_group = (Window) GetParent()->X11GetMainWindow();
}
wm_hints.input = True;
wm_hints.initial_state = NormalState;
XSetWMHints( xdisplay, xwindow, &wm_hints);
Atom wm_protocols[2];
wm_protocols[0] = XInternAtom( xdisplay, "WM_DELETE_WINDOW", False );
wm_protocols[1] = XInternAtom( xdisplay, "WM_TAKE_FOCUS", False );
XSetWMProtocols( xdisplay, xwindow, wm_protocols, 2);
#endif
wxSetWMDecorations( xwindow, style);
SetTitle(title);
return true;
}
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
);
SetXComp(0);
SetYComp(0);
SetSize( nX
,nY
,nWidth
,nHeight
);
delete pTextFont;
return true;
} // end of wxListBox::Create
bool wxSpinButton::Create(
wxWindow* pParent
, wxWindowID vId
, const wxPoint& rPos
, const wxSize& rSize
, long lStyle
, const wxString& rsName
)
{
int nX = rPos.x;
int nY = rPos.y;
int nWidth = rSize.x;
int nHeight = rSize.y;
SWP vSwp;
m_min = 0;
m_max = 100;
if (vId == -1)
m_windowId = NewControlId();
else
m_windowId = vId;
m_backgroundColour = pParent->GetBackgroundColour();
m_foregroundColour = pParent->GetForegroundColour();
SetName(rsName);
SetParent(pParent);
m_windowStyle = lStyle;
//
// Get the right size for the control
//
if (nWidth <= 0 || nHeight <= 0 )
{
wxSize vSize = DoGetBestSize();
if (nWidth <= 0 )
nWidth = vSize.x;
if (nHeight <= 0 )
nHeight = vSize.y;
}
if (nX < 0 )
nX = 0;
if (nY < 0 )
nY = 0;
long lSstyle = 0L;
lSstyle = WS_VISIBLE |
WS_TABSTOP |
SPBS_MASTER | // We use only single field spin buttons
SPBS_NUMERICONLY; // We default to numeric data
if (m_windowStyle & wxCLIP_SIBLINGS )
lSstyle |= WS_CLIPSIBLINGS;
m_hWnd = (WXHWND)::WinCreateWindow( GetWinHwnd(pParent)
,WC_SPINBUTTON
,(PSZ)NULL
,lSstyle
,0L, 0L, 0L, 0L
,GetWinHwnd(pParent)
,HWND_TOP
,(HMENU)vId
,NULL
,NULL
);
if (m_hWnd == 0)
{
return FALSE;
}
SetRange(m_min, m_max);
if(pParent)
pParent->AddChild((wxSpinButton *)this);
::WinQueryWindowPos(m_hWnd, &vSwp);
SetXComp(vSwp.x);
SetYComp(vSwp.y-5); // compensate for the associated TextControl border
SetFont(*wxSMALL_FONT);
//
// For OS/2 we want to hide the text portion so we can substitute an
// independent text ctrl in its place.
// Therefore we must override any user given width with our best guess.
//
SetSize( nX - GetXComp()
,nY - GetYComp()
,nWidth
,nHeight
);
wxAssociateWinWithHandle( m_hWnd
,(wxWindowOS2*)this
);
#if 0
// FIXME:
// Apparently, this does not work, as it crashes in setvalue/setrange calls
// What's it supposed to do anyway?
::WinSetWindowULong(GetHwnd(), QWL_USER, (LONG)this);
fnWndProcSpinCtrl = (WXFARPROC)::WinSubclassWindow(m_hWnd, (PFNWP)wxSpinCtrlWndProc);
#endif
return TRUE;
} // end of wxSpinButton::Create
bool wxMenuBar::Insert(size_t pos, wxMenu *menu, const wxString& title)
{
// Find out which MSW item before which we'll be inserting before
// wxMenuBarBase::Insert is called and GetMenu(pos) is the new menu.
// If IsAttached() is false this won't be used anyway
bool isAttached =
#if defined(WINCE_WITHOUT_COMMANDBAR)
IsAttached();
#else
(GetHmenu() != 0);
#endif
if ( !wxMenuBarBase::Insert(pos, menu, title) )
return false;
menu->wxMenuBase::SetTitle(title);
if ( isAttached )
{
#if defined(WINCE_WITHOUT_COMMANDBAR)
if (!GetToolBar())
return false;
TBBUTTON tbButton;
memset(&tbButton, 0, sizeof(TBBUTTON));
tbButton.iBitmap = I_IMAGENONE;
tbButton.fsState = TBSTATE_ENABLED;
tbButton.fsStyle = TBSTYLE_DROPDOWN | TBSTYLE_NO_DROPDOWN_ARROW | TBSTYLE_AUTOSIZE;
HMENU hPopupMenu = (HMENU) menu->GetHMenu() ;
tbButton.dwData = (DWORD)hPopupMenu;
wxString label = wxStripMenuCodes(title);
tbButton.iString = (int) wxMSW_CONV_LPCTSTR(label);
tbButton.idCommand = NewControlId();
if (!::SendMessage((HWND) GetToolBar()->GetHWND(), TB_INSERTBUTTON, pos, (LPARAM)&tbButton))
{
wxLogLastError(wxT("TB_INSERTBUTTON"));
return false;
}
#else
// We have a problem with the index if there is an extra "Window" menu
// in this menu bar, which is added by wxMDIParentFrame to it directly
// using Windows API (so that it remains invisible to the user code),
// but which does affect the indices of the items we insert after it.
// So we check if any of the menus before the insertion position is a
// foreign one and adjust the insertion index accordingly.
int mswExtra = 0;
// Skip all this if the total number of menus matches (notice that the
// internal menu count has already been incremented by wxMenuBarBase::
// Insert() call above, hence -1).
int mswCount = ::GetMenuItemCount(GetHmenu());
if ( mswCount != -1 &&
static_cast<unsigned>(mswCount) != GetMenuCount() - 1 )
{
wxMenuList::compatibility_iterator node = m_menus.GetFirst();
for ( size_t n = 0; n < pos; n++ )
{
if ( ::GetSubMenu(GetHmenu(), n) != GetHmenuOf(node->GetData()) )
mswExtra++;
else
node = node->GetNext();
}
}
if ( !::InsertMenu(GetHmenu(), pos + mswExtra,
MF_BYPOSITION | MF_POPUP | MF_STRING,
(UINT_PTR)GetHmenuOf(menu), title.t_str()) )
{
wxLogLastError(wxT("InsertMenu"));
}
#endif
#if wxUSE_ACCEL
if ( menu->HasAccels() )
{
// need to rebuild accell table
RebuildAccelTable();
}
#endif // wxUSE_ACCEL
if (IsAttached())
Refresh();
}
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.t_str();
mcs.szTitle = title.t_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 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 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;
}
WXHMENU wxMenuBar::Create()
{
// Note: this totally doesn't work on Smartphone,
// since you have to use resources.
// We'll have to find another way to add a menu
// by changing/adding menu items to an existing menu.
#if defined(WINCE_WITHOUT_COMMANDBAR)
if ( m_hMenu != 0 )
return m_hMenu;
if (!GetToolBar())
return 0;
HWND hCommandBar = (HWND) GetToolBar()->GetHWND();
HMENU hMenu = (HMENU)::SendMessage(hCommandBar, SHCMBM_GETMENU, (WPARAM)0, (LPARAM)0);
if (hMenu)
{
TBBUTTON tbButton;
memset(&tbButton, 0, sizeof(TBBUTTON));
tbButton.iBitmap = I_IMAGENONE;
tbButton.fsState = TBSTATE_ENABLED;
tbButton.fsStyle = TBSTYLE_DROPDOWN | TBSTYLE_NO_DROPDOWN_ARROW | TBSTYLE_AUTOSIZE;
size_t i;
for (i = 0; i < GetMenuCount(); i++)
{
HMENU hPopupMenu = (HMENU) GetMenu(i)->GetHMenu() ;
tbButton.dwData = (DWORD)hPopupMenu;
wxString label = wxStripMenuCodes(GetLabelTop(i));
tbButton.iString = (int) label.c_str();
int position = i;
tbButton.idCommand = NewControlId();
if (!::SendMessage(hCommandBar, TB_INSERTBUTTON, position, (LPARAM)&tbButton))
{
wxLogLastError(wxT("TB_INSERTBUTTON"));
}
}
}
m_hMenu = (WXHMENU) hMenu;
return m_hMenu;
#else
if ( m_hMenu != 0 )
return m_hMenu;
m_hMenu = (WXHMENU)::CreateMenu();
if ( !m_hMenu )
{
wxLogLastError(wxT("CreateMenu"));
}
else
{
size_t count = GetMenuCount(), i;
wxMenuList::iterator it;
for ( i = 0, it = m_menus.begin(); i < count; i++, it++ )
{
if ( !::AppendMenu((HMENU)m_hMenu, MF_POPUP | MF_STRING,
(UINT)(*it)->GetHMenu(),
m_titles[i]) )
{
wxLogLastError(wxT("AppendMenu"));
}
}
}
return m_hMenu;
#endif
}
bool wxTopLevelWindowMotif::Create( wxWindow *parent, wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name )
{
SetName(name);
m_windowStyle = style;
if ( parent )
parent->AddChild(this);
wxTopLevelWindows.Append(this);
m_windowId = ( id > -1 ) ? id : NewControlId();
bool retval = DoCreate( parent, id, title, pos, size, style, name );
if( !retval ) return false;
// Intercept CLOSE messages from the window manager
Widget shell = (Widget)GetShellWidget();
Atom WM_DELETE_WINDOW = XmInternAtom( XtDisplay( shell ),
"WM_DELETE_WINDOW", False );
// Remove and add WM_DELETE_WINDOW so ours is only handler
// This only appears to be necessary for wxDialog, but does not hurt
// for wxFrame
XmRemoveWMProtocols( shell, &WM_DELETE_WINDOW, 1 );
XmAddWMProtocols( shell, &WM_DELETE_WINDOW, 1 );
XmActivateWMProtocol( shell, WM_DELETE_WINDOW );
// Modified Steve Hammes for Motif 2.0
#if (XmREVISION > 1 || XmVERSION > 1)
XmAddWMProtocolCallback( shell, WM_DELETE_WINDOW,
(XtCallbackProc)wxCloseTLWCallback,
(XtPointer)this );
#elif XmREVISION == 1
XmAddWMProtocolCallback( shell, WM_DELETE_WINDOW,
(XtCallbackProc)wxCloseTLWCallback,
(caddr_t)this );
#else
XmAddWMProtocolCallback( shell, WM_DELETE_WINDOW,
(void (*)())wxCloseTLWCallback, (caddr_t)this );
#endif
// This patch come from Torsten Liermann [email protected]
if( XmIsMotifWMRunning( shell ) )
{
int decor = 0 ;
if( !(m_windowStyle & wxNO_BORDER) )
decor |= MWM_DECOR_BORDER;
if( m_windowStyle & wxRESIZE_BORDER )
decor |= MWM_DECOR_RESIZEH;
if( m_windowStyle & wxSYSTEM_MENU )
decor |= MWM_DECOR_MENU;
if( ( m_windowStyle & wxCAPTION ) ||
( m_windowStyle & wxTINY_CAPTION_HORIZ ) ||
( m_windowStyle & wxTINY_CAPTION_VERT ) )
decor |= MWM_DECOR_TITLE;
if( m_windowStyle & wxTHICK_FRAME )
decor |= MWM_DECOR_BORDER;
if( m_windowStyle & wxMINIMIZE_BOX )
decor |= MWM_DECOR_MINIMIZE;
if( m_windowStyle & wxMAXIMIZE_BOX )
decor |= MWM_DECOR_MAXIMIZE;
XtVaSetValues( shell,
XmNmwmDecorations, decor,
NULL );
}
else
{
// This allows non-Motif window managers to support at least the
// no-decorations case.
if( ( m_windowStyle & wxCAPTION ) != wxCAPTION )
XtVaSetValues( shell,
XmNoverrideRedirect, True,
NULL );
}
XtAddEventHandler( (Widget)GetClientWidget(),
ButtonPressMask | ButtonReleaseMask |
PointerMotionMask | KeyPressMask,
False,
wxTLWEventHandler,
(XtPointer)this );
return retval;
}
bool wxSlider::Create(wxWindow *parent,
wxWindowID id,
int value,
int minValue,
int maxValue,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name)
{
wxCHECK_MSG( minValue < maxValue, false,
wxT("Slider minimum must be strictly less than the maximum.") );
// our styles are redundant: wxSL_LEFT/RIGHT imply wxSL_VERTICAL and
// wxSL_TOP/BOTTOM imply wxSL_HORIZONTAL, but for backwards compatibility
// reasons we can't really change it, instead try to infer the orientation
// from the flags given to us here
switch ( style & (wxSL_LEFT | wxSL_RIGHT | wxSL_TOP | wxSL_BOTTOM) )
{
case wxSL_LEFT:
case wxSL_RIGHT:
style |= wxSL_VERTICAL;
break;
case wxSL_TOP:
case wxSL_BOTTOM:
style |= wxSL_HORIZONTAL;
break;
case 0:
// no specific direction, do we have at least the orientation?
if ( !(style & (wxSL_HORIZONTAL | wxSL_VERTICAL)) )
{
// no, choose default
style |= wxSL_BOTTOM | wxSL_HORIZONTAL;
}
};
wxASSERT_MSG( !(style & wxSL_VERTICAL) || !(style & wxSL_HORIZONTAL),
wxT("incompatible slider direction and orientation") );
// initialize everything
if ( !CreateControl(parent, id, pos, size, style, validator, name) )
return false;
// ensure that we have correct values for GetLabelsSize()
m_rangeMin = minValue;
m_rangeMax = maxValue;
// create the labels first, so that our DoGetBestSize() could take them
// into account
//
// note that we could simply create 3 wxStaticTexts here but it could
// result in some observable side effects at wx level (e.g. the parent of
// wxSlider would have 3 more children than expected) and so we prefer not
// to do it like this
if ( m_windowStyle & wxSL_LABELS )
{
m_labels = new wxSubwindows(SliderLabel_Last);
HWND hwndParent = GetHwndOf(parent);
for ( size_t n = 0; n < SliderLabel_Last; n++ )
{
wxWindowIDRef lblid = NewControlId();
HWND wnd = ::CreateWindow
(
wxT("STATIC"),
NULL,
WS_CHILD | WS_VISIBLE | SS_CENTER,
0, 0, 0, 0,
hwndParent,
(HMENU)wxUIntToPtr(lblid.GetValue()),
wxGetInstance(),
NULL
);
m_labels->Set(n, wnd, lblid);
}
m_labels->SetFont(GetFont());
}
// now create the main control too
if ( !MSWCreateControl(TRACKBAR_CLASS, wxEmptyString, pos, size) )
return false;
// and initialize everything
SetRange(minValue, maxValue);
SetValue(value);
SetPageSize( wxMax(1, (maxValue - minValue)/10) );
// we need to position the labels correctly if we have them and if
// SetSize() hadn't been called before (when best size was determined by
// MSWCreateControl()) as in this case they haven't been put in place yet
if ( m_labels && size.x != wxDefaultCoord && size.y != wxDefaultCoord )
{
SetSize(size);
}
return true;
}
void wxMenuBar::Attach(wxFrame *frame)
{
wxMenuBarBase::Attach(frame);
#if defined(WINCE_WITH_COMMANDBAR)
if (!m_hMenu)
this->Create();
if (!m_commandBar)
m_commandBar = (WXHWND) CommandBar_Create(wxGetInstance(), (HWND) frame->GetHWND(), NewControlId());
if (m_commandBar)
{
if (m_hMenu)
{
if (!CommandBar_InsertMenubarEx((HWND) m_commandBar, NULL, (LPTSTR) m_hMenu, 0))
{
wxLogLastError(wxT("CommandBar_InsertMenubarEx"));
}
}
}
#endif
#if wxUSE_ACCEL
RebuildAccelTable();
#endif // wxUSE_ACCEL
}
bool wxMDIParentFrame::Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
m_clientWindow = NULL;
m_currentChild = NULL;
// this style can be used to prevent a window from having the standard MDI
// "Window" menu
if ( style & wxFRAME_NO_WINDOW_MENU )
{
m_windowMenu = (wxMenu *)NULL;
}
else // normal case: we have the window menu, so construct it
{
m_windowMenu = new wxMenu;
m_windowMenu->Append(IDM_WINDOWCASCADE, _("&Cascade"));
m_windowMenu->Append(IDM_WINDOWTILEHOR, _("Tile &Horizontally"));
m_windowMenu->Append(IDM_WINDOWTILEVERT, _("Tile &Vertically"));
m_windowMenu->AppendSeparator();
m_windowMenu->Append(IDM_WINDOWICONS, _("&Arrange Icons"));
m_windowMenu->Append(IDM_WINDOWNEXT, _("&Next"));
m_windowMenu->Append(IDM_WINDOWPREV, _("&Previous"));
}
m_parentFrameActive = true;
if (!parent)
wxTopLevelWindows.Append(this);
SetName(name);
m_windowStyle = style;
if ( parent )
parent->AddChild(this);
if ( id != wxID_ANY )
m_windowId = id;
else
m_windowId = NewControlId();
WXDWORD exflags;
WXDWORD msflags = MSWGetCreateWindowFlags(&exflags);
msflags &= ~WS_VSCROLL;
msflags &= ~WS_HSCROLL;
if ( !wxWindow::MSWCreate(wxMDIFrameClassName,
title,
pos, size,
msflags,
exflags) )
{
return false;
}
// unlike (almost?) all other windows, frames are created hidden
m_isShown = false;
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 wxMDIChildFrame::Create(wxMDIParentFrame *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
long style,
const wxString& name)
{
SetName(name);
if ( id != wxID_ANY )
m_windowId = id;
else
m_windowId = (int)NewControlId();
if ( parent )
{
parent->AddChild(this);
}
int x = pos.x;
int y = pos.y;
int width = size.x;
int height = size.y;
MDICREATESTRUCT mcs;
mcs.szClass = style & wxFULL_REPAINT_ON_RESIZE
? wxMDIChildFrameClassName
: wxMDIChildFrameClassNameNoRedraw;
mcs.szTitle = title;
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 & wxTHICK_FRAME)
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, (LONG)(LPSTR)&mcs);
wxAssociateWinWithHandle((HWND) GetHWND(), this);
return true;
}
bool wxGauge::Create( wxWindowOS2* pParent,
wxWindowID vId,
int nRange,
const wxPoint& rPos,
const wxSize& rSize,
long lStyle,
const wxValidator& rValidator,
const wxString& rsName )
{
int nX = rPos.x;
int nY = rPos.y;
int nWidth = rSize.x;
int nHeight = rSize.y;
long lMsStyle = 0L;
SWP vSwp;
SetName(rsName);
#if wxUSE_VALIDATORS
SetValidator(rValidator);
#endif
if (pParent)
pParent->AddChild(this);
m_backgroundColour.Set(wxString(wxT("LIGHT GREY")));
m_foregroundColour.Set(wxString(wxT("NAVY")));
m_nRangeMax = nRange;
m_nGaugePos = 0;
m_windowStyle = lStyle;
if (vId == wxID_ANY)
m_windowId = (int)NewControlId();
else
m_windowId = vId;
if (m_windowStyle & wxCLIP_SIBLINGS )
lMsStyle |= WS_CLIPSIBLINGS;
//
// OS/2 will use an edit control for this, since there is not a native gauge
// Other choices include using an armless slider but they are more difficult
// to control and manipulate
//
lMsStyle = WS_VISIBLE | ES_MARGIN | ES_LEFT | ES_READONLY;
if (m_windowStyle & wxCLIP_SIBLINGS)
lMsStyle |= WS_CLIPSIBLINGS;
m_hWnd = (WXHWND)::WinCreateWindow( (HWND)GetHwndOf(pParent) // Parent window handle
,WC_ENTRYFIELD // Window class
,(PSZ)NULL // Initial Text
,(ULONG)lMsStyle // Style flags
,0L, 0L, 0L, 0L // Origin -- 0 size
,(HWND)GetHwndOf(pParent) // owner window handle (same as parent
,HWND_TOP // initial z position
,(HMENU)m_windowId // Window identifier
,NULL // Slider control data
,NULL // no Presentation parameters
);
wxAssociateWinWithHandle( m_hWnd
,(wxWindowOS2*)this
);
::WinSetWindowULong(GetHwnd(), QWL_USER, (LONG)this);
fnWndProcGauge = (WXFARPROC)::WinSubclassWindow(m_hWnd, (PFNWP)wxGaugeWndProc);
::WinQueryWindowPos(m_hWnd, &vSwp);
SetXComp(vSwp.x);
SetYComp(vSwp.y);
wxFont* pTextFont = new wxFont( 10
,wxMODERN
,wxNORMAL
,wxNORMAL
);
SetFont(*pTextFont);
if (nWidth == -1L)
nWidth = 50L;
if (nHeight == -1L)
nHeight = 28L;
SetSize( nX
,nY
,nWidth
,nHeight
);
m_nWidth = nWidth; // Save for GetBestSize
m_nHeight = nHeight;
::WinShowWindow((HWND)GetHWND(), TRUE);
delete pTextFont;
return true;
} // end of wxGauge::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") );
// Avoid giving the status bar a themed window
style = (style & ~wxBORDER_MASK) | wxBORDER_NONE;
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 wxRadioBox::Create(wxWindow *parent,
wxWindowID id,
const wxString& title,
const wxPoint& pos,
const wxSize& size,
int n,
const wxString choices[],
int majorDim,
long style,
const wxValidator& val,
const wxString& name)
{
// common initialization
if ( !wxStaticBox::Create(parent, id, title, pos, size, style, name) )
return false;
// the code elsewhere in this file supposes that either wxRA_SPECIFY_COLS
// or wxRA_SPECIFY_ROWS is set, ensure that this is indeed the case
if ( !(style & (wxRA_SPECIFY_ROWS | wxRA_SPECIFY_COLS)) )
style |= wxRA_SPECIFY_COLS;
#if wxUSE_VALIDATORS
SetValidator(val);
#else
wxUnusedVar(val);
#endif // wxUSE_VALIDATORS/!wxUSE_VALIDATORS
// We need an extra one to keep track of the 'dummy' item we
// create to end the radio group, so it will be destroyed and
// it's id will be released. But we want it separate from the
// other buttons since the wxSubwindows will operate on it as
// well and we just want to ignore it until destroying it.
// For instance, we don't want the bounding box of the radio
// buttons to include the dummy button
m_radioButtons = new wxSubwindows(n);
m_radioWidth = new int[n];
m_radioHeight = new int[n];
#if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */
# pragma ivdep
# pragma swp
# pragma unroll
# pragma prefetch
# if 0
# pragma simd noassert
# endif
#endif /* VDM auto patch */
for ( int i = 0; i < n; i++ )
{
m_radioWidth[i] =
m_radioHeight[i] = wxDefaultCoord;
long styleBtn = BS_AUTORADIOBUTTON | WS_TABSTOP | WS_CHILD | WS_VISIBLE;
if ( i == 0 )
styleBtn |= WS_GROUP;
wxWindowIDRef subid = NewControlId();
HWND hwndBtn = ::CreateWindow(wxT("BUTTON"),
choices[i].t_str(),
styleBtn,
0, 0, 0, 0, // will be set in SetSize()
GetHwndOf(parent),
(HMENU)wxUIntToPtr(subid.GetValue()),
wxGetInstance(),
NULL);
if ( !hwndBtn )
{
wxLogLastError(wxT("CreateWindow(radio btn)"));
return false;
}
// Keep track of the subwindow
m_radioButtons->Set(i, hwndBtn, subid);
SubclassRadioButton((WXHWND)hwndBtn);
// Also, make it a subcontrol of this control
m_subControls.Add(subid);
}
// Create a dummy radio control to end the group.
m_dummyId = NewControlId();
m_dummyHwnd = (WXHWND)::CreateWindow(wxT("BUTTON"),
wxEmptyString,
WS_GROUP | BS_AUTORADIOBUTTON | WS_CHILD,
0, 0, 0, 0, GetHwndOf(parent),
(HMENU)wxUIntToPtr(m_dummyId.GetValue()),
wxGetInstance(), NULL);
m_radioButtons->SetFont(GetFont());
SetMajorDim(majorDim == 0 ? n : majorDim, style);
// Select the first radio button if we have any buttons at all.
if ( n > 0 )
SetSelection(0);
SetSize(pos.x, pos.y, size.x, size.y);
// Now that we have items determine what is the best size and set it.
SetInitialSize(size);
// And update all the buttons positions to match it.
const wxSize actualSize = GetSize();
PositionAllButtons(pos.x, pos.y, actualSize.x, actualSize.y);
// The base wxStaticBox class never accepts focus, but we do because giving
// focus to a wxRadioBox actually gives it to one of its buttons, which are
// not visible at wx level and hence are not taken into account by the
// logic in wxControlContainer code.
m_container.EnableSelfFocus();
return true;
}
bool wxSpinCtrl::Create( wxWindow* pParent,
wxWindowID vId,
const wxString& WXUNUSED(rsValue),
const wxPoint& rPos,
const wxSize& rSize,
long lStyle,
int nMin,
int nMax,
int nInitial,
const wxString& rsName )
{
if (vId == wxID_ANY)
m_windowId = NewControlId();
else
m_windowId = vId;
if (pParent)
{
m_backgroundColour = pParent->GetBackgroundColour();
m_foregroundColour = pParent->GetForegroundColour();
}
SetName(rsName);
SetParent(pParent);
m_windowStyle = lStyle;
int lSstyle = 0L;
lSstyle = WS_VISIBLE |
WS_TABSTOP |
SPBS_MASTER | // We use only single field spin buttons
SPBS_NUMERICONLY; // We default to numeric data
if (m_windowStyle & wxCLIP_SIBLINGS )
lSstyle |= WS_CLIPSIBLINGS;
SPBCDATA vCtrlData;
vCtrlData.cbSize = sizeof(SPBCDATA);
vCtrlData.ulTextLimit = 10L;
vCtrlData.lLowerLimit = 0L;
vCtrlData.lUpperLimit = 100L;
vCtrlData.idMasterSpb = vId;
vCtrlData.pHWXCtlData = NULL;
m_hWnd = (WXHWND)::WinCreateWindow( GetWinHwnd(pParent)
,WC_SPINBUTTON
,(PSZ)NULL
,lSstyle
,0L, 0L, 0L, 0L
,GetWinHwnd(pParent)
,HWND_TOP
,(HMENU)vId
,(PVOID)&vCtrlData
,NULL
);
if (m_hWnd == 0)
{
return false;
}
m_hWndBuddy = m_hWnd; // One in the same for OS/2
if(pParent)
pParent->AddChild((wxSpinButton *)this);
SetFont(*wxSMALL_FONT);
SetXComp(0);
SetYComp(0);
SetSize( rPos.x, rPos.y, rSize.x, rSize.y );
SetRange(nMin, nMax);
SetValue(nInitial);
//
// For OS/2 we'll just set our handle into our long data
//
wxAssociateWinWithHandle( m_hWnd
,(wxWindowOS2*)this
);
::WinSetWindowULong(GetHwnd(), QWL_USER, (LONG)this);
fnWndProcSpinCtrl = (WXFARPROC)::WinSubclassWindow(m_hWnd, (PFNWP)wxSpinCtrlWndProc);
m_svAllSpins.Add(this);
return true;
} // end of wxSpinCtrl::Create
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_backgroundColour = parent->GetBackgroundColour();
m_foregroundColour = parent->GetForegroundColour();
m_windowStyle = style;
if ( style & wxBU_AUTODRAW )
{
m_marginX = wxDEFAULT_BUTTON_MARGIN;
m_marginY = wxDEFAULT_BUTTON_MARGIN;
}
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);
SetBestSize(size);
return true;
}
WXHMENU wxMenuBar::Create()
{
// Note: this doesn't work at all on Smartphone,
// since you have to use resources.
// We'll have to find another way to add a menu
// by changing/adding menu items to an existing menu.
#if defined(WINCE_WITHOUT_COMMANDBAR)
if ( m_hMenu != 0 )
return m_hMenu;
wxToolMenuBar * const bar = static_cast<wxToolMenuBar *>(GetToolBar());
if ( !bar )
return NULL;
HWND hCommandBar = GetHwndOf(bar);
// notify comctl32.dll about the version of the headers we use before using
// any other TB_XXX messages
SendMessage(hCommandBar, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
TBBUTTON tbButton;
wxZeroMemory(tbButton);
tbButton.iBitmap = I_IMAGENONE;
tbButton.fsState = TBSTATE_ENABLED;
tbButton.fsStyle = TBSTYLE_DROPDOWN |
TBSTYLE_NO_DROPDOWN_ARROW |
TBSTYLE_AUTOSIZE;
for ( unsigned i = 0; i < GetMenuCount(); i++ )
{
HMENU hPopupMenu = (HMENU) GetMenu(i)->GetHMenu();
tbButton.dwData = (DWORD)hPopupMenu;
wxString label = wxStripMenuCodes(GetMenuLabel(i));
tbButton.iString = (int) wxMSW_CONV_LPCTSTR(label);
tbButton.idCommand = NewControlId();
if ( !::SendMessage(hCommandBar, TB_INSERTBUTTON, i, (LPARAM)&tbButton) )
{
wxLogLastError(wxT("TB_INSERTBUTTON"));
}
}
m_hMenu = bar->GetHMenu();
return m_hMenu;
#else // !__WXWINCE__
if ( m_hMenu != 0 )
return m_hMenu;
m_hMenu = (WXHMENU)::CreateMenu();
if ( !m_hMenu )
{
wxLogLastError(wxT("CreateMenu"));
}
else
{
for ( wxMenuList::iterator it = m_menus.begin();
it != m_menus.end();
++it )
{
if ( !::AppendMenu((HMENU)m_hMenu, MF_POPUP | MF_STRING,
(UINT_PTR)(*it)->GetHMenu(),
(*it)->GetTitle().t_str()) )
{
wxLogLastError(wxT("AppendMenu"));
}
}
}
return m_hMenu;
#endif // __WXWINCE__/!__WXWINCE__
}
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;
// 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;
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
