wxHitTest wxScrollBar::HitTestBar(const wxPoint& pt) const
{
// we only need to work with either x or y coord depending on the
// orientation, choose one (but still check the other one to verify if the
// mouse is in the window at all)
const wxSize sizeArrowSB = m_renderer->GetScrollbarArrowSize();
wxCoord coord, sizeArrow, sizeTotal;
wxSize size = GetSize();
if ( GetWindowStyle() & wxVERTICAL )
{
if ( pt.x < 0 || pt.x > size.x )
return wxHT_NOWHERE;
coord = pt.y;
sizeArrow = sizeArrowSB.y;
sizeTotal = size.y;
}
else // horizontal
{
if ( pt.y < 0 || pt.y > size.y )
return wxHT_NOWHERE;
coord = pt.x;
sizeArrow = sizeArrowSB.x;
sizeTotal = size.x;
}
// test for the arrows first as it's faster
if ( coord < 0 || coord > sizeTotal )
{
return wxHT_NOWHERE;
}
else if ( coord < sizeArrow )
{
return wxHT_SCROLLBAR_ARROW_LINE_1;
}
else if ( coord > sizeTotal - sizeArrow )
{
return wxHT_SCROLLBAR_ARROW_LINE_2;
}
else
{
// calculate the thumb position in pixels
sizeTotal -= 2*sizeArrow;
wxCoord thumbStart, thumbEnd;
int range = GetRange();
if ( !range )
{
// clicking the scrollbar without range has no effect
return wxHT_NOWHERE;
}
else
{
GetScrollBarThumbSize(sizeTotal,
GetThumbPosition(),
GetThumbSize(),
range,
&thumbStart,
&thumbEnd);
}
// now compare with the thumb position
coord -= sizeArrow;
if ( coord < thumbStart )
return wxHT_SCROLLBAR_BAR_1;
else if ( coord > thumbEnd )
return wxHT_SCROLLBAR_BAR_2;
else
return wxHT_SCROLLBAR_THUMB;
}
}
// Lay out controls
void wxBookCtrlBase::DoSize()
{
if ( !m_bookctrl )
{
// we're not fully created yet or OnSize() should be hidden by derived class
return;
}
if (GetSizer())
Layout();
else
{
// resize controller and the page area to fit inside our new size
const wxSize sizeClient( GetClientSize() ),
sizeBorder( m_bookctrl->GetSize() - m_bookctrl->GetClientSize() ),
sizeCtrl( GetControllerSize() );
m_bookctrl->SetClientSize( sizeCtrl.x - sizeBorder.x, sizeCtrl.y - sizeBorder.y );
// if this changes the visibility of the scrollbars the best size changes, relayout in this case
wxSize sizeCtrl2 = GetControllerSize();
if ( sizeCtrl != sizeCtrl2 )
{
wxSize sizeBorder2 = m_bookctrl->GetSize() - m_bookctrl->GetClientSize();
m_bookctrl->SetClientSize( sizeCtrl2.x - sizeBorder2.x, sizeCtrl2.y - sizeBorder2.y );
}
const wxSize sizeNew = m_bookctrl->GetSize();
wxPoint posCtrl;
switch ( GetWindowStyle() & wxBK_ALIGN_MASK )
{
default:
wxFAIL_MSG( wxT("unexpected alignment") );
// fall through
case wxBK_TOP:
case wxBK_LEFT:
// posCtrl is already ok
break;
case wxBK_BOTTOM:
posCtrl.y = sizeClient.y - sizeNew.y;
break;
case wxBK_RIGHT:
posCtrl.x = sizeClient.x - sizeNew.x;
break;
}
if ( m_bookctrl->GetPosition() != posCtrl )
m_bookctrl->Move(posCtrl);
}
// resize all pages to fit the new control size
const wxRect pageRect = GetPageRect();
const unsigned pagesCount = m_pages.GetCount();
for ( unsigned int i = 0; i < pagesCount; ++i )
{
wxWindow * const page = m_pages[i];
if ( !page )
{
wxASSERT_MSG( AllowNullPage(),
wxT("Null page in a control that does not allow null pages?") );
continue;
}
page->SetSize(pageRect);
}
}
int WINAPI WinMain( HINSTANCE hinstance,
HINSTANCE hprevinstance,
LPSTR lpcmdline,
int ncmdshow)
{
// this is the winmain function
WNDCLASS winclass; // this will hold the class we create
HWND hwnd; // generic window handle
MSG msg; // generic message
HDC hdc; // generic dc
PAINTSTRUCT ps; // generic paintstruct
// first fill in the window class stucture
winclass.style = CS_DBLCLKS | CS_OWNDC |
CS_HREDRAW | CS_VREDRAW;
winclass.lpfnWndProc = WindowProc;
winclass.cbClsExtra = 0;
winclass.cbWndExtra = 0;
winclass.hInstance = hinstance;
winclass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
winclass.hCursor = LoadCursor(NULL, IDC_ARROW);
winclass.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
winclass.lpszMenuName = NULL;
winclass.lpszClassName = WINDOW_CLASS_NAME;
// register the window class
if (!RegisterClass(&winclass))
return(0);
// create the window, note the test to see if WINDOWED_APP is
// true to select the appropriate window flags
if (!(hwnd = CreateWindow(WINDOW_CLASS_NAME, // class
WINDOW_TITLE, // title
(WINDOWED_APP ? (WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION) : (WS_POPUP | WS_VISIBLE)),
0,0, // x,y
WINDOW_WIDTH, // width
WINDOW_HEIGHT, // height
NULL, // handle to parent
NULL, // handle to menu
hinstance,// instance
NULL))) // creation parms
return(0);
// save the window handle and instance in a global
main_window_handle = hwnd;
main_instance = hinstance;
// resize the window so that client is really width x height
if (WINDOWED_APP)
{
// now resize the window, so the client area is the actual size requested
// since there may be borders and controls if this is going to be a windowed app
// if the app is not windowed then it won't matter
RECT window_rect = {0,0,WINDOW_WIDTH-1,WINDOW_HEIGHT-1};
// make the call to adjust window_rect
AdjustWindowRectEx(&window_rect,
GetWindowStyle(main_window_handle),
GetMenu(main_window_handle) != NULL,
GetWindowExStyle(main_window_handle));
// save the global client offsets, they are needed in DDraw_Flip()
window_client_x0 = -window_rect.left;
window_client_y0 = -window_rect.top;
// now resize the window with a call to MoveWindow()
MoveWindow(main_window_handle,
0, // x position
0, // y position
window_rect.right - window_rect.left, // width
window_rect.bottom - window_rect.top, // height
FALSE);
// show the window, so there's no garbage on first render
ShowWindow(main_window_handle, SW_SHOW);
} // end if windowed
// perform all game console specific initialization
Game_Init();
// disable CTRL-ALT_DEL, ALT_TAB, comment this line out
// if it causes your system to crash
SystemParametersInfo(SPI_SCREENSAVERRUNNING, TRUE, NULL, 0);
// enter main event loop
while(1)
{
if (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
// test if this is a quit
if (msg.message == WM_QUIT)
break;
// translate any accelerator keys
TranslateMessage(&msg);
// send the message to the window proc
DispatchMessage(&msg);
} // end if
// main game processing goes here
Game_Main();
} // end while
// shutdown game and release all resources
Game_Shutdown();
// enable CTRL-ALT_DEL, ALT_TAB, comment this line out
// if it causes your system to crash
SystemParametersInfo(SPI_SCREENSAVERRUNNING, FALSE, NULL, 0);
// return to Windows like this
return(msg.wParam);
} // end WinMain
/* Set the final window size, set the window text and icon, and then unhide the
* window. */
void GraphicsWindow::CreateGraphicsWindow( const VideoModeParams &p, bool bForceRecreateWindow )
{
g_CurrentParams = p;
// Adjust g_CurrentParams to reflect the actual display settings.
AdjustVideoModeParams( g_CurrentParams );
if( g_hWndMain == NULL || bForceRecreateWindow )
{
int iWindowStyle = GetWindowStyle( p.windowed );
AppInstance inst;
HWND hWnd = CreateWindow( g_sClassName, "app", iWindowStyle,
0, 0, 0, 0, NULL, NULL, inst, NULL );
if( hWnd == NULL )
RageException::Throw( "%s", werr_ssprintf( GetLastError(), "CreateWindow" ).c_str() );
/* If an old window exists, transfer focus to the new window before
* deleting it, or some other window may temporarily get focus, which
* can cause it to be resized. */
if( g_hWndMain != NULL )
{
// While we change to the new window, don't do ChangeDisplaySettings in WM_ACTIVATE.
g_bRecreatingVideoMode = true;
SetForegroundWindow( hWnd );
g_bRecreatingVideoMode = false;
GraphicsWindow::DestroyGraphicsWindow();
}
g_hWndMain = hWnd;
CrashHandler::SetForegroundWindow( g_hWndMain );
g_HDC = GetDC( g_hWndMain );
}
// Update the window title.
do
{
if( m_bWideWindowClass )
{
if( SetWindowText( g_hWndMain, ConvertUTF8ToACP(p.sWindowTitle).c_str() ) )
break;
}
SetWindowTextA( g_hWndMain, ConvertUTF8ToACP(p.sWindowTitle) );
} while(0);
// Update the window icon.
if( g_hIcon != NULL )
{
SetClassLong( g_hWndMain, GCL_HICON, (LONG) LoadIcon(NULL,IDI_APPLICATION) );
DestroyIcon( g_hIcon );
g_hIcon = NULL;
}
g_hIcon = IconFromFile( p.sIconFile );
if( g_hIcon != NULL )
SetClassLong( g_hWndMain, GCL_HICON, (LONG) g_hIcon );
/* The window style may change as a result of switching to or from fullscreen;
* apply it. Don't change the WS_VISIBLE bit. */
int iWindowStyle = GetWindowStyle( p.windowed );
if( GetWindowLong( g_hWndMain, GWL_STYLE ) & WS_VISIBLE )
iWindowStyle |= WS_VISIBLE;
SetWindowLong( g_hWndMain, GWL_STYLE, iWindowStyle );
RECT WindowRect;
SetRect( &WindowRect, 0, 0, p.width, p.height );
AdjustWindowRect( &WindowRect, iWindowStyle, FALSE );
//LOG->Warn( "w = %d, h = %d", p.width, p.height );
const int iWidth = WindowRect.right - WindowRect.left;
const int iHeight = WindowRect.bottom - WindowRect.top;
// If windowed, center the window.
int x = 0, y = 0;
if( p.windowed )
{
x = GetSystemMetrics(SM_CXSCREEN)/2-iWidth/2;
y = GetSystemMetrics(SM_CYSCREEN)/2-iHeight/2;
}
/* Move and resize the window. SWP_FRAMECHANGED causes the above
* SetWindowLong to take effect. */
if( !SetWindowPos( g_hWndMain, HWND_NOTOPMOST, x, y, iWidth, iHeight, SWP_FRAMECHANGED|SWP_SHOWWINDOW ) )
LOG->Warn( "%s", werr_ssprintf( GetLastError(), "SetWindowPos" ).c_str() );
SetForegroundWindow( g_hWndMain );
/* Pump messages quickly, to make sure the window is completely set up.
* If we don't do this, then starting up in a D3D fullscreen window may
* cause all other windows on the system to be resized. */
MSG msg;
while( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
{
GetMessage( &msg, NULL, 0, 0 );
DispatchMessage( &msg );
}
}
void CBasicWindow::GetPosition(int *pLeft,int *pTop,int *pWidth,int *pHeight) const
{
if (m_hwnd!=NULL) {
RECT rc;
if ((GetWindowStyle() & WS_CHILD)!=0) {
::GetWindowRect(m_hwnd,&rc);
::MapWindowPoints(NULL,::GetParent(m_hwnd),reinterpret_cast<POINT*>(&rc),2);
if (pLeft)
*pLeft=rc.left;
if (pTop)
*pTop=rc.top;
if (pWidth)
*pWidth=rc.right-rc.left;
if (pHeight)
*pHeight=rc.bottom-rc.top;
} else {
WINDOWPLACEMENT wp;
wp.length=sizeof(WINDOWPLACEMENT);
::GetWindowPlacement(m_hwnd,&wp);
if (wp.showCmd==SW_SHOWNORMAL) {
// 通常表示時はGetWindowRectの方が座標変換の問題がないので確実
::GetWindowRect(m_hwnd,&rc);
} else {
/*
WS_EX_TOOLWINDOWスタイルが付いていない場合は、
rcNormalPositionはワークスペース座標になる(仕様が意味不明...)
*/
if ((GetWindowExStyle() & WS_EX_TOOLWINDOW)==0) {
/*
ワークスペース座標をスクリーン座標に変換
しかし、マルチモニタの時はどのモニタのワークスペース座標が
基準になっているのか不明...
*/
HMONITOR hMonitor=::MonitorFromWindow(m_hwnd,MONITOR_DEFAULTTONEAREST);
MONITORINFO mi;
mi.cbSize=sizeof(MONITORINFO);
::GetMonitorInfo(hMonitor,&mi);
::OffsetRect(&wp.rcNormalPosition,
mi.rcWork.left-mi.rcMonitor.left,
mi.rcWork.top-mi.rcMonitor.top);
}
rc=wp.rcNormalPosition;
}
if (pLeft)
*pLeft=rc.left;
if (pTop)
*pTop=rc.top;
if (pWidth)
*pWidth=rc.right-rc.left;
if (pHeight)
*pHeight=rc.bottom-rc.top;
}
} else {
if (pLeft)
*pLeft=m_WindowPosition.Left;
if (pTop)
*pTop=m_WindowPosition.Top;
if (pWidth)
*pWidth=m_WindowPosition.Width;
if (pHeight)
*pHeight=m_WindowPosition.Height;
}
}
bool
wxProgressDialog::Update(int value, const wxString& newmsg, bool *skip)
{
wxASSERT_MSG( value == -1 || m_gauge, wxT("cannot update non existent dialog") );
#ifdef __WXMSW__
value /= m_factor;
#endif // __WXMSW__
wxASSERT_MSG( value <= m_maximum, wxT("invalid progress value") );
if ( m_gauge )
m_gauge->SetValue(value);
UpdateMessage(newmsg);
if ( (m_elapsed || m_remaining || m_estimated) && (value != 0) )
{
unsigned long elapsed = wxGetCurrentTime() - m_timeStart;
if ( m_last_timeupdate < elapsed
|| value == m_maximum
)
{
m_last_timeupdate = elapsed;
unsigned long estimated = m_break +
(unsigned long)(( (double) (elapsed-m_break) * m_maximum ) / ((double)value)) ;
if ( estimated > m_display_estimated
&& m_ctdelay >= 0
)
{
++m_ctdelay;
}
else if ( estimated < m_display_estimated
&& m_ctdelay <= 0
)
{
--m_ctdelay;
}
else
{
m_ctdelay = 0;
}
if ( m_ctdelay >= m_delay // enough confirmations for a higher value
|| m_ctdelay <= (m_delay*-1) // enough confirmations for a lower value
|| value == m_maximum // to stay consistent
|| elapsed > m_display_estimated // to stay consistent
|| ( elapsed > 0 && elapsed < 4 ) // additional updates in the beginning
)
{
m_display_estimated = estimated;
m_ctdelay = 0;
}
}
long display_remaining = m_display_estimated - elapsed;
if ( display_remaining < 0 )
{
display_remaining = 0;
}
SetTimeLabel(elapsed, m_elapsed);
SetTimeLabel(m_display_estimated, m_estimated);
SetTimeLabel(display_remaining, m_remaining);
}
if ( value == m_maximum )
{
if ( m_state == Finished )
{
// ignore multiple calls to Update(m_maximum): it may sometimes be
// troublesome to ensure that Update() is not called twice with the
// same value (e.g. because of the rounding errors) and if we don't
// return now we're going to generate asserts below
return true;
}
// so that we return true below and that out [Cancel] handler knew what
// to do
m_state = Finished;
if( !(GetWindowStyle() & wxPD_AUTO_HIDE) )
{
EnableClose();
DisableSkip();
#if defined(__WXMSW__) && !defined(__WXUNIVERSAL__)
EnableCloseButton();
#endif // __WXMSW__
if ( newmsg.empty() )
{
// also provide the finishing message if the application didn't
m_msg->SetLabel(_("Done."));
}
wxYieldIfNeeded() ;
(void)ShowModal();
}
else // auto hide
{
// reenable other windows before hiding this one because otherwise
// Windows wouldn't give the focus back to the window which had
// been previously focused because it would still be disabled
ReenableOtherWindows();
Hide();
}
}
else // not at maximum yet
{
return DoAfterUpdate(skip);
}
// update the display in case yielding above didn't do it
Update();
return m_state != Canceled;
}
wxSize wxSpinButton::DoGetBestSize() const
{
return GetBestSpinnerSize( (GetWindowStyle() & wxSP_VERTICAL) != 0 );
}
void wxWindow::SetScrollbar(int orient,
int pos,
int pageSize,
int range,
bool refresh)
{
#if wxUSE_SCROLLBAR
wxASSERT_MSG( pageSize <= range,
wxT("page size can't be greater than range") );
bool hasClientSizeChanged = false;
wxScrollBar *scrollbar = GetScrollbar(orient);
if ( range && (pageSize < range) )
{
if ( !scrollbar )
{
// create it
#if wxUSE_TWO_WINDOWS
SetInsertIntoMain( true );
#endif
scrollbar = new wxWindowScrollBar(this, wxID_ANY,
wxDefaultPosition, wxDefaultSize,
orient & wxVERTICAL ? wxSB_VERTICAL
: wxSB_HORIZONTAL);
#if wxUSE_TWO_WINDOWS
SetInsertIntoMain( false );
#endif
if ( orient & wxVERTICAL )
m_scrollbarVert = scrollbar;
else
m_scrollbarHorz = scrollbar;
// the client area diminished as we created a scrollbar
hasClientSizeChanged = true;
PositionScrollbars();
}
else if ( GetWindowStyle() & wxALWAYS_SHOW_SB )
{
// we might have disabled it before
scrollbar->Enable();
}
scrollbar->SetScrollbar(pos, pageSize, range, pageSize, refresh);
}
else // no range means no scrollbar
{
if ( scrollbar )
{
// wxALWAYS_SHOW_SB only applies to the vertical scrollbar
if ( (orient & wxVERTICAL) && (GetWindowStyle() & wxALWAYS_SHOW_SB) )
{
// just disable the scrollbar
scrollbar->SetScrollbar(pos, pageSize, range, pageSize, refresh);
scrollbar->Disable();
}
else // really remove the scrollbar
{
delete scrollbar;
if ( orient & wxVERTICAL )
m_scrollbarVert = NULL;
else
m_scrollbarHorz = NULL;
// the client area increased as we removed a scrollbar
hasClientSizeChanged = true;
// the size of the remaining scrollbar must be adjusted
if ( m_scrollbarHorz || m_scrollbarVert )
{
PositionScrollbars();
}
}
}
}
// give the window a chance to relayout
if ( hasClientSizeChanged )
{
#if wxUSE_TWO_WINDOWS
wxWindowNative::SetSize( GetSize() );
#else
wxSizeEvent event(GetSize());
(void)GetEventHandler()->ProcessEvent(event);
#endif
}
#else
wxUnusedVar(orient);
wxUnusedVar(pos);
wxUnusedVar(pageSize);
wxUnusedVar(range);
wxUnusedVar(refresh);
#endif // wxUSE_SCROLLBAR
}
bool wxSpinCtrl::Create(wxWindow *parent,
wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
long style,
int min, int max, int initial,
const wxString& name)
{
// this should be in ctor/init function but I don't want to add one to 2.8
// to avoid problems with default ctor which can be inlined in the user
// code and so might not get this fix without recompilation
m_oldValue = INT_MIN;
// before using DoGetBestSize(), have to set style to let the base class
// know whether this is a horizontal or vertical control (we're always
// vertical)
style |= wxSP_VERTICAL;
if ( (style & wxBORDER_MASK) == wxBORDER_DEFAULT )
#ifdef __WXWINCE__
style |= wxBORDER_SIMPLE;
#else
style |= wxBORDER_SUNKEN;
#endif
SetWindowStyle(style);
WXDWORD exStyle = 0;
WXDWORD msStyle = MSWGetStyle(GetWindowStyle(), & exStyle) ;
// calculate the sizes: the size given is the toal size for both controls
// and we need to fit them both in the given width (height is the same)
wxSize sizeText(size), sizeBtn(size);
sizeBtn.x = wxSpinButton::DoGetBestSize().x;
if ( sizeText.x <= 0 )
{
// 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(_T("not enough space for wxSpinCtrl!"));
}
wxPoint posBtn(pos);
posBtn.x += sizeText.x + MARGIN_BETWEEN;
// we must create the text 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
_T("EDIT"), // 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;
}
// create the spin button
if ( !wxSpinButton::Create(parent, id, posBtn, sizeBtn, style, name) )
{
return false;
}
wxSpinButtonBase::SetRange(min, max);
// subclass the text ctrl to be able to intercept some events
wxSetWindowUserData(GetBuddyHwnd(), this);
m_wndProcBuddy = (WXFARPROC)wxSetWindowProc(GetBuddyHwnd(),
wxBuddyTextWndProc);
// 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 text window with the spin button
(void)::SendMessage(GetHwnd(), UDM_SETBUDDY, (WPARAM)m_hwndBuddy, 0);
SetValue(initial);
// Set the range in the native control
SetRange(min, max);
if ( !value.empty() )
{
SetValue(value);
m_oldValue = (int) wxAtol(value);
}
else
{
SetValue(wxString::Format(wxT("%d"), initial));
m_oldValue = initial;
}
// do it after finishing with m_hwndBuddy creation to avoid generating
// initial wxEVT_COMMAND_TEXT_UPDATED message
ms_allSpins.Add(this);
return true;
}
void wxGenericHyperlinkCtrl::OnRightUp(wxMouseEvent& event)
{
if( GetWindowStyle() & wxHL_CONTEXTMENU )
if ( GetLabelRect().Contains(event.GetPosition()) )
DoContextMenu(wxPoint(event.m_x, event.m_y));
}
void wxNotebook::OnPaint(wxPaintEvent& WXUNUSED(event))
{
wxPaintDC dc(this);
wxMemoryDC memdc;
RECT rc;
::GetClientRect(GetHwnd(), &rc);
wxBitmap bmp(rc.right, rc.bottom);
memdc.SelectObject(bmp);
const wxLayoutDirection dir = dc.GetLayoutDirection();
memdc.SetLayoutDirection(dir);
const HDC hdc = GetHdcOf(memdc);
// The drawing logic of the native tab control is absolutely impenetrable
// but observation shows that in the current Windows versions (XP and 7),
// the tab control always erases its entire background in its window proc
// when the tabs are top-aligned but does not do it when the tabs are in
// any other position.
//
// This means that we can't rely on our background colour being used for
// the blank area in the tab row because this doesn't work in the default
// top-aligned case, hence the hack with ExtFloodFill() below. But it also
// means that we still do need to erase the DC to account for the other
// cases.
//
// Moreover, just in case some very old or very new (or even future,
// although it seems unlikely that this is ever going to change by now)
// version of Windows didn't do it like this, do both things in all cases
// instead of optimizing away the one of them which doesn't do anything for
// the effectively used tab orientation -- better safe than fast.
// Notice that we use our own background here, not the background used for
// the pages, because the tab row background must blend with the parent and
// so the background colour inherited from it (if any) must be used.
AutoHBRUSH hbr(wxColourToRGB(GetBackgroundColour()));
::FillRect(hdc, &rc, hbr);
MSWDefWindowProc(WM_PAINT, (WPARAM)hdc, 0);
// At least for the top-aligned tabs, our background colour was overwritten
// and so we now replace the default background with our colour. This is
// horribly inefficient, of course, but seems to be the only way to do it.
if ( UseBgCol() )
{
SelectInHDC selectBrush(hdc, hbr);
// Find the point which must contain the default background colour:
// this is a hack, of course, but using this point "close" to the
// corner seems to work fine in practice.
int x = 0,
y = 0;
switch ( GetWindowStyle() & wxBK_ALIGN_MASK )
{
case wxBK_TOP:
x = rc.right - 2;
y = 2;
break;
case wxBK_BOTTOM:
x = rc.right - 2;
y = rc.bottom - 2;
break;
case wxBK_LEFT:
x = 2;
y = rc.bottom - 2;
break;
case wxBK_RIGHT:
x = 2;
y = rc.bottom - 2;
break;
}
::ExtFloodFill(hdc, x, y, ::GetSysColor(COLOR_BTNFACE), FLOODFILLSURFACE);
}
// For some reason in RTL mode, source offset has to be -1, otherwise the
// right border (physical) remains unpainted.
const wxCoord ofs = dir == wxLayout_RightToLeft ? -1 : 0;
dc.Blit(ofs, 0, rc.right, rc.bottom, &memdc, ofs, 0);
}
//-----------------------------------------------------------------------------
// Name: CreateWindowedDisplay()
// Desc:
//-----------------------------------------------------------------------------
HRESULT CDisplay::CreateWindowedDisplay( HWND hWnd, DWORD dwWidth, DWORD dwHeight )
{
HRESULT hr;
// Cleanup anything from a previous call
DestroyObjects();
// DDraw stuff begins here
if( FAILED( hr = DirectDrawCreateEx( NULL, (VOID**)&m_pDD,
IID_IDirectDraw7, NULL ) ) )
return E_FAIL;
// Set cooperative level
hr = m_pDD->SetCooperativeLevel( hWnd, DDSCL_NORMAL );
if( FAILED(hr) )
return E_FAIL;
RECT rcWork;
RECT rc;
DWORD dwStyle;
// If we are still a WS_POPUP window we should convert to a normal app
// window so we look like a windows app.
dwStyle = GetWindowStyle( hWnd );
dwStyle &= ~WS_POPUP;
dwStyle |= WS_OVERLAPPED | WS_CAPTION | WS_THICKFRAME | WS_MINIMIZEBOX;
SetWindowLong( hWnd, GWL_STYLE, dwStyle );
// Aet window size
SetRect( &rc, 0, 0, dwWidth, dwHeight );
AdjustWindowRectEx( &rc, GetWindowStyle(hWnd), GetMenu(hWnd) != NULL,
GetWindowExStyle(hWnd) );
SetWindowPos( hWnd, NULL, 0, 0, rc.right-rc.left, rc.bottom-rc.top,
SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE );
SetWindowPos( hWnd, HWND_NOTOPMOST, 0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE );
// Make sure our window does not hang outside of the work area
SystemParametersInfo( SPI_GETWORKAREA, 0, &rcWork, 0 );
GetWindowRect( hWnd, &rc );
if( rc.left < rcWork.left ) rc.left = rcWork.left;
if( rc.top < rcWork.top ) rc.top = rcWork.top;
SetWindowPos( hWnd, NULL, rc.left, rc.top, 0, 0,
SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
LPDIRECTDRAWCLIPPER pcClipper;
// Create the primary surface
DDSURFACEDESC2 ddsd;
ZeroMemory( &ddsd, sizeof( ddsd ) );
ddsd.dwSize = sizeof( ddsd );
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
if( FAILED( m_pDD->CreateSurface( &ddsd, &m_pddsFrontBuffer, NULL ) ) )
return E_FAIL;
// Create the backbuffer surface
ddsd.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
ddsd.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
ddsd.dwWidth = dwWidth;
ddsd.dwHeight = dwHeight;
if( FAILED( hr = m_pDD->CreateSurface( &ddsd, &m_pddsBackBuffer, NULL ) ) )
return E_FAIL;
if( FAILED( hr = m_pDD->CreateClipper( 0, &pcClipper, NULL ) ) )
return E_FAIL;
if( FAILED( hr = pcClipper->SetHWnd( 0, hWnd ) ) )
{
pcClipper->Release();
return E_FAIL;
}
if( FAILED( hr = m_pddsFrontBuffer->SetClipper( pcClipper ) ) )
{
pcClipper->Release();
return E_FAIL;
}
// Done with clipper
pcClipper->Release();
m_hWnd = hWnd;
m_bWindowed = TRUE;
UpdateBounds();
return S_OK;
}
static int CoolBarCtrlProc (HWND hWnd, int message, WPARAM wParam, LPARAM lParam)
{
HDC hdc;
PCOOLBARCTRL TbarData;
PCOOLBARITEMDATA pTbid;
switch (message) {
case MSG_CREATE:
{
DWORD data;
DWORD dwStyle;
const char* caption;
if ((TbarData = (COOLBARCTRL*) calloc (1, sizeof (COOLBARCTRL))) == NULL)
return 1;
TbarData->nCount = 0;
TbarData->head = TbarData->tail = NULL;
TbarData->BackBmp = NULL;
TbarData->iSel = -1;
TbarData->iMvOver = -1;
TbarData->ShowHint = TRUE;
TbarData->hToolTip = 0;
ExcludeWindowStyle (hWnd, WS_BORDER);
dwStyle = GetWindowStyle (hWnd);
if (dwStyle & CBS_BMP_32X32) {
TbarData->ItemWidth = 32;
TbarData->ItemHeight = 32;
}
else if (dwStyle & CBS_BMP_CUSTOM) {
data = GetWindowAdditionalData (hWnd);
TbarData->ItemWidth = LOWORD (data);
TbarData->ItemHeight = HIWORD (data);
}
else {
TbarData->ItemWidth = 16;
TbarData->ItemHeight = 16;
}
caption = GetWindowCaption (hWnd);
if ((dwStyle & CBS_USEBKBMP) && caption [0]) {
TbarData->BackBmp = (BITMAP*)calloc (1, sizeof (BITMAP));
if (LoadBitmap (HDC_SCREEN, TbarData->BackBmp, caption) < 0) {
free (TbarData->BackBmp);
TbarData->BackBmp = NULL;
break;
}
}
SetWindowAdditionalData2 (hWnd, (DWORD)TbarData);
}
break;
case MSG_DESTROY:
{
COOLBARITEMDATA* unloaddata, *tmp;
TbarData = (PCOOLBARCTRL) GetWindowAdditionalData2(hWnd);
if (TbarData->hToolTip != 0) {
DestroyToolTipWin (TbarData->hToolTip);
TbarData->hToolTip = 0;
}
if (TbarData->BackBmp) {
UnloadBitmap (TbarData->BackBmp);
free (TbarData->BackBmp);
}
unloaddata = TbarData->head;
while (unloaddata) {
tmp = unloaddata->next;
free (unloaddata);
unloaddata = tmp;
}
free (TbarData);
}
break;
case MSG_SIZECHANGING:
{
const RECT* rcExpect = (const RECT*)wParam;
RECT* rcResult = (RECT*)lParam;
TbarData = (PCOOLBARCTRL) GetWindowAdditionalData2(hWnd);
rcResult->left = rcExpect->left;
rcResult->top = rcExpect->top;
rcResult->right = rcExpect->right;
rcResult->bottom = rcExpect->top + TbarData->ItemHeight + 8;
return 0;
}
case MSG_SIZECHANGED:
{
RECT* rcWin = (RECT*)wParam;
RECT* rcClient = (RECT*)lParam;
*rcClient = *rcWin;
return 1;
}
case MSG_NCPAINT:
return 0;
case MSG_PAINT:
{
TbarData = (PCOOLBARCTRL) GetWindowAdditionalData2(hWnd);
hdc = BeginPaint (hWnd);
DrawCoolBox (hWnd, hdc, TbarData);
EndPaint (hWnd, hdc);
return 0;
}
case CBM_ADDITEM:
{
COOLBARITEMINFO* TbarInfo = NULL;
COOLBARITEMDATA* ptemp;
RECT rc;
TbarData = (PCOOLBARCTRL) GetWindowAdditionalData2 (hWnd);
TbarInfo = (COOLBARITEMINFO*) lParam;
if (!(ptemp = (COOLBARITEMDATA*)calloc (1, sizeof (COOLBARITEMDATA)))) {
return -1;
}
GetClientRect (hWnd, &rc);
ptemp->id = TbarInfo->id;
ptemp->Disable = 0;
ptemp->ItemType = TbarInfo->ItemType;
if (TbarInfo->ItemHint) {
strncpy (ptemp->Hint, TbarInfo->ItemHint, LEN_HINT);
ptemp->Hint [LEN_HINT] = '\0';
}
else
ptemp->Hint [0] = '\0';
if (TbarInfo->Caption) {
strncpy (ptemp->Caption, TbarInfo->Caption, LEN_TITLE);
ptemp->Caption [LEN_TITLE] = '\0';
}
else
ptemp->Caption [0] = '\0';
ptemp->Bmp = TbarInfo->Bmp;
set_item_rect (hWnd, TbarData, ptemp);
ptemp->next = NULL;
if (TbarData->nCount == 0) {
TbarData->head = TbarData->tail = ptemp;
}
else if (TbarData->nCount > 0) {
TbarData->tail->next = ptemp;
TbarData->tail = ptemp;
}
ptemp->insPos = TbarData->nCount;
TbarData->nCount++;
InvalidateRect (hWnd, NULL, TRUE);
return 0;
}
case CBM_ENABLE:
TbarData = (PCOOLBARCTRL)GetWindowAdditionalData2 (hWnd);
if (enable_item (TbarData, wParam, lParam))
return -1;
InvalidateRect (hWnd, NULL, TRUE);
return 0;
case MSG_LBUTTONDOWN:
{
int posx, posy;
TbarData=(PCOOLBARCTRL) GetWindowAdditionalData2(hWnd);
posx = LOSWORD (lParam);
posy = HISWORD (lParam);
if (GetCapture () == hWnd)
break;
SetCapture (hWnd);
if ((pTbid = GetCurTag (posx, posy, TbarData)) == NULL)
break;
TbarData->iSel = pTbid->insPos;
break;
}
case MSG_LBUTTONUP:
{
int x, y;
TbarData = (PCOOLBARCTRL)GetWindowAdditionalData2(hWnd);
x = LOSWORD(lParam);
y = HISWORD(lParam);
if (GetCapture() != hWnd)
break;
ReleaseCapture ();
ScreenToClient (hWnd, &x, &y);
if ((pTbid = GetCurTag(x, y, TbarData)) == NULL) {
break;
}
if (TbarData->iSel == pTbid->insPos && !pTbid->Disable)
NotifyParent (hWnd, GetDlgCtrlID(hWnd), pTbid->id);
TbarData->iSel = -1;
break;
}
case MSG_MOUSEMOVE:
{
int x, y;
TbarData = (PCOOLBARCTRL) GetWindowAdditionalData2(hWnd);
x = LOSWORD(lParam);
y = HISWORD(lParam);
if (GetCapture() == hWnd)
ScreenToClient (hWnd, &x, &y);
if ((pTbid = GetCurTag (x, y, TbarData)) == NULL) {
unhilight (hWnd);
break;
}
if (TbarData->iMvOver == pTbid->insPos)
break;
unhilight (hWnd);
TbarData->iMvOver = pTbid->insPos;
hilight (hWnd, TbarData, pTbid);
break;
}
case MSG_MOUSEMOVEIN:
if (!wParam)
unhilight (hWnd);
break;
case MSG_NCLBUTTONDOWN:
case MSG_KILLFOCUS:
unhilight (hWnd);
break;
}
return DefaultControlProc (hWnd, message, wParam, lParam);
}
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;
}
wxSize wxSlider::DoGetBestSize() const
{
wxSize size;
int textwidth, textheight;
int mintwidth, mintheight;
int maxtwidth, maxtheight;
textwidth = textheight = 0;
mintwidth = mintheight = 0;
maxtwidth = maxtheight = 0;
if (GetWindowStyle() & wxSL_LABELS)
{
wxString text;
// Get maximum text label width and height
text.Printf( wxT("%d"), ValueInvertOrNot( m_rangeMin ) );
GetTextExtent(text, &mintwidth, &mintheight);
text.Printf( wxT("%d"), ValueInvertOrNot( m_rangeMax ) );
GetTextExtent(text, &maxtwidth, &maxtheight);
if (maxtheight > mintheight)
textheight = maxtheight;
else
textheight = mintheight;
if (maxtwidth > mintwidth)
textwidth = maxtwidth;
else
textwidth = mintwidth;
}
if (GetWindowStyle() & wxSL_VERTICAL)
{
size.y = 150;
if (GetWindowStyle() & wxSL_AUTOTICKS)
size.x = wxSLIDER_DIMENSIONACROSS_WITHTICKMARKS;
else
size.x = wxSLIDER_DIMENSIONACROSS_ARROW;
if (GetWindowStyle() & wxSL_LABELS)
size.x += textwidth + wxSLIDER_BORDERTEXT;
}
else
{
size.x = 150;
if (GetWindowStyle() & wxSL_AUTOTICKS)
size.y = wxSLIDER_DIMENSIONACROSS_WITHTICKMARKS;
else
size.y = wxSLIDER_DIMENSIONACROSS_ARROW;
if (GetWindowStyle() & wxSL_LABELS)
{
size.y += textheight + wxSLIDER_BORDERTEXT;
size.x += (mintwidth / 2) + (maxtwidth / 2);
}
}
return size;
}
//
// - returns true if DirectDraw was initialized properly
//
int InitDirectDrawe (HWND appWin, int width, int height, int bpp, int fullScr)
{
DDSURFACEDESC ddsd; // DirectDraw surface description for allocating
DDSCAPS ddscaps;
HRESULT ddrval;
DWORD dwStyle;
RECT rect;
// enumerate directdraw devices
//if (FAILED(DirectDrawEnumerate (myEnumDDDevicesCallback, NULL)))
// I_Error("Error with DirectDrawEnumerate");
if (!DDr2)
CreateDirectDrawInstance();
// remember what screen mode we are in
bAppFullScreen = fullScr;
ScreenHeight = height;
ScreenWidth = width;
if (bAppFullScreen)
{
// Change window attributes
dwStyle = WS_POPUP | WS_VISIBLE;
SetWindowLong (appWin, GWL_STYLE, dwStyle);
SetWindowPos(appWin, HWND_TOPMOST, 0, 0, 0, 0, SWP_NOACTIVATE |
SWP_NOMOVE | SWP_NOSIZE | SWP_NOZORDER);
// Get exclusive mode
ddrval = IDirectDraw2_SetCooperativeLevel(DDr2, appWin, DDSCL_EXCLUSIVE |
DDSCL_FULLSCREEN |
DDSCL_ALLOWREBOOT);
if (ddrval != DD_OK)
I_Error("SetCooperativeLevel FAILED: %s\n", DXErrorToString(ddrval));
// Switch from windows desktop to fullscreen
#ifdef NT4COMPAT
ddrval = IDirectDraw2_SetDisplayMode(DDr2, width, height, bpp, 0, 0);
#else
ddrval = IDirectDraw2_SetDisplayMode(DDr2, width, height, bpp, 0, DDSDM_STANDARDVGAMODE);
#endif
if (ddrval != DD_OK)
I_Error("SetDisplayMode FAILED: %s\n", DXErrorToString(ddrval));
// This is not really needed, except in certain cases. One case
// is while using MFC. When the desktop is initally at 16bpp, a mode
// switch to 8bpp somehow causes the MFC window to not fully initialize
// and a CreateSurface will fail with DDERR_NOEXCLUSIVEMODE. This will
// ensure that the window is initialized properly after a mode switch.
ShowWindow(appWin, SW_SHOW);
// Create the primary surface with 1 back buffer. Always zero the
// DDSURFACEDESC structure and set the dwSize member!
ZeroMemory(&ddsd, sizeof (ddsd));
ddsd.dwSize = sizeof (ddsd);
ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX;
// for fullscreen we use page flipping, for windowed mode, we blit the hidden surface to
// the visible surface, in both cases we have a visible (or 'real') surface, and a hidden
// (or 'virtual', or 'backbuffer') surface.
ddsd.dwBackBufferCount = 2;
ddrval = IDirectDraw2_CreateSurface(DDr2,&ddsd, &ScreenReal, NULL);
if (ddrval != DD_OK)
I_Error("CreateSurface Primary Screen FAILED");
// Get a pointer to the back buffer
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
ddrval = IDirectDrawSurface_GetAttachedSurface(ScreenReal,&ddscaps, &ScreenVirtual);
if (ddrval != DD_OK)
I_Error("GetAttachedSurface FAILED");
}
else
{
rect.top = 0;
rect.left = 0;
rect.bottom = height;
rect.right = width;
// Change window attributes
dwStyle = GetWindowStyle(appWin);
dwStyle &= ~WS_POPUP;
dwStyle |= WS_OVERLAPPED | WS_SYSMENU | WS_CAPTION;
SetWindowLong(appWin, GWL_STYLE, dwStyle);
// Resize the window so that the client area is the requested width/height
AdjustWindowRectEx(&rect, GetWindowStyle(appWin), GetMenu(appWin) != NULL,
GetWindowExStyle(appWin));
// Just in case the window was moved off the visible area of the
// screen.
SetWindowPos(appWin, NULL, 0, 0, rect.right-rect.left,
rect.bottom-rect.top, SWP_NOMOVE | SWP_NOZORDER |
SWP_NOACTIVATE);
SetWindowPos(appWin, HWND_NOTOPMOST, 0, 0, 0, 0,
SWP_NOSIZE | SWP_NOMOVE | SWP_NOACTIVATE);
// Exclusive mode is normal since it's in windowed mode and needs
// to cooperate with GDI
ddrval = IDirectDraw2_SetCooperativeLevel(DDr2,appWin, DDSCL_NORMAL);
if (ddrval != DD_OK)
I_Error("SetCooperativeLevel FAILED");
// Always zero the DDSURFACEDESC structure and set the dwSize member!
ZeroMemory(&ddsd, sizeof (ddsd));
ddsd.dwSize = sizeof (ddsd);
ddsd.dwFlags = DDSD_CAPS;
ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
// Create the primary surface
ddrval = IDirectDraw2_CreateSurface(DDr2,&ddsd, &ScreenReal, NULL);
if (ddrval != DD_OK)
I_Error("CreateSurface Primary Screen FAILED");
// Create a back buffer for offscreen rendering, this will be used to
// blt to the primary
ScreenVirtual = CreateNewSurface(width, height, DDSCAPS_OFFSCREENPLAIN |
DDSCAPS_SYSTEMMEMORY);
if (ScreenVirtual == NULL)
I_Error("CreateSurface Secondary Screen FAILED");
/// \todo get the desktop bit depth, and build a lookup table
/// for quick conversions of 8bit color indexes 0-255 to desktop colors
/// eg: 256 entries of equivalent of palette colors 0-255 in 15,16,24,32 bit format
/// when blit virtual to real, convert pixels through lookup table..
// Use a clipper object for clipping when in windowed mode
// (make sure our drawing doesn't affect other windows)
ddrval = IDirectDraw2_CreateClipper (DDr2, 0, &windclip, 0);
if (ddrval != DD_OK)
I_Error("CreateClipper FAILED");
// Associate the clipper with the window.
ddrval = IDirectDrawClipper_SetHWnd (windclip,0, appWin);
if (ddrval != DD_OK)
I_Error("Clipper -> SetHWnd FAILED");
// Attach the clipper to the surface.
ddrval = IDirectDrawSurface_SetClipper (ScreenReal,windclip);
if (ddrval != DD_OK)
I_Error("PrimaryScreen -> SetClipperClipper FAILED");
}
return TRUE;
}
void wxSlider::DoSetSize(int x, int y, int w, int h, int sizeFlags)
{
int yborder = 0;
int minValWidth, maxValWidth, textheight;
int sliderBreadth;
int width = w;
if (GetWindowStyle() & wxSL_LABELS)
{
wxString text;
int ht, valValWidth;
// Get maximum text label width and height
text.Printf(wxT("%d"), ValueInvertOrNot( m_rangeMin ) );
GetTextExtent(text, &minValWidth, &textheight);
text.Printf(wxT("%d"), ValueInvertOrNot( m_rangeMax ) );
GetTextExtent(text, &maxValWidth, &ht);
if (ht > textheight)
textheight = ht;
if (GetWindowStyle() & wxSL_HORIZONTAL)
{
if ( m_macMinimumStatic )
{
w -= minValWidth / 2;
x += minValWidth / 2;
}
if ( m_macMaximumStatic )
w -= maxValWidth / 2;
}
// Labels have this control's parent as their parent
// so if this control is not at 0,0 relative to the parent
// the labels need to know the position of this control
// relative to its parent in order to size properly, so
// move the control first so we can use GetPosition()
wxControl::DoSetSize( x, y, w, h, sizeFlags );
if (GetWindowStyle() & wxSL_VERTICAL)
// If vertical, use current value
text.Printf(wxT("%d"), (int)GetPeer()->GetValue());
else
// Use max so that the current value doesn't drift as centering would need to change
text.Printf(wxT("%d"), m_rangeMax);
GetTextExtent(text, &valValWidth, &ht);
yborder = textheight + wxSLIDER_BORDERTEXT;
// Get slider breadth
if (GetWindowStyle() & wxSL_AUTOTICKS)
sliderBreadth = wxSLIDER_DIMENSIONACROSS_WITHTICKMARKS;
else
sliderBreadth = wxSLIDER_DIMENSIONACROSS_ARROW;
if (GetWindowStyle() & wxSL_VERTICAL)
{
h = h - yborder;
if ( m_macMinimumStatic )
m_macMinimumStatic->Move(GetPosition().x + sliderBreadth + wxSLIDER_BORDERTEXT, GetPosition().y + h - yborder);
if ( m_macMaximumStatic )
m_macMaximumStatic->Move(GetPosition().x + sliderBreadth + wxSLIDER_BORDERTEXT, GetPosition().y + 0);
if ( m_macValueStatic )
m_macValueStatic->Move(GetPosition().x + sliderBreadth + wxSLIDER_BORDERTEXT, GetPosition().y + (h / 2) - (ht / 2));
}
else
{
if ( m_macMinimumStatic )
m_macMinimumStatic->Move(GetPosition().x, GetPosition().y + sliderBreadth + wxSLIDER_BORDERTEXT);
if ( m_macMaximumStatic )
m_macMaximumStatic->Move(GetPosition().x + w - maxValWidth, GetPosition().y + sliderBreadth + wxSLIDER_BORDERTEXT);
if ( m_macValueStatic )
m_macValueStatic->Move(GetPosition().x + (w / 2) - (valValWidth / 2), GetPosition().y + sliderBreadth + wxSLIDER_BORDERTEXT);
}
}
// yet another hack since this is a composite control
// when wxSlider has it's size hardcoded, we're not allowed to
// change the size. But when the control has labels, we DO need
// to resize the internal Mac control to accommodate the text labels.
// We need to trick the wxWidgets resize mechanism so that we can
// resize the slider part of the control ONLY.
// TODO: Can all of this code go in the conditional wxSL_LABELS block?
int minWidth = m_minWidth;
if (GetWindowStyle() & wxSL_LABELS)
{
// make sure we don't allow the entire control to be resized accidentally
if (width == GetSize().x)
m_minWidth = -1;
}
// If the control has labels, we still need to call this again because
// the labels alter the control's w and h values.
wxControl::DoSetSize( x, y, w, h, sizeFlags );
m_minWidth = minWidth;
}
int
WIN_CreateWindow(_THIS, SDL_Window * window)
{
HWND hwnd;
RECT rect;
DWORD style = STYLE_BASIC;
int x, y;
int w, h;
style |= GetWindowStyle(window);
/* Figure out what the window area will be */
rect.left = window->x;
rect.top = window->y;
rect.right = window->x + window->w;
rect.bottom = window->y + window->h;
AdjustWindowRectEx(&rect, style, FALSE, 0);
x = rect.left;
y = rect.top;
w = (rect.right - rect.left);
h = (rect.bottom - rect.top);
hwnd =
CreateWindow(SDL_Appname, TEXT(""), style, x, y, w, h, NULL, NULL,
SDL_Instance, NULL);
if (!hwnd) {
return WIN_SetError("Couldn't create window");
}
WIN_PumpEvents(_this);
if (SetupWindowData(_this, window, hwnd, SDL_TRUE) < 0) {
DestroyWindow(hwnd);
return -1;
}
#if SDL_VIDEO_OPENGL_WGL
/* We need to initialize the extensions before deciding how to create ES profiles */
if (window->flags & SDL_WINDOW_OPENGL) {
WIN_GL_InitExtensions(_this);
}
#endif
#if SDL_VIDEO_OPENGL_ES2
if ((window->flags & SDL_WINDOW_OPENGL) &&
_this->gl_config.profile_mask == SDL_GL_CONTEXT_PROFILE_ES
#if SDL_VIDEO_OPENGL_WGL
&& (!_this->gl_data || !_this->gl_data->HAS_WGL_EXT_create_context_es2_profile)
#endif
) {
#if SDL_VIDEO_OPENGL_EGL
if (WIN_GLES_SetupWindow(_this, window) < 0) {
WIN_DestroyWindow(_this, window);
return -1;
}
#else
return SDL_SetError("Could not create GLES window surface (no EGL support available)");
#endif /* SDL_VIDEO_OPENGL_EGL */
} else
#endif /* SDL_VIDEO_OPENGL_ES2 */
#if SDL_VIDEO_OPENGL_WGL
if (window->flags & SDL_WINDOW_OPENGL) {
if (WIN_GL_SetupWindow(_this, window) < 0) {
WIN_DestroyWindow(_this, window);
return -1;
}
}
#endif
return 0;
}
inline bool isVertical( HWND hwnd ) {
return 0 != (0x1 & GetWindowStyle( hwnd ));
}
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;
}
void wxSplitterWindow::OnMouseEvent(wxMouseEvent& event)
{
int x = (int)event.GetX(),
y = (int)event.GetY();
if ( GetWindowStyle() & wxSP_NOSASH )
{
event.Skip();
return;
}
bool isLive = IsLive(this);
if (event.LeftDown())
{
if ( SashHitTest(x, y) )
{
// Start the drag now
m_dragMode = wxSPLIT_DRAG_DRAGGING;
// Capture mouse and set the cursor
CaptureMouse();
SetResizeCursor();
if ( !isLive )
{
// remember the initial sash position and draw the initial
// shadow sash
m_sashPositionCurrent = m_sashPosition;
m_oldX = (m_splitMode == wxSPLIT_VERTICAL ? m_sashPositionCurrent : x);
m_oldY = (m_splitMode != wxSPLIT_VERTICAL ? m_sashPositionCurrent : y);
DrawSashTracker(m_oldX, m_oldY);
}
m_ptStart = wxPoint(x,y);
m_sashStart = m_sashPosition;
return;
}
}
else if (event.LeftUp() && m_dragMode == wxSPLIT_DRAG_DRAGGING)
{
// We can stop dragging now and see what we've got.
m_dragMode = wxSPLIT_DRAG_NONE;
// Release mouse and unset the cursor
ReleaseMouse();
SetCursor(* wxSTANDARD_CURSOR);
// exit if unsplit after doubleclick
if ( !IsSplit() )
{
return;
}
// Erase old tracker
if ( !isLive )
{
DrawSashTracker(m_oldX, m_oldY);
}
// the position of the click doesn't exactly correspond to
// m_sashPosition, rather it changes it by the distance by which the
// mouse has moved
int diff = m_splitMode == wxSPLIT_VERTICAL ? x - m_ptStart.x : y - m_ptStart.y;
int posSashNew = OnSashPositionChanging(m_sashStart + diff);
if ( posSashNew == -1 )
{
// change not allowed
return;
}
if ( m_permitUnsplitAlways || m_minimumPaneSize == 0 )
{
// Deal with possible unsplit scenarios
if ( posSashNew == 0 )
{
// We remove the first window from the view
wxWindow *removedWindow = m_windowOne;
m_windowOne = m_windowTwo;
m_windowTwo = NULL;
OnUnsplit(removedWindow);
wxSplitterEvent eventUnsplit(wxEVT_SPLITTER_UNSPLIT, this);
eventUnsplit.m_data.win = removedWindow;
(void)DoSendEvent(eventUnsplit);
SetSashPositionAndNotify(0);
}
else if ( posSashNew == GetWindowSize() )
{
// We remove the second window from the view
wxWindow *removedWindow = m_windowTwo;
m_windowTwo = NULL;
OnUnsplit(removedWindow);
wxSplitterEvent eventUnsplit(wxEVT_SPLITTER_UNSPLIT, this);
eventUnsplit.m_data.win = removedWindow;
(void)DoSendEvent(eventUnsplit);
SetSashPositionAndNotify(0);
}
else
{
SetSashPositionAndNotify(posSashNew);
}
}
else
{
SetSashPositionAndNotify(posSashNew);
}
SizeWindows();
} // left up && dragging
else if ((event.Moving() || event.Leaving() || event.Entering()) && (m_dragMode == wxSPLIT_DRAG_NONE))
{
if ( event.Leaving() || !SashHitTest(x, y) )
OnLeaveSash();
else
OnEnterSash();
}
else if (event.Dragging() && (m_dragMode == wxSPLIT_DRAG_DRAGGING))
{
int diff = m_splitMode == wxSPLIT_VERTICAL ? x - m_ptStart.x : y - m_ptStart.y;
int posSashNew = OnSashPositionChanging(m_sashStart + diff);
if ( posSashNew == -1 )
{
// change not allowed
return;
}
if ( !isLive )
{
if ( posSashNew == m_sashPositionCurrent )
return;
m_sashPositionCurrent = posSashNew;
// Erase old tracker
DrawSashTracker(m_oldX, m_oldY);
m_oldX = (m_splitMode == wxSPLIT_VERTICAL ? m_sashPositionCurrent : x);
m_oldY = (m_splitMode != wxSPLIT_VERTICAL ? m_sashPositionCurrent : y);
#ifdef __WXMSW__
// As we captured the mouse, we may get the mouse events from outside
// our window - for example, negative values in x, y. This has a weird
// consequence under MSW where we use unsigned values sometimes and
// signed ones other times: the coordinates turn as big positive
// numbers and so the sash is drawn on the *right* side of the window
// instead of the left (or bottom instead of top). Correct this.
if ( (short)m_oldX < 0 )
m_oldX = 0;
if ( (short)m_oldY < 0 )
m_oldY = 0;
#endif // __WXMSW__
// Draw new one
DrawSashTracker(m_oldX, m_oldY);
}
else
{
if ( posSashNew == m_sashPosition )
return;
DoSetSashPosition(posSashNew);
// in live mode, the new position is the actual sash position, clear requested position!
m_requestedSashPosition = INT_MAX;
m_needUpdating = true;
}
}
else if ( event.LeftDClick() && m_windowTwo )
{
OnDoubleClickSash(x, y);
}
else
{
event.Skip();
}
}
static bool HasWsBorder(HWND hwnd)
{
DWORD style = GetWindowStyle(hwnd);
return bit::IsMaskSet<DWORD>(style, WS_BORDER);
}
bool CBasicWindow::CalcPositionFromClientRect(RECT *pRect) const
{
if (m_hwnd==NULL)
return false;
return ::AdjustWindowRectEx(pRect,GetWindowStyle(),FALSE,GetWindowExStyle())!=FALSE;
}
BOOL SetScrollInfoEx (HWND hWnd, int iSBar,
LPCSCROLLINFO lpsi, BOOL fRedraw) /* jmt: iSBar not used */
{
PMWSCROLLBARINFO pSBar;
HWND pWin;
RECT rcBar;
DWORD dwStyle; /* jmt:2k0820 */
pWin = (HWND)hWnd;
if ( !(pSBar = wndGetScrollBar (pWin)) )
return FALSE;
if( lpsi->fMask & SIF_RANGE )
{
pSBar->minPos = (lpsi->nMin < lpsi->nMax)?lpsi->nMin:lpsi->nMax;
pSBar->maxPos = (lpsi->nMin < lpsi->nMax)?lpsi->nMax:lpsi->nMin;
}
if( lpsi->fMask & SIF_POS )
pSBar->curPos = lpsi->nPos;
if( lpsi->fMask & SIF_PAGE )
pSBar->pageStep = lpsi->nPage;
/* validate parameters. */
if (pSBar->curPos < pSBar->minPos)
pSBar->curPos = pSBar->minPos;
if (pSBar->pageStep <= 0)
pSBar->pageStep = 0;
else if (pSBar->pageStep > (pSBar->maxPos - pSBar->minPos + 1))
pSBar->pageStep = pSBar->maxPos - pSBar->minPos + 1;
{
int max = pSBar->maxPos;
max -= ((pSBar->pageStep - 1) > 0)?(pSBar->pageStep - 1):0;
if (pSBar->curPos > max)
pSBar->curPos = max;
}
dwStyle = (GetWindowStyle (hWnd) & SBS_TYPEMASK); /* jmt: 2k0820 */
if(fRedraw)
{
if (dwStyle == SBS_VERT)
{
wndGetVScrollBarRect (pWin, &rcBar);
rcBar.left --;
rcBar.right --;
}
else
{
wndGetHScrollBarRect (pWin, &rcBar);
rcBar.top --;
rcBar.bottom --;
}
wndScrollBarPos (pWin, dwStyle == SBS_HORZ, &rcBar);
#if 0
SendMessage (hWnd, WM_NCPAINT, 0, (LPARAM)(&rcBar));
#else
MwPaintScrollbars(hWnd,NULL,dwStyle); /* a must */
#endif
}
return TRUE;
}
bool wxTextCtrl::Create(wxWindow *parent, wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
long style,
const wxValidator& validator,
const wxString& name)
{
if ( (style & wxBORDER_MASK) == wxBORDER_DEFAULT )
style |= wxBORDER_SIMPLE;
SetWindowStyle(style);
WXDWORD exStyle = 0;
WXDWORD msStyle = MSWGetStyle(GetWindowStyle(), & exStyle) ;
wxSize sizeText(size), sizeBtn(size);
sizeBtn.x = GetBestSpinnerSize(IsVertical(style)).x / 2;
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(_T("not enough space for wxSpinCtrl!"));
}
wxPoint posBtn(pos);
posBtn.x += sizeText.x + MARGIN_BETWEEN;
// we need to turn '\n's into "\r\n"s for the multiline controls
wxString valueWin;
if ( m_windowStyle & wxTE_MULTILINE )
{
valueWin = wxTextFile::Translate(value, wxTextFileType_Dos);
}
else // single line
{
valueWin = value;
}
// 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
_T("EDIT"), // window class
valueWin, // 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_EXPANDABLE |
UDS_NOSCROLL;
if ( !IsVertical(style) )
spiner_style |= UDS_HORZ;
if ( style & wxSP_WRAP )
spiner_style |= UDS_WRAP;
if ( !MSWCreateControl(UPDOWN_CLASS, spiner_style, posBtn, sizeBtn, _T(""), 0) )
return false;
// subclass the text ctrl to be able to intercept some events
wxSetWindowUserData(GetBuddyHwnd(), this);
m_wndProcBuddy = (WXFARPROC)wxSetWindowProc(GetBuddyHwnd(),
wxBuddyTextCtrlWndProc);
// set up fonts and colours (This is nomally done in MSWCreateControl)
InheritAttributes();
if (!m_hasFont)
SetFont(GetDefaultAttributes().font);
// set the size of the text window - can do it only now, because we
// couldn't call DoGetBestSize() before as font wasn't set
if ( sizeText.y <= 0 )
{
int cx, cy;
wxGetCharSize(GetHWND(), &cx, &cy, GetFont());
sizeText.y = EDIT_HEIGHT_FROM_CHAR_HEIGHT(cy);
}
SetInitialSize(size);
(void)::ShowWindow(GetBuddyHwnd(), SW_SHOW);
// associate the list window with the spin button
(void)::SendMessage(GetHwnd(), UDM_SETBUDDY, (WPARAM)GetBuddyHwnd(), 0);
// do it after finishing with m_hwndBuddy creation to avoid generating
// initial wxEVT_COMMAND_TEXT_UPDATED message
ms_allTextSpins.Add(this);
return true;
}
BOOL ShowScrollBarEx (HWND hWnd, int iSBar, BOOL bShow) /* jmt: iSBar not used */
{
PMWSCROLLBARINFO pSBar;
HWND pWin;
BOOL bPrevState;
RECT rcBar;
DWORD dwStyle; /* jmt:2k0820 */
pWin = (HWND)hWnd;
if ( !(pSBar = wndGetScrollBar (pWin)) )
return FALSE;
bPrevState = !(pSBar->status & SBS_HIDE);
if (bShow && !bPrevState)
pSBar->status &= ~SBS_HIDE;
else if (!bShow && bPrevState)
pSBar->status |= SBS_HIDE;
else
return FALSE;
#if 0 /* fix: no WM_CHANGESIZE */
SendMessage (hWnd, WM_CHANGESIZE, 0, 0);
#endif
dwStyle = (GetWindowStyle (hWnd) & SBS_TYPEMASK); /* jmt: 2k0820 */
if (dwStyle == SBS_VERT)
wndGetVScrollBarRect (pWin, &rcBar);
else
wndGetHScrollBarRect (pWin, &rcBar);
{
RECT rcWin, rcClient;
memcpy (&rcWin, &pWin->winrect.left, sizeof (RECT));
rcClient.left = 0;
rcClient.top = 0;
rcClient.right = pWin->clirect.right - pWin->clirect.left;
rcClient.bottom = pWin->clirect.bottom - pWin->clirect.top;
#if 0 /* fix: no WM_SIZECHANGED */
SendMessage (hWnd, WM_SIZECHANGED,
(WPARAM)&rcWin, (LPARAM)&rcClient);
#endif
}
if (bShow) {
SendMessage (hWnd, WM_NCPAINT, 0, 0);
}
else {
rcBar.left -= pWin->clirect.left;
rcBar.top -= pWin->clirect.top;
rcBar.right -= pWin->clirect.left;
rcBar.bottom -= pWin->clirect.top;
SendMessage (hWnd, WM_NCPAINT, 0, 0);
InvalidateRect (hWnd, &rcBar, TRUE);
}
return TRUE;
}
bool CMultiLineEditUI::IsReadOnly() const
{
return (GetWindowStyle(*m_pWindow) & ES_READONLY) != 0;
}
static LRESULT CALLBACK
ScrollbarControlProc (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) /* jmt:2k0820 */
{
DWORD dwStyle;
MWSCROLLBARINFO* pData;
int moveRange;
RECT rcBar;
dwStyle = (GetWindowStyle (hwnd) & SBS_TYPEMASK);
switch (message)
{
case WM_CREATE:
if (!(pData = malloc (sizeof (MWSCROLLBARINFO))))
{
fprintf(stderr, "Create scroll bar control failure!\n");
return -1;
}
pData->minPos=0; /* min value of scroll range.*/
/* max value of scroll range.*/
pData->maxPos=0;
if (dwStyle==SBS_VERT)
moveRange=((hwnd->winrect.bottom-hwnd->winrect.top)
-((hwnd->winrect.right-hwnd->winrect.left)<<1));
else
moveRange=((hwnd->winrect.right-hwnd->winrect.left)
-((hwnd->winrect.bottom-hwnd->winrect.top)<<1));
if (moveRange > MWM_MINBARLEN)
{
pData->maxPos=moveRange / MWM_MINBARLEN;
if( (moveRange % MWM_MINBARLEN) )
pData->maxPos++;
}
printf("maxPos=%d\n",pData->maxPos);
pData->curPos=0; /* current scroll pos.*/
/* steps per page.*/
pData->pageStep=1;
if ( (pData->maxPos - 2) > 1)
pData->pageStep = pData->maxPos - 2;
printf("pageStep=%d\n",pData->pageStep);
pData->barStart=0; /* start pixel of bar.*/
pData->barLen=MWM_MINBARLEN; /* length of bar.*/
pData->status=SBS_UNKNOWN; /* status of scroll bar.*/
#if 0 /* jmt: must handle WM_MOVE */
pData->rc=hwnd->winrect; /* screen coordinates position*/
#endif
hwnd->userdata = (DWORD)pData;
if (dwStyle == SBS_VERT)
{
wndGetVScrollBarRect (hwnd, &rcBar);
rcBar.left --;
rcBar.right --;
}
else
{
wndGetHScrollBarRect (hwnd, &rcBar);
rcBar.top --;
rcBar.bottom --;
}
/* adjust pData->barLen */
wndScrollBarPos (hwnd, dwStyle == SBS_HORZ, &rcBar);
break;
case WM_DESTROY:
free ((void *)(hwnd->userdata));
break;
case WM_PAINT:
MwPaintScrollbars(hwnd,NULL,dwStyle);
break;
case WM_NCLBUTTONDOWN:
case WM_NCLBUTTONDBLCLK:
case WM_NCMOUSEMOVE:
case WM_NCLBUTTONUP:
MwHandleMessageScrollbar(hwnd, wParam, lParam, message, dwStyle);
break;
case WM_HSCROLL:
case WM_VSCROLL:
{
int newTop,itemCount,itemVisibles;
pData = (MWSCROLLBARINFO *)hwnd->userdata;
newTop = pData->curPos;
itemCount = pData->maxPos - pData->minPos + 1;
itemVisibles = pData->pageStep;
switch(wParam)
{
case SB_LINEDOWN:
#define ITEM_BOTTOM(x) (x->curPos + itemVisibles - 1)
if (ITEM_BOTTOM (pData) < (itemCount - 1 ))
{
newTop ++;
}
break;
case SB_LINEUP:
if (pData->curPos > 0)
{
newTop --;
}
break;
case SB_PAGEDOWN:
if ((pData->curPos + (itemVisibles << 1)) <=
itemCount)
newTop += itemVisibles;
else
newTop = itemCount - itemVisibles;
if (newTop < 0)
return 0;
break;
case SB_PAGEUP:
if (pData->curPos >= itemVisibles)
newTop -= itemVisibles;
else
newTop = 0;
break;
case SB_THUMBTRACK:
newTop = (int)lParam;
break;
}
pData->curPos = newTop;
SendMessage (hwnd, WM_PAINT, 0, 0);
sbSetScrollInfo (hwnd, pData, TRUE);
return 0;
}
break;
default:
return DefWindowProc (hwnd, message, wParam, lParam);
}
return 0;
}
bool wxToolBar::Realize()
{
if ( m_tools.GetCount() == 0 )
{
// nothing to do
return true;
}
bool isVertical = GetWindowStyle() & wxTB_VERTICAL;
// Separator spacing
const int separatorSize = GetToolSeparation(); // 8;
wxSize margins = GetToolMargins();
int packing = GetToolPacking();
int marginX = margins.x;
int marginY = margins.y;
int currentX = marginX;
int currentY = marginY;
int buttonHeight = 0, buttonWidth = 0;
Widget button;
Pixmap pixmap, insensPixmap;
wxBitmap bmp, insensBmp;
wxToolBarToolsList::compatibility_iterator node = m_tools.GetFirst();
while ( node )
{
wxToolBarTool *tool = (wxToolBarTool *)node->GetData();
switch ( tool->GetStyle() )
{
case wxTOOL_STYLE_CONTROL:
{
wxControl* control = tool->GetControl();
wxSize sz = control->GetSize();
wxPoint pos = control->GetPosition();
// Allow a control to specify a y[x]-offset by setting
// its initial position, but still don't allow it to
// position itself above the top[left] margin.
int controlY = (pos.y > 0) ? pos.y : currentY;
int controlX = (pos.x > 0) ? pos.x : currentX;
control->Move( isVertical ? controlX : currentX,
isVertical ? currentY : controlY );
if ( isVertical )
currentY += sz.y + packing;
else
currentX += sz.x + packing;
break;
}
case wxTOOL_STYLE_SEPARATOR:
// skip separators for vertical toolbars
if( !isVertical )
{
currentX += separatorSize;
}
break;
case wxTOOL_STYLE_BUTTON:
button = (Widget) 0;
if ( tool->CanBeToggled() && !tool->GetButtonWidget() )
{
button = XtVaCreateWidget("toggleButton",
xmToggleButtonWidgetClass, (Widget) m_mainWidget,
XmNx, currentX, XmNy, currentY,
XmNindicatorOn, False,
XmNshadowThickness, 2,
XmNborderWidth, 0,
XmNspacing, 0,
XmNmarginWidth, 0,
XmNmarginHeight, 0,
XmNmultiClick, XmMULTICLICK_KEEP,
XmNlabelType, XmPIXMAP,
NULL);
XtAddCallback ((Widget) button,
XmNvalueChangedCallback,
(XtCallbackProc) wxToolButtonCallback,
(XtPointer) this);
XtVaSetValues ((Widget) button,
XmNselectColor,
m_backgroundColour.AllocColour
(XtDisplay((Widget) button)),
NULL);
}
else if( !tool->GetButtonWidget() )
{
button = XtVaCreateWidget("button",
xmPushButtonWidgetClass, (Widget) m_mainWidget,
XmNx, currentX, XmNy, currentY,
XmNpushButtonEnabled, True,
XmNmultiClick, XmMULTICLICK_KEEP,
XmNlabelType, XmPIXMAP,
NULL);
XtAddCallback (button,
XmNactivateCallback,
(XtCallbackProc) wxToolButtonCallback,
(XtPointer) this);
}
if( !tool->GetButtonWidget() )
{
wxDoChangeBackgroundColour((WXWidget) button,
m_backgroundColour, true);
tool->SetWidget(button);
}
else
{
button = (Widget)tool->GetButtonWidget();
XtVaSetValues( button,
XmNx, currentX, XmNy, currentY,
NULL );
}
// For each button, if there is a mask, we must create
// a new wxBitmap that has the correct background colour
// for the button. Otherwise the background will just be
// e.g. black if a transparent XPM has been loaded.
bmp = tool->GetNormalBitmap();
insensBmp = tool->GetDisabledBitmap();
if ( bmp.GetMask() || insensBmp.GetMask() )
{
WXPixel backgroundPixel;
XtVaGetValues(button, XmNbackground, &backgroundPixel,
NULL);
wxColour col;
col.SetPixel(backgroundPixel);
if( bmp.IsOk() && bmp.GetMask() )
{
bmp = wxCreateMaskedBitmap(bmp, col);
tool->SetNormalBitmap(bmp);
}
if( insensBmp.IsOk() && insensBmp.GetMask() )
{
insensBmp = wxCreateMaskedBitmap(insensBmp, col);
tool->SetDisabledBitmap(insensBmp);
}
}
// Create a selected/toggled bitmap. If there isn't a 2nd
// bitmap, we need to create it (with a darker, selected
// background)
WXPixel backgroundPixel;
if ( tool->CanBeToggled() )
XtVaGetValues(button, XmNselectColor, &backgroundPixel,
NULL);
else
XtVaGetValues(button, XmNarmColor, &backgroundPixel,
NULL);
wxColour col;
col.SetPixel(backgroundPixel);
pixmap = (Pixmap) bmp.GetDrawable();
{
wxBitmap tmp = tool->GetDisabledBitmap();
insensPixmap = tmp.IsOk() ?
(Pixmap)tmp.GetDrawable() :
tool->GetInsensPixmap();
}
if (tool->CanBeToggled())
{
// Toggle button
Pixmap pixmap2 = tool->GetArmPixmap();
Pixmap insensPixmap2 = tool->GetInsensPixmap();
XtVaSetValues (button,
XmNfillOnSelect, True,
XmNlabelPixmap, pixmap,
XmNselectPixmap, pixmap2,
XmNlabelInsensitivePixmap, insensPixmap,
XmNselectInsensitivePixmap, insensPixmap2,
XmNlabelType, XmPIXMAP,
NULL);
}
else
{
Pixmap pixmap2 = tool->GetArmPixmap();
// Normal button
XtVaSetValues(button,
XmNlabelPixmap, pixmap,
XmNlabelInsensitivePixmap, insensPixmap,
XmNarmPixmap, pixmap2,
NULL);
}
XtManageChild(button);
{
Dimension width, height;
XtVaGetValues(button,
XmNwidth, &width,
XmNheight, & height,
NULL);
if ( isVertical )
currentY += height + packing;
else
currentX += width + packing;
buttonHeight = wxMax(buttonHeight, height);
buttonWidth = wxMax(buttonWidth, width);
}
XtAddEventHandler (button, EnterWindowMask | LeaveWindowMask,
False, wxToolButtonPopupCallback, (XtPointer) this);
break;
}
node = node->GetNext();
}
SetSize( -1, -1,
isVertical ? buttonWidth + 2 * marginX : -1,
isVertical ? -1 : buttonHeight + 2*marginY );
return true;
}
bool wxSpinCtrl::Create(wxWindow *parent,
wxWindowID id,
const wxString& value,
const wxPoint& pos,
const wxSize& size,
long style,
int min, int max, int initial,
const wxString& name)
{
// before using DoGetBestSize(), have to set style to let the base class
// know whether this is a horizontal or vertical control (we're always
// vertical)
style |= wxSP_VERTICAL;
if ( (style & wxBORDER_MASK) == wxBORDER_DEFAULT )
#ifdef __WXWINCE__
style |= wxBORDER_SIMPLE;
#else
style |= wxBORDER_SUNKEN;
#endif
SetWindowStyle(style);
WXDWORD exStyle = 0;
WXDWORD msStyle = MSWGetStyle(GetWindowStyle(), & exStyle) ;
// Scroll text automatically if there is not enough space to show all of
// it, this is better than not allowing to enter more digits at all.
msStyle |= ES_AUTOHSCROLL;
// propagate text alignment style to text ctrl
if ( style & wxALIGN_RIGHT )
msStyle |= ES_RIGHT;
else if ( style & wxALIGN_CENTER )
msStyle |= ES_CENTER;
// calculate the sizes: the size given is the total size for both controls
// and we need to fit them both in the given width (height is the same)
wxSize sizeText(size), sizeBtn(size);
sizeBtn.x = wxSpinButton::DoGetBestSize().x;
if ( sizeText.x <= 0 )
{
// 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 text 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("EDIT"), // 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;
}
// create the spin button
if ( !wxSpinButton::Create(parent, id, posBtn, sizeBtn, style, name) )
{
return false;
}
wxSpinButtonBase::SetRange(min, max);
// subclass the text ctrl to be able to intercept some events
gs_spinForTextCtrl[GetBuddyHwnd()] = this;
m_wndProcBuddy = (WXFARPROC)wxSetWindowProc(GetBuddyHwnd(),
wxBuddyTextWndProc);
// 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 text window with the spin button
(void)::SendMessage(GetHwnd(), UDM_SETBUDDY, (WPARAM)m_hwndBuddy, 0);
// If the initial text value is actually a number, it overrides the
// "initial" argument specified later.
long initialFromText;
if ( value.ToLong(&initialFromText) )
initial = initialFromText;
SetValue(initial);
m_oldValue = initial;
// Set the range in the native control
SetRange(min, max);
// Also set the text part of the control if it was specified independently
// but don't generate an event for this, it would be unexpected.
m_blockEvent = true;
if ( !value.empty() )
SetValue(value);
m_blockEvent = false;
return true;
}