/////////////////////////////////////////////////////////////////////////////
// Name: gtk/scrolwin.cpp
// Purpose: wxScrolledWindow implementation
-// Author: Julian Smart
+// Author: Robert Roebling
// Modified by: Ron Lee
// Created: 01/02/97
// RCS-ID: $Id$
-// Copyright: (c) Julian Smart and Markus Holzem
-// Licence: wxWindows license
+// Copyright: (c) Robert Roebling
+// Licence: wxWindows licence
/////////////////////////////////////////////////////////////////////////////
// ============================================================================
// headers
// ----------------------------------------------------------------------------
-#ifdef __GNUG__
+#if defined(__GNUG__) && !defined(NO_GCC_PRAGMA)
#pragma implementation "scrolwin.h"
#endif
#pragma hdrstop
#endif
+#include "wx/scrolwin.h"
#include "wx/utils.h"
#include "wx/dcclient.h"
-
-#include "wx/scrolwin.h"
#include "wx/panel.h"
#include "wx/sizer.h"
// "value_changed" from m_vAdjust
//-----------------------------------------------------------------------------
+extern "C" {
static void gtk_scrolled_window_vscroll_callback( GtkAdjustment *adjust,
SCROLLBAR_CBACK_ARG
wxScrolledWindow *win )
if (g_blockEventsOnDrag) return;
if (!win->m_hasVMT) return;
-
+
win->GtkVScroll( adjust->value,
GET_SCROLL_TYPE(GTK_SCROLLED_WINDOW(win->m_widget)->vscrollbar) );
}
+}
//-----------------------------------------------------------------------------
// "value_changed" from m_hAdjust
//-----------------------------------------------------------------------------
+extern "C" {
static void gtk_scrolled_window_hscroll_callback( GtkAdjustment *adjust,
SCROLLBAR_CBACK_ARG
wxScrolledWindow *win )
win->GtkHScroll( adjust->value,
GET_SCROLL_TYPE(GTK_SCROLLED_WINDOW(win->m_widget)->hscrollbar) );
}
+}
//-----------------------------------------------------------------------------
// "button_press_event" from scrollbar
//-----------------------------------------------------------------------------
+extern "C" {
static gint gtk_scrollbar_button_press_callback( GtkRange *widget,
GdkEventButton *gdk_event,
wxWindowGTK *win)
return FALSE;
}
+}
//-----------------------------------------------------------------------------
// "button_release_event" from scrollbar
//-----------------------------------------------------------------------------
+extern "C" {
static gint gtk_scrollbar_button_release_callback( GtkRange *widget,
GdkEventButton *WXUNUSED(gdk_event),
wxWindowGTK *win)
return FALSE;
}
+}
//-----------------------------------------------------------------------------
// InsertChild for wxScrolledWindow
GtkHConnectEvent();
// these handlers block mouse events to any window during scrolling such as
- // motion events and prevent GTK and wxWindows from fighting over where the
+ // motion events and prevent GTK and wxWidgets from fighting over where the
// slider should be
gtk_signal_connect( GTK_OBJECT(scrolledWindow->vscrollbar), "button_press_event",
PostCreation();
Show( TRUE );
-
+
return TRUE;
}
wxPanel::DoSetVirtualSize( x, y );
AdjustScrollbars();
-#if wxUSE_CONSTRAINTS
if (GetAutoLayout())
Layout();
-#endif
+}
+
+// wxWindow's GetBestVirtualSize returns the actual window size,
+// whereas we want to return the virtual size
+wxSize wxScrolledWindow::GetBestVirtualSize() const
+{
+ wxSize clientSize( GetClientSize() );
+ if (GetSizer())
+ {
+ wxSize minSize( GetSizer()->CalcMin() );
+
+ return wxSize( wxMax( clientSize.x, minSize.x ), wxMax( clientSize.y, minSize.y ) );
+ }
+ else
+ return clientSize;
+}
+
+// return the size best suited for the current window
+// (this isn't a virtual size, this is a sensible size for the window)
+wxSize wxScrolledWindow::DoGetBestSize() const
+{
+ wxSize best;
+
+ if ( GetSizer() )
+ {
+ wxSize b = GetSizer()->GetMinSize();
+
+ // Only use the content to set the window size in the direction
+ // where there's no scrolling; otherwise we're going to get a huge
+ // window in the direction in which scrolling is enabled
+ int ppuX, ppuY;
+ GetScrollPixelsPerUnit(& ppuX, & ppuY);
+
+ wxSize minSize;
+ if ( GetMinSize().IsFullySpecified() )
+ minSize = GetMinSize();
+ else
+ minSize = GetSize();
+
+ if (ppuX > 0)
+ b.x = minSize.x;
+ if (ppuY > 0)
+ b.y = minSize.y;
+ best = b;
+ }
+ else
+ return wxWindow::DoGetBestSize();
+
+ // Add any difference between size and client size
+ wxSize diff = GetSize() - GetClientSize();
+ best.x += wxMax(0, diff.x);
+ best.y += wxMax(0, diff.y);
+
+ return best;
}
/*
int noUnitsX, int noUnitsY,
int xPos, int yPos, bool noRefresh )
{
- int old_x = m_xScrollPixelsPerLine * m_xScrollPosition;
- int old_y = m_yScrollPixelsPerLine * m_yScrollPosition;
+ int xs, ys;
+ GetViewStart (& xs, & ys);
+
+ int old_x = m_xScrollPixelsPerLine * xs;
+ int old_y = m_yScrollPixelsPerLine * ys;
m_xScrollPixelsPerLine = pixelsPerUnitX;
m_yScrollPixelsPerLine = pixelsPerUnitY;
m_hAdjust->value = m_xScrollPosition = xPos;
m_vAdjust->value = m_yScrollPosition = yPos;
- m_targetWindow->SetVirtualSizeHints( noUnitsX * pixelsPerUnitX, noUnitsY * pixelsPerUnitY );
+ // Setting hints here should arguably be deprecated, but without it
+ // a sizer might override this manual scrollbar setting in old code.
+ // m_targetWindow->SetVirtualSizeHints( noUnitsX * pixelsPerUnitX, noUnitsY * pixelsPerUnitY );
+
+ int w = noUnitsX * pixelsPerUnitX;
+ int h = noUnitsY * pixelsPerUnitY;
+ m_targetWindow->SetVirtualSize( w ? w : wxDefaultCoord,
+ h ? h : wxDefaultCoord);
if (!noRefresh)
{
m_targetWindow->GetClientSize( &w, &h );
m_targetWindow->GetVirtualSize( &vw, &vh );
-
+
if (m_xScrollPixelsPerLine == 0)
{
m_hAdjust->upper = 1.0;
+ m_hAdjust->page_increment = 1.0;
m_hAdjust->page_size = 1.0;
}
else
{
- m_hAdjust->upper = vw / m_xScrollPixelsPerLine;
- m_hAdjust->page_size = (w / m_xScrollPixelsPerLine);
-
+ m_hAdjust->upper = (vw+m_xScrollPixelsPerLine-1) / m_xScrollPixelsPerLine;
+ m_hAdjust->page_size = w / m_xScrollPixelsPerLine;
+ m_hAdjust->page_increment = w / m_xScrollPixelsPerLine;
+
+ // Special case. When client and virtual size are very close but
+ // the client is big enough, kill scrollbar.
+
+ if ((m_hAdjust->page_size < m_hAdjust->upper) && (w >= vw))
+ m_hAdjust->page_size += 1.0;
+
// If the scrollbar hits the right side, move the window
// right to keep it from over extending.
- if( m_hAdjust->value + m_hAdjust->page_size > m_hAdjust->upper )
+ if ((m_hAdjust->value != 0.0) && (m_hAdjust->value + m_hAdjust->page_size > m_hAdjust->upper))
{
+ m_hAdjust->value = m_hAdjust->upper - m_hAdjust->page_size;
+ if (m_hAdjust->value < 0.0)
+ m_hAdjust->value = 0.0;
+
if (GetChildren().GetCount() == 0)
- {
- m_hAdjust->value = m_hAdjust->upper - m_hAdjust->page_size;
- m_xScrollPosition = (int)m_hAdjust->value;
- }
+ m_xScrollPosition = (int)m_hAdjust->value; // This is enough without child windows
+ else
+ gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" ); // Actually scroll window
}
}
if (m_yScrollPixelsPerLine == 0)
{
m_vAdjust->upper = 1.0;
+ m_vAdjust->page_increment = 1.0;
m_vAdjust->page_size = 1.0;
}
else
{
- m_vAdjust->upper = vh / m_yScrollPixelsPerLine;
- m_vAdjust->page_size = (h / m_yScrollPixelsPerLine);
-
- if( m_vAdjust->value + m_vAdjust->page_size > m_vAdjust->upper )
+ m_vAdjust->upper = (vh+m_yScrollPixelsPerLine-1) / m_yScrollPixelsPerLine;
+ m_vAdjust->page_size = h / m_yScrollPixelsPerLine;
+ m_vAdjust->page_increment = h / m_yScrollPixelsPerLine;
+
+ if ((m_vAdjust->page_size < m_vAdjust->upper) && (h >= vh))
+ m_vAdjust->page_size += 1.0;
+
+ if ((m_vAdjust->value != 0.0) && (m_vAdjust->value + m_vAdjust->page_size > m_vAdjust->upper))
{
+ m_vAdjust->value = m_vAdjust->upper - m_vAdjust->page_size;
+ if (m_vAdjust->value < 0.0)
+ m_vAdjust->value = 0.0;
+
if (GetChildren().GetCount() == 0)
- {
- m_vAdjust->value = m_vAdjust->upper - m_vAdjust->page_size;
- m_yScrollPosition = (int)m_vAdjust->value;
- }
+ m_yScrollPosition = (int)m_vAdjust->value;
+ else
+ gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
}
}
- m_xScrollLinesPerPage = (int)(m_hAdjust->page_size + 0.5);
- m_yScrollLinesPerPage = (int)(m_vAdjust->page_size + 0.5);
+ m_xScrollLinesPerPage = (int)(m_hAdjust->page_increment + 0.5);
+ m_yScrollLinesPerPage = (int)(m_vAdjust->page_increment + 0.5);
gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "changed" );
gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "changed" );
m_targetWindow = target;
}
-wxWindow *wxScrolledWindow::GetTargetWindow()
+wxWindow *wxScrolledWindow::GetTargetWindow() const
{
return m_targetWindow;
}
// Override this function if you don't want to have wxScrolledWindow
// automatically change the origin according to the scroll position.
-void wxScrolledWindow::PrepareDC(wxDC& dc)
+void wxScrolledWindow::DoPrepareDC(wxDC& dc)
{
dc.SetDeviceOrigin( -m_xScrollPosition * m_xScrollPixelsPerLine,
-m_yScrollPosition * m_yScrollPixelsPerLine );
m_targetWindow->ScrollWindow( (old_x-m_xScrollPosition)*m_xScrollPixelsPerLine, 0 );
- // Just update the scrollbar, don't send any wxWindows event
+ // Just update the scrollbar, don't send any wxWidgets event
GtkHDisconnectEvent();
gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
GtkHConnectEvent();
m_targetWindow->ScrollWindow( 0, (old_y-m_yScrollPosition)*m_yScrollPixelsPerLine );
- // Just update the scrollbar, don't send any wxWindows event
+ // Just update the scrollbar, don't send any wxWidgets event
GtkVDisconnectEvent();
gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
GtkVConnectEvent();
void wxScrolledWindow::DoCalcScrolledPosition(int x, int y, int *xx, int *yy) const
{
+ int xs, ys;
+ GetViewStart (& xs, & ys);
+
if ( xx )
- *xx = x - m_xScrollPosition * m_xScrollPixelsPerLine;
+ *xx = x - xs * m_xScrollPixelsPerLine;
if ( yy )
- *yy = y - m_yScrollPosition * m_yScrollPixelsPerLine;
+ *yy = y - ys * m_yScrollPixelsPerLine;
}
void wxScrolledWindow::DoCalcUnscrolledPosition(int x, int y, int *xx, int *yy) const
{
+ int xs, ys;
+ GetViewStart (& xs, & ys);
+
if ( xx )
- *xx = x + m_xScrollPosition * m_xScrollPixelsPerLine;
+ *xx = x + xs * m_xScrollPixelsPerLine;
if ( yy )
- *yy = y + m_yScrollPosition * m_yScrollPixelsPerLine;
+ *yy = y + ys * m_yScrollPixelsPerLine;
}
int wxScrolledWindow::CalcScrollInc(wxScrollWinEvent& event)
{
if (orient == wxHORIZONTAL)
{
- // Just update the scrollbar, don't send any wxWindows event
+ // Just update the scrollbar, don't send any wxWidgets event
GtkHDisconnectEvent();
gtk_signal_emit_by_name( GTK_OBJECT(m_hAdjust), "value_changed" );
GtkHConnectEvent();
}
else
{
- // Just update the scrollbar, don't send any wxWindows event
+ // Just update the scrollbar, don't send any wxWidgets event
GtkVDisconnectEvent();
gtk_signal_emit_by_name( GTK_OBJECT(m_vAdjust), "value_changed" );
GtkVConnectEvent();
// Default OnSize resets scrollbars, if any
void wxScrolledWindow::OnSize(wxSizeEvent& WXUNUSED(event))
{
- if( m_targetWindow != this )
- m_targetWindow->SetVirtualSize( m_targetWindow->GetClientSize() );
-
- SetVirtualSize( GetClientSize() );
+ if ( m_targetWindow->GetAutoLayout() )
+ {
+ wxSize size = m_targetWindow->GetBestVirtualSize();
+
+ // This will call ::Layout() and ::AdjustScrollbars()
+ SetVirtualSize( size );
+ }
+ else
+ {
+ AdjustScrollbars();
+ }
}
// This calls OnDraw, having adjusted the origin according to the current
szx, szy, // view size (total)
clix, cliy; // view size (on screen)
- ViewStart(&stx, &sty);
+ GetViewStart(&stx, &sty);
GetClientSize(&clix, &cliy);
GetVirtualSize(&szx, &szy);
yScrollOld = GetScrollPos(wxVERTICAL);
int dsty;
- switch ( event.KeyCode() )
+ switch ( event.GetKeyCode() )
{
case WXK_PAGEUP:
case WXK_PRIOR:
projects / wxWidgets.git / blobdiff