git.saurik.com Git - wxWidgets.git/blob - include/wx/univ/scrolbar.h

1 ///////////////////////////////////////////////////////////////////////////////

2 // Name: wx/univ/scrolbar.h

3 // Purpose: wxScrollBar for wxUniversal

4 // Author: Vadim Zeitlin

5 // Modified by:

6 // Created: 20.08.00

8 // Licence: wxWindows licence

9 ///////////////////////////////////////////////////////////////////////////////

11 #ifndef _WX_UNIV_SCROLBAR_H_

12 #define _WX_UNIV_SCROLBAR_H_

14 class WXDLLIMPEXP_FWD_CORE wxScrollTimer;

16 #include "wx/univ/scrarrow.h"

17 #include "wx/renderer.h"

19 // ----------------------------------------------------------------------------

20 // the actions supported by this control

21 // ----------------------------------------------------------------------------

23 // scroll the bar

24 #define wxACTION_SCROLL_START wxT("start") // to the beginning

 #define wxACTION_SCROLL_END         wxT("end")       // to the end

 #define wxACTION_SCROLL_LINE_UP     wxT("lineup")    // one line up/left

 #define wxACTION_SCROLL_PAGE_UP     wxT("pageup")    // one page up/left

 #define wxACTION_SCROLL_LINE_DOWN   wxT("linedown")  // one line down/right

 #define wxACTION_SCROLL_PAGE_DOWN   wxT("pagedown")  // one page down/right

31 // the scrollbar thumb may be dragged

32 #define wxACTION_SCROLL_THUMB_DRAG wxT("thumbdrag")

33 #define wxACTION_SCROLL_THUMB_MOVE wxT("thumbmove")

34 #define wxACTION_SCROLL_THUMB_RELEASE wxT("thumbrelease")

36 // ----------------------------------------------------------------------------

37 // wxScrollBar

38 // ----------------------------------------------------------------------------

40 class WXDLLIMPEXP_CORE wxScrollBar : public wxScrollBarBase,

41 public wxControlWithArrows

42 {

43 public:

44 // scrollbar elements: they correspond to wxHT_SCROLLBAR_XXX constants but

45 // start from 0 which allows to use them as array indices

46 enum Element

47 {

48 Element_Arrow_Line_1,

49 Element_Arrow_Line_2,

50 Element_Arrow_Page_1,

51 Element_Arrow_Page_2,

52 Element_Thumb,

53 Element_Bar_1,

54 Element_Bar_2,

55 Element_Max

56 };

58 wxScrollBar();

59 wxScrollBar(wxWindow *parent,

60 wxWindowID id,

61 const wxPoint& pos = wxDefaultPosition,

62 const wxSize& size = wxDefaultSize,

63 long style = wxSB_HORIZONTAL,

64 const wxValidator& validator = wxDefaultValidator,

65 const wxString& name = wxScrollBarNameStr);

     bool Create(wxWindow *parent,

68 wxWindowID id,

69 const wxPoint& pos = wxDefaultPosition,

70 const wxSize& size = wxDefaultSize,

71 long style = wxSB_HORIZONTAL,

72 const wxValidator& validator = wxDefaultValidator,

73 const wxString& name = wxScrollBarNameStr);

75 virtual ~wxScrollBar();

77 // implement base class pure virtuals

     virtual int GetThumbPosition() const;

     virtual int GetThumbSize() const;

     virtual int GetPageSize() const;

     virtual int GetRange() const;

     virtual void SetThumbPosition(int thumbPos);

     virtual void SetScrollbar(int position, int thumbSize,

85 int range, int pageSize,

86 bool refresh = true);

88 // wxScrollBar actions

89 void ScrollToStart();

90 void ScrollToEnd();

     bool ScrollLines(int nLines);

     bool ScrollPages(int nPages);

     virtual bool PerformAction(const wxControlAction& action,

95 long numArg = 0,

96 const wxString& strArg = wxEmptyString);

     static wxInputHandler *GetStdInputHandler(wxInputHandler *handlerDef);

     virtual wxInputHandler *DoGetStdInputHandler(wxInputHandler *handlerDef)

100 {

101 return GetStdInputHandler(handlerDef);

102 }

103

104 // scrollbars around a normal window should not receive the focus

     virtual bool AcceptsFocus() const;

106

107 // wxScrollBar sub elements state (combination of wxCONTROL_XXX)

     void SetState(Element which, int flags);

     int GetState(Element which) const;

110

111 // implement wxControlWithArrows methods

     virtual wxRenderer *GetRenderer() const { return m_renderer; }

     virtual wxWindow *GetWindow() { return this; }

     virtual bool IsVertical() const { return wxScrollBarBase::IsVertical(); }

     virtual int GetArrowState(wxScrollArrows::Arrow arrow) const;

     virtual void SetArrowFlag(wxScrollArrows::Arrow arrow, int flag, bool set);

     virtual bool OnArrow(wxScrollArrows::Arrow arrow);

     virtual wxScrollArrows::Arrow HitTestArrow(const wxPoint& pt) const;

119

120 // for wxControlRenderer::DrawScrollbar() only

     const wxScrollArrows& GetArrows() const { return m_arrows; }

122

123 // returns one of wxHT_SCROLLBAR_XXX constants

     wxHitTest HitTestBar(const wxPoint& pt) const;

125

126 // idle processing

127 virtual void OnInternalIdle();

128

129 protected:

     virtual wxSize DoGetBestClientSize() const;

     virtual void DoDraw(wxControlRenderer *renderer);

     virtual wxBorder GetDefaultBorder() const { return wxBORDER_NONE; }

133

134 // forces update of thumb's visual appearence (does nothing if m_dirty=false)

135 void UpdateThumb();

136

137 // SetThumbPosition() helper

     void DoSetThumb(int thumbPos);

139

140 // common part of all ctors

141 void Init();

142

143 // is this scrollbar attached to a window or a standalone control?

     bool IsStandalone() const;

145

146 // scrollbar geometry methods:

147

148 // gets the bounding box for a scrollbar element for the given (by default

149 // - current) thumb position

     wxRect GetScrollbarRect(wxScrollBar::Element elem, int thumbPos = -1) const;

151

152 // returns the size of the scrollbar shaft excluding the arrows

153 wxCoord GetScrollbarSize() const;

154

155 // translate the scrollbar position (in logical units) into physical

156 // coordinate (in pixels) and the other way round

     wxCoord ScrollbarToPixel(int thumbPos = -1);

158 int PixelToScrollbar(wxCoord coord);

159

160 // return the starting and ending positions, in pixels, of the thumb of a

161 // scrollbar with the given logical position, thumb size and range and the

162 // given physical length

163 static void GetScrollBarThumbSize(wxCoord length,

164 int thumbPos,

165 int thumbSize,

166 int range,

167 wxCoord *thumbStart,

168 wxCoord *thumbEnd);

169

170 private:

171 // total range of the scrollbar in logical units

172 int m_range;

173

174 // the current and previous (after last refresh - this is used for

175 // repainting optimisation) size of the thumb in logical units (from 0 to

176 // m_range) and its position (from 0 to m_range - m_thumbSize)

177 int m_thumbSize,

178 m_thumbPos,

179 m_thumbPosOld;

180

181 // the page size, i.e. the number of lines by which to scroll when page

182 // up/down action is performed

183 int m_pageSize;

184

185 // the state of the sub elements

186 int m_elementsState[Element_Max];

187

188 // the dirty flag: if set, scrollbar must be updated

189 bool m_dirty;

190

191 // the object handling the arrows

192 wxScrollArrows m_arrows;

193

194 friend WXDLLIMPEXP_CORE class wxControlRenderer; // for geometry methods

195 friend class wxStdScrollBarInputHandler; // for geometry methods

196

197 DECLARE_EVENT_TABLE()

198 DECLARE_DYNAMIC_CLASS(wxScrollBar)

199 };

