]>
Commit | Line | Data |
---|---|---|
c801d85f | 1 | ///////////////////////////////////////////////////////////////////////////// |
1e6feb95 | 2 | // Name: wx/gtk/window.h |
c801d85f KB |
3 | // Purpose: |
4 | // Author: Robert Roebling | |
58614078 RR |
5 | // Id: $Id$ |
6 | // Copyright: (c) 1998 Robert Roebling | |
65571936 | 7 | // Licence: wxWindows licence |
c801d85f KB |
8 | ///////////////////////////////////////////////////////////////////////////// |
9 | ||
ef5c70f9 VZ |
10 | #ifndef _WX_GTK_WINDOW_H_ |
11 | #define _WX_GTK_WINDOW_H_ | |
12 | ||
13 | #include "wx/dynarray.h" | |
c801d85f | 14 | |
a3c15d89 VS |
15 | // helper structure that holds class that holds GtkIMContext object and |
16 | // some additional data needed for key events processing | |
17 | struct wxGtkIMData; | |
18 | ||
ef5c70f9 VZ |
19 | WX_DEFINE_EXPORTED_ARRAY_PTR(GdkWindow *, wxArrayGdkWindows); |
20 | ||
6ca41e57 | 21 | //----------------------------------------------------------------------------- |
fd0eed64 | 22 | // callback definition for inserting a window (internal) |
6ca41e57 RR |
23 | //----------------------------------------------------------------------------- |
24 | ||
20123d49 | 25 | class WXDLLIMPEXP_CORE wxWindowGTK; |
1e6feb95 | 26 | typedef void (*wxInsertChildFunction)( wxWindowGTK*, wxWindowGTK* ); |
6ca41e57 | 27 | |
c801d85f | 28 | //----------------------------------------------------------------------------- |
1e6feb95 | 29 | // wxWindowGTK |
c801d85f KB |
30 | //----------------------------------------------------------------------------- |
31 | ||
20123d49 | 32 | class WXDLLIMPEXP_CORE wxWindowGTK : public wxWindowBase |
c801d85f | 33 | { |
aed8df38 | 34 | public: |
bfc6fde4 VZ |
35 | // creating the window |
36 | // ------------------- | |
1e6feb95 VZ |
37 | wxWindowGTK(); |
38 | wxWindowGTK(wxWindow *parent, | |
39 | wxWindowID id, | |
40 | const wxPoint& pos = wxDefaultPosition, | |
41 | const wxSize& size = wxDefaultSize, | |
42 | long style = 0, | |
43 | const wxString& name = wxPanelNameStr); | |
f03fc89f VZ |
44 | bool Create(wxWindow *parent, |
45 | wxWindowID id, | |
46 | const wxPoint& pos = wxDefaultPosition, | |
47 | const wxSize& size = wxDefaultSize, | |
48 | long style = 0, | |
49 | const wxString& name = wxPanelNameStr); | |
1e6feb95 | 50 | virtual ~wxWindowGTK(); |
cd0183ca | 51 | |
f03fc89f VZ |
52 | // implement base class (pure) virtual methods |
53 | // ------------------------------------------- | |
a264ece2 | 54 | |
4292eeb4 | 55 | virtual void SetLabel(const wxString& WXUNUSED(label)) { } |
5bc3865f | 56 | virtual wxString GetLabel() const { return wxEmptyString; } |
2ea5111b | 57 | |
bfc6fde4 | 58 | virtual bool Destroy(); |
bfc6fde4 | 59 | |
f03fc89f VZ |
60 | virtual void Raise(); |
61 | virtual void Lower(); | |
ff8bfdbb | 62 | |
5bc3865f | 63 | virtual bool Show( bool show = true ); |
47a8a4d5 | 64 | virtual void DoEnable( bool enable ); |
ff8bfdbb | 65 | |
015dca24 MR |
66 | virtual void SetWindowStyleFlag( long style ); |
67 | ||
f03fc89f | 68 | virtual bool IsRetained() const; |
2f2aa628 | 69 | |
bfc6fde4 | 70 | virtual void SetFocus(); |
80332672 | 71 | virtual void SetCanFocus(bool canFocus); |
ff8bfdbb | 72 | |
fdb7dadb | 73 | virtual bool Reparent( wxWindowBase *newParent ); |
ff8bfdbb | 74 | |
f03fc89f | 75 | virtual void WarpPointer(int x, int y); |
b1170810 | 76 | |
5bc3865f | 77 | virtual void Refresh( bool eraseBackground = true, |
f03fc89f | 78 | const wxRect *rect = (const wxRect *) NULL ); |
beab25bd | 79 | virtual void Update(); |
596f1d11 | 80 | virtual void ClearBackground(); |
bfc6fde4 | 81 | |
f03fc89f VZ |
82 | virtual bool SetBackgroundColour( const wxColour &colour ); |
83 | virtual bool SetForegroundColour( const wxColour &colour ); | |
84 | virtual bool SetCursor( const wxCursor &cursor ); | |
85 | virtual bool SetFont( const wxFont &font ); | |
cd0183ca | 86 | |
c7382f91 | 87 | virtual bool SetBackgroundStyle(wxBackgroundStyle style) ; |
f26623c8 | 88 | |
bfc6fde4 VZ |
89 | virtual int GetCharHeight() const; |
90 | virtual int GetCharWidth() const; | |
f03fc89f VZ |
91 | virtual void GetTextExtent(const wxString& string, |
92 | int *x, int *y, | |
93 | int *descent = (int *) NULL, | |
94 | int *externalLeading = (int *) NULL, | |
95 | const wxFont *theFont = (const wxFont *) NULL) | |
96 | const; | |
aed8df38 | 97 | |
f03fc89f | 98 | virtual void SetScrollbar( int orient, int pos, int thumbVisible, |
5bc3865f WS |
99 | int range, bool refresh = true ); |
100 | virtual void SetScrollPos( int orient, int pos, bool refresh = true ); | |
f03fc89f VZ |
101 | virtual int GetScrollPos( int orient ) const; |
102 | virtual int GetScrollThumb( int orient ) const; | |
103 | virtual int GetScrollRange( int orient ) const; | |
104 | virtual void ScrollWindow( int dx, int dy, | |
105 | const wxRect* rect = (wxRect *) NULL ); | |
0c131a5a VZ |
106 | virtual bool ScrollLines(int lines); |
107 | virtual bool ScrollPages(int pages); | |
8bbe427f | 108 | |
f03fc89f VZ |
109 | #if wxUSE_DRAG_AND_DROP |
110 | virtual void SetDropTarget( wxDropTarget *dropTarget ); | |
111 | #endif // wxUSE_DRAG_AND_DROP | |
f26623c8 | 112 | |
a589495e VS |
113 | virtual void AddChild( wxWindowBase *child ); |
114 | virtual void RemoveChild( wxWindowBase *child ); | |
8bbe427f | 115 | |
978af864 VZ |
116 | virtual void SetLayoutDirection(wxLayoutDirection dir); |
117 | virtual wxLayoutDirection GetLayoutDirection() const; | |
fe92a9d6 RR |
118 | virtual wxCoord AdjustForLayoutDirection(wxCoord x, |
119 | wxCoord width, | |
120 | wxCoord widthTotal) const; | |
978af864 | 121 | |
657b4fd4 RD |
122 | virtual bool DoIsExposed( int x, int y ) const; |
123 | virtual bool DoIsExposed( int x, int y, int w, int h ) const; | |
847dfdb4 | 124 | |
8e1a5bf9 VZ |
125 | // currently wxGTK2-only |
126 | void SetDoubleBuffered(bool on); | |
2e992e06 | 127 | virtual bool IsDoubleBuffered() const; |
8e1a5bf9 | 128 | |
f03fc89f VZ |
129 | // implementation |
130 | // -------------- | |
c801d85f | 131 | |
d7c24517 VZ |
132 | virtual WXWidget GetHandle() const { return m_widget; } |
133 | ||
ef5c70f9 VZ |
134 | // many important things are done here, this function must be called |
135 | // regularly | |
bfc6fde4 | 136 | virtual void OnInternalIdle(); |
ff8bfdbb | 137 | |
010afced RR |
138 | // Internal represention of Update() |
139 | void GtkUpdate(); | |
f26623c8 | 140 | |
beab25bd RR |
141 | // For compatibility across platforms (not in event table) |
142 | void OnIdle(wxIdleEvent& WXUNUSED(event)) {} | |
20e85460 | 143 | |
beab25bd | 144 | // Used by all window classes in the widget creation process. |
1e6feb95 | 145 | bool PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size ); |
bfc6fde4 | 146 | void PostCreation(); |
ff8bfdbb | 147 | |
beab25bd RR |
148 | // Internal addition of child windows. differs from class |
149 | // to class not by using virtual functions but by using | |
150 | // the m_insertCallback. | |
1e6feb95 | 151 | void DoAddChild(wxWindowGTK *child); |
f26623c8 | 152 | |
beab25bd RR |
153 | // This methods sends wxPaintEvents to the window. It reads the |
154 | // update region, breaks it up into rects and sends an event | |
155 | // for each rect. It is also responsible for background erase | |
156 | // events and NC paint events. It is called from "draw" and | |
157 | // "expose" handlers as well as from ::Update() | |
158 | void GtkSendPaintEvents(); | |
159 | ||
160 | // The methods below are required because many native widgets | |
161 | // are composed of several subwidgets and setting a style for | |
162 | // the widget means setting it for all subwidgets as well. | |
90e572f1 | 163 | // also, it is not clear which native widget is the top |
beab25bd RR |
164 | // widget where (most of) the input goes. even tooltips have |
165 | // to be applied to all subwidgets. | |
bfc6fde4 | 166 | virtual GtkWidget* GetConnectWidget(); |
bfc6fde4 | 167 | void ConnectWidget( GtkWidget *widget ); |
8bbe427f | 168 | |
5478f221 VZ |
169 | // Called from several event handlers, if it returns true or false, the |
170 | // same value should be immediately returned by the handler without doing | |
171 | // anything else. If it returns -1, the handler should continue as usual | |
172 | int GTKCallbackCommonPrologue(struct _GdkEventAny *event) const; | |
ef5c70f9 | 173 | |
97687291 VZ |
174 | // override this if some events should never be consumed by wxWidgets but |
175 | // but have to be left for the native control | |
176 | // | |
177 | // base version just does GetEventHandler()->ProcessEvent() | |
178 | virtual bool GTKProcessEvent(wxEvent& event) const; | |
179 | ||
978af864 VZ |
180 | // Map GTK widget direction of the given widget to/from wxLayoutDirection |
181 | static wxLayoutDirection GTKGetLayout(GtkWidget *widget); | |
182 | static void GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir); | |
183 | ||
cb3db090 | 184 | protected: |
2e1f5012 | 185 | // Override GTKWidgetNeedsMnemonic and return true if your |
28e88942 | 186 | // needs to set its mnemonic widget, such as for a |
2e1f5012 VZ |
187 | // GtkLabel for wxStaticText, then do the actual |
188 | // setting of the widget inside GTKWidgetDoSetMnemonic | |
189 | virtual bool GTKWidgetNeedsMnemonic() const; | |
190 | virtual void GTKWidgetDoSetMnemonic(GtkWidget* w); | |
191 | ||
ef5c70f9 VZ |
192 | // Get the GdkWindows making part of this window: usually there will be |
193 | // only one of them in which case it should be returned directly by this | |
194 | // function. If there is more than one GdkWindow (can be the case for | |
195 | // composite widgets), return NULL and fill in the provided array | |
196 | // | |
197 | // This is not pure virtual for backwards compatibility but almost | |
198 | // certainly must be overridden in any wxControl-derived class! | |
199 | virtual GdkWindow *GTKGetWindow(wxArrayGdkWindows& windows) const; | |
200 | ||
201 | // Check if the given window makes part of this widget | |
202 | bool GTKIsOwnWindow(GdkWindow *window) const; | |
203 | ||
204 | // Set the focus to this window if its setting was delayed because the | |
205 | // widget hadn't been realized when SetFocus() was called | |
206 | // | |
207 | // Return true if focus was set to us, false if nothing was done | |
208 | bool GTKSetDelayedFocusIfNeeded(); | |
209 | ||
cb3db090 | 210 | public: |
2b5f62a0 VZ |
211 | // Returns the default context which usually is anti-aliased |
212 | PangoContext *GtkGetPangoDefaultContext(); | |
2b5f62a0 | 213 | |
ff8bfdbb | 214 | #if wxUSE_TOOLTIPS |
74ce55e9 | 215 | virtual void ApplyToolTip( GtkTooltips *tips, const wxChar *tip ); |
ff8bfdbb | 216 | #endif // wxUSE_TOOLTIPS |
301cd871 | 217 | |
90e572f1 | 218 | // Called from GTK signal handlers. it indicates that |
739730ca RR |
219 | // the layouting functions have to be called later on |
220 | // (i.e. in idle time, implemented in OnInternalIdle() ). | |
5bc3865f | 221 | void GtkUpdateSize() { m_sizeSet = false; } |
28e88942 VZ |
222 | |
223 | ||
f46ad98f RR |
224 | // Called when a window should delay showing itself |
225 | // until idle time. This partly mimmicks defered | |
226 | // sizing under MSW. | |
227 | void GtkShowOnIdle() { m_showOnIdle = true; } | |
28e88942 | 228 | |
7317857d RR |
229 | // This is called from the various OnInternalIdle methods |
230 | bool GtkShowFromOnIdle(); | |
94633ad9 | 231 | |
3ae4c570 VZ |
232 | // fix up the mouse event coords, used by wxListBox only so far |
233 | virtual void FixUpMouseEvent(GtkWidget * WXUNUSED(widget), | |
234 | wxCoord& WXUNUSED(x), | |
235 | wxCoord& WXUNUSED(y)) { } | |
236 | ||
d1f2ac45 | 237 | // is this window transparent for the mouse events (as wxStaticBox is)? |
5bc3865f | 238 | virtual bool IsTransparentForMouse() const { return false; } |
d1f2ac45 | 239 | |
2b4f3c9f | 240 | // is this a radiobutton (used by radiobutton code itself only)? |
5bc3865f | 241 | virtual bool IsRadioButton() const { return false; } |
2b4f3c9f | 242 | |
add7cadd PC |
243 | // Common scroll event handling code for wxWindow and wxScrollBar |
244 | wxEventType GetScrollEventType(GtkRange* range); | |
245 | ||
a01ed326 PC |
246 | void BlockScrollEvent(); |
247 | void UnblockScrollEvent(); | |
248 | ||
f03fc89f VZ |
249 | // position and size of the window |
250 | int m_x, m_y; | |
251 | int m_width, m_height; | |
5b8a521e | 252 | int m_oldClientWidth,m_oldClientHeight; |
bcf1fa6b | 253 | |
76fcf0f2 RR |
254 | // see the docs in src/gtk/window.cpp |
255 | GtkWidget *m_widget; // mostly the widget seen by the rest of GTK | |
77ffb593 | 256 | GtkWidget *m_wxwindow; // mostly the client area as per wxWidgets |
94633ad9 | 257 | |
76fcf0f2 RR |
258 | // this widget will be queried for GTK's focus events |
259 | GtkWidget *m_focusWidget; | |
f03fc89f | 260 | |
a3c15d89 | 261 | wxGtkIMData *m_imData; |
3bcc8d15 | 262 | |
22c9b211 VZ |
263 | |
264 | // indices for the arrays below | |
265 | enum ScrollDir { ScrollDir_Horz, ScrollDir_Vert, ScrollDir_Max }; | |
266 | ||
add7cadd | 267 | // horizontal/vertical scroll bar |
22c9b211 VZ |
268 | GtkRange* m_scrollBar[ScrollDir_Max]; |
269 | ||
add7cadd | 270 | // horizontal/vertical scroll position |
22c9b211 VZ |
271 | double m_scrollPos[ScrollDir_Max]; |
272 | ||
273 | // if true, don't notify about adjustment change (without resetting the | |
274 | // flag, so this has to be done manually) | |
275 | bool m_blockValueChanged[ScrollDir_Max]; | |
276 | ||
277 | // return the scroll direction index corresponding to the given orientation | |
278 | // (which is wxVERTICAL or wxHORIZONTAL) | |
279 | static ScrollDir ScrollDirFromOrient(int orient) | |
280 | { | |
281 | return orient == wxVERTICAL ? ScrollDir_Vert : ScrollDir_Horz; | |
282 | } | |
283 | ||
284 | // return the orientation for the given scrolling direction | |
285 | static int OrientFromScrollDir(ScrollDir dir) | |
286 | { | |
287 | return dir == ScrollDir_Horz ? wxHORIZONTAL : wxVERTICAL; | |
288 | } | |
289 | ||
290 | // find the direction of the given scrollbar (must be one of ours) | |
291 | ScrollDir ScrollDirFromRange(GtkRange *range) const; | |
292 | ||
739730ca | 293 | |
f03fc89f | 294 | // extra (wxGTK-specific) flags |
76fcf0f2 RR |
295 | bool m_needParent:1; // ! wxFrame, wxDialog, wxNotebookPage ? |
296 | bool m_noExpose:1; // wxGLCanvas has its own redrawing | |
297 | bool m_nativeSizeEvent:1; // wxGLCanvas sends wxSizeEvent upon "alloc_size" | |
f03fc89f | 298 | bool m_hasScrolling:1; |
f03fc89f VZ |
299 | bool m_hasVMT:1; |
300 | bool m_sizeSet:1; | |
301 | bool m_resizing:1; | |
6cad4f1b VZ |
302 | bool m_hasFocus:1; // true if == FindFocus() |
303 | bool m_isScrolling:1; // dragging scrollbar thumb? | |
5bc3865f | 304 | bool m_clipPaintRegion:1; // true after ScrollWindow() |
bcb614b3 | 305 | wxRegion m_nativeUpdateRegion; // not transformed for RTL |
a589495e VS |
306 | bool m_dirtyTabOrder:1; // tab order changed, GTK focus |
307 | // chain needs update | |
c7382f91 JS |
308 | bool m_needsStyleChange:1; // May not be able to change |
309 | // background style until OnIdle | |
add7cadd PC |
310 | bool m_mouseButtonDown:1; |
311 | bool m_blockScrollEvent:1; | |
28e88942 | 312 | |
f46ad98f | 313 | bool m_showOnIdle:1; // postpone showing the window until idle |
7af6f327 | 314 | |
d7c24517 VZ |
315 | // C++ has no virtual methods in the constrcutor of any class but we need |
316 | // different methods of inserting a child window into a wxFrame, | |
317 | // wxMDIFrame, wxNotebook etc. this is the callback that will get used. | |
f03fc89f | 318 | wxInsertChildFunction m_insertCallback; |
68995f26 | 319 | |
6f02a879 | 320 | protected: |
f03fc89f | 321 | // implement the base class pure virtuals |
dabc0cd5 VZ |
322 | virtual void DoClientToScreen( int *x, int *y ) const; |
323 | virtual void DoScreenToClient( int *x, int *y ) const; | |
f03fc89f VZ |
324 | virtual void DoGetPosition( int *x, int *y ) const; |
325 | virtual void DoGetSize( int *width, int *height ) const; | |
326 | virtual void DoGetClientSize( int *width, int *height ) const; | |
bfc6fde4 VZ |
327 | virtual void DoSetSize(int x, int y, |
328 | int width, int height, | |
329 | int sizeFlags = wxSIZE_AUTO); | |
bfc6fde4 | 330 | virtual void DoSetClientSize(int width, int height); |
9d9b7755 | 331 | virtual void DoMoveWindow(int x, int y, int width, int height); |
aed8df38 | 332 | |
6f02a879 VZ |
333 | #if wxUSE_MENUS_NATIVE |
334 | virtual bool DoPopupMenu( wxMenu *menu, int x, int y ); | |
335 | #endif // wxUSE_MENUS_NATIVE | |
336 | ||
94633ad9 VZ |
337 | virtual void DoCaptureMouse(); |
338 | virtual void DoReleaseMouse(); | |
f26623c8 | 339 | |
f03fc89f VZ |
340 | #if wxUSE_TOOLTIPS |
341 | virtual void DoSetToolTip( wxToolTip *tip ); | |
342 | #endif // wxUSE_TOOLTIPS | |
343 | ||
3ae4c570 | 344 | // common part of all ctors (not virtual because called from ctor) |
f03fc89f | 345 | void Init(); |
f26623c8 | 346 | |
a589495e | 347 | virtual void DoMoveInTabOrder(wxWindow *win, MoveKind move); |
5644933f VZ |
348 | virtual bool DoNavigateIn(int flags); |
349 | ||
a589495e VS |
350 | |
351 | // Copies m_children tab order to GTK focus chain: | |
352 | void RealizeTabOrder(); | |
f26623c8 | 353 | |
f40fdaa3 VS |
354 | // Called by ApplyWidgetStyle (which is called by SetFont() and |
355 | // SetXXXColour etc to apply style changed to native widgets) to create | |
5edef14e VS |
356 | // modified GTK style with non-standard attributes. If forceStyle=true, |
357 | // creates empty GtkRcStyle if there are no modifications, otherwise | |
358 | // returns NULL in such case. | |
359 | GtkRcStyle *CreateWidgetStyle(bool forceStyle = false); | |
f40fdaa3 VS |
360 | |
361 | // Overridden in many GTK widgets who have to handle subwidgets | |
5edef14e | 362 | virtual void ApplyWidgetStyle(bool forceStyle = false); |
f26623c8 | 363 | |
5bc3865f | 364 | // helper function to ease native widgets wrapping, called by |
7074ce35 VS |
365 | // ApplyWidgetStyle -- override this, not ApplyWidgetStyle |
366 | virtual void DoApplyWidgetStyle(GtkRcStyle *style); | |
f03fc89f | 367 | |
6493aaca VZ |
368 | // sets the border of a given GtkScrolledWindow from a wx style |
369 | static void GtkScrolledWindowSetBorder(GtkWidget* w, int style); | |
370 | ||
ef5c70f9 VZ |
371 | // set the current cursor for all GdkWindows making part of this widget |
372 | // (see GTKGetWindow) | |
2f262021 | 373 | // |
ef5c70f9 VZ |
374 | // should be called from OnInternalIdle() if it's overridden |
375 | void GTKUpdateCursor(); | |
376 | ||
68dda785 | 377 | private: |
22c9b211 VZ |
378 | enum ScrollUnit { ScrollUnit_Line, ScrollUnit_Page, ScrollUnit_Max }; |
379 | ||
380 | // common part of ScrollLines() and ScrollPages() and could be used, in the | |
381 | // future, for horizontal scrolling as well | |
382 | // | |
383 | // return true if we scrolled, false otherwise (on error or simply if we | |
384 | // are already at the end) | |
385 | bool DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units); | |
386 | ||
387 | ||
1e6feb95 | 388 | DECLARE_DYNAMIC_CLASS(wxWindowGTK) |
1a0d517e | 389 | DECLARE_NO_COPY_CLASS(wxWindowGTK) |
c801d85f KB |
390 | }; |
391 | ||
20123d49 | 392 | extern WXDLLIMPEXP_CORE wxWindow *wxFindFocusedChild(wxWindowGTK *win); |
3379ed37 | 393 | |
ef5c70f9 | 394 | #endif // _WX_GTK_WINDOW_H_ |