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