200

201 // ----------------------------------------------------------------------------

202 // Standard scrollbar input handler which can be used as a base class

203 // ----------------------------------------------------------------------------

204

205 class WXDLLIMPEXP_CORE wxStdScrollBarInputHandler : public wxStdInputHandler

206 {

207 public:

208 // constructor takes a renderer (used for scrollbar hit testing) and the

209 // base handler to which all unhandled events are forwarded

210 wxStdScrollBarInputHandler(wxRenderer *renderer,

211 wxInputHandler *inphand);

212

     virtual bool HandleKey(wxInputConsumer *consumer,

214 const wxKeyEvent& event,

215 bool pressed);

     virtual bool HandleMouse(wxInputConsumer *consumer,

217 const wxMouseEvent& event);

     virtual bool HandleMouseMove(wxInputConsumer *consumer, const wxMouseEvent& event);

219

220 virtual ~wxStdScrollBarInputHandler();

221

222 // this method is called by wxScrollBarTimer only and may be overridden

223 //

224 // return true to continue scrolling, false to stop the timer

     virtual bool OnScrollTimer(wxScrollBar *scrollbar,

226 const wxControlAction& action);

227

228 protected:

229 // return true if the mouse button can be used to activate scrollbar, false

230 // if not (any button under GTK+ unlike left button only which is default)

     virtual bool IsAllowedButton(int button) const

232 { return button == wxMOUSE_BTN_LEFT; }

233

234 // set or clear the specified flag on the scrollbar element corresponding

235 // to m_htLast

     void SetElementState(wxScrollBar *scrollbar, int flag, bool doIt);

237

238 // [un]highlight the scrollbar element corresponding to m_htLast

     virtual void Highlight(wxScrollBar *scrollbar, bool doIt)

         { SetElementState(scrollbar, wxCONTROL_CURRENT, doIt); }

241

242 // [un]press the scrollbar element corresponding to m_htLast

     virtual void Press(wxScrollBar *scrollbar, bool doIt)

         { SetElementState(scrollbar, wxCONTROL_PRESSED, doIt); }

245

246 // stop scrolling because we reached the end point

     void StopScrolling(wxScrollBar *scrollbar);

248

249 // get the mouse coordinates in the scrollbar direction from the event

     wxCoord GetMouseCoord(const wxScrollBar *scrollbar,

                           const wxMouseEvent& event) const;

252

253 // generate a "thumb move" action for this mouse event

     void HandleThumbMove(wxScrollBar *scrollbar, const wxMouseEvent& event);

255

256

257 // the window (scrollbar) which has capture or NULL and the flag telling if

258 // the mouse is inside the element which captured it or not

259 wxWindow *m_winCapture;

260 bool m_winHasMouse;

261 int m_btnCapture; // the mouse button which has captured mouse

262

263 // the position where we started scrolling by page

264 wxPoint m_ptStartScrolling;

265

266 // one of wxHT_SCROLLBAR_XXX value: where has the mouse been last time?

267 wxHitTest m_htLast;

268

269 // the renderer (we use it only for hit testing)

270 wxRenderer *m_renderer;

271

272 // the offset of the top/left of the scrollbar relative to the mouse to

273 // keep during the thumb drag

274 int m_ofsMouse;

275

276 // the timer for generating scroll events when the mouse stays pressed on

277 // a scrollbar

278 wxScrollTimer *m_timerScroll;

279 };

280

281 #endif // _WX_UNIV_SCROLBAR_H_

282