| 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 bool Destroy(); |
| 49 | |
| 50 | virtual void Raise(); |
| 51 | virtual void Lower(); |
| 52 | |
| 53 | virtual bool Show( bool show = true ); |
| 54 | |
| 55 | virtual void SetWindowStyleFlag( long style ); |
| 56 | |
| 57 | virtual bool IsRetained() const; |
| 58 | |
| 59 | virtual void SetFocus(); |
| 60 | |
| 61 | // hint from wx to native GTK+ tab traversal code |
| 62 | virtual void SetCanFocus(bool canFocus); |
| 63 | |
| 64 | virtual bool Reparent( wxWindowBase *newParent ); |
| 65 | |
| 66 | virtual void WarpPointer(int x, int y); |
| 67 | |
| 68 | virtual void Refresh( bool eraseBackground = true, |
| 69 | const wxRect *rect = (const wxRect *) NULL ); |
| 70 | virtual void Update(); |
| 71 | virtual void ClearBackground(); |
| 72 | |
| 73 | virtual bool SetBackgroundColour( const wxColour &colour ); |
| 74 | virtual bool SetForegroundColour( const wxColour &colour ); |
| 75 | virtual bool SetCursor( const wxCursor &cursor ); |
| 76 | virtual bool SetFont( const wxFont &font ); |
| 77 | |
| 78 | virtual bool SetBackgroundStyle(wxBackgroundStyle style) ; |
| 79 | |
| 80 | virtual int GetCharHeight() const; |
| 81 | virtual int GetCharWidth() const; |
| 82 | |
| 83 | virtual void SetScrollbar( int orient, int pos, int thumbVisible, |
| 84 | int range, bool refresh = true ); |
| 85 | virtual void SetScrollPos( int orient, int pos, bool refresh = true ); |
| 86 | virtual int GetScrollPos( int orient ) const; |
| 87 | virtual int GetScrollThumb( int orient ) const; |
| 88 | virtual int GetScrollRange( int orient ) const; |
| 89 | virtual void ScrollWindow( int dx, int dy, |
| 90 | const wxRect* rect = NULL ); |
| 91 | virtual bool ScrollLines(int lines); |
| 92 | virtual bool ScrollPages(int pages); |
| 93 | |
| 94 | #if wxUSE_DRAG_AND_DROP |
| 95 | virtual void SetDropTarget( wxDropTarget *dropTarget ); |
| 96 | #endif // wxUSE_DRAG_AND_DROP |
| 97 | |
| 98 | virtual void AddChild( wxWindowBase *child ); |
| 99 | virtual void RemoveChild( wxWindowBase *child ); |
| 100 | |
| 101 | virtual void SetLayoutDirection(wxLayoutDirection dir); |
| 102 | virtual wxLayoutDirection GetLayoutDirection() const; |
| 103 | virtual wxCoord AdjustForLayoutDirection(wxCoord x, |
| 104 | wxCoord width, |
| 105 | wxCoord widthTotal) const; |
| 106 | |
| 107 | virtual bool DoIsExposed( int x, int y ) const; |
| 108 | virtual bool DoIsExposed( int x, int y, int w, int h ) const; |
| 109 | |
| 110 | // currently wxGTK2-only |
| 111 | void SetDoubleBuffered(bool on); |
| 112 | virtual bool IsDoubleBuffered() const; |
| 113 | |
| 114 | // SetLabel(), which does nothing in wxWindow |
| 115 | virtual void SetLabel(const wxString& label) { m_gtkLabel = label; } |
| 116 | virtual wxString GetLabel() const { return m_gtkLabel; } |
| 117 | |
| 118 | // implementation |
| 119 | // -------------- |
| 120 | |
| 121 | virtual WXWidget GetHandle() const { return m_widget; } |
| 122 | |
| 123 | // many important things are done here, this function must be called |
| 124 | // regularly |
| 125 | virtual void OnInternalIdle(); |
| 126 | |
| 127 | // For compatibility across platforms (not in event table) |
| 128 | void OnIdle(wxIdleEvent& WXUNUSED(event)) {} |
| 129 | |
| 130 | // Used by all window classes in the widget creation process. |
| 131 | bool PreCreation( wxWindowGTK *parent, const wxPoint &pos, const wxSize &size ); |
| 132 | void PostCreation(); |
| 133 | |
| 134 | // Internal addition of child windows |
| 135 | void DoAddChild(wxWindowGTK *child); |
| 136 | |
| 137 | // This methods sends wxPaintEvents to the window. It reads the |
| 138 | // update region, breaks it up into rects and sends an event |
| 139 | // for each rect. It is also responsible for background erase |
| 140 | // events and NC paint events. It is called from "draw" and |
| 141 | // "expose" handlers as well as from ::Update() |
| 142 | void GtkSendPaintEvents(); |
| 143 | |
| 144 | // The methods below are required because many native widgets |
| 145 | // are composed of several subwidgets and setting a style for |
| 146 | // the widget means setting it for all subwidgets as well. |
| 147 | // also, it is not clear which native widget is the top |
| 148 | // widget where (most of) the input goes. even tooltips have |
| 149 | // to be applied to all subwidgets. |
| 150 | virtual GtkWidget* GetConnectWidget(); |
| 151 | void ConnectWidget( GtkWidget *widget ); |
| 152 | |
| 153 | // Called from several event handlers, if it returns true or false, the |
| 154 | // same value should be immediately returned by the handler without doing |
| 155 | // anything else. If it returns -1, the handler should continue as usual |
| 156 | int GTKCallbackCommonPrologue(struct _GdkEventAny *event) const; |
| 157 | |
| 158 | // Simplified form of GTKCallbackCommonPrologue() which can be used from |
| 159 | // GTK callbacks without return value to check if the event should be |
| 160 | // ignored: if this returns true, the event shouldn't be handled |
| 161 | bool GTKShouldIgnoreEvent() const; |
| 162 | |
| 163 | |
| 164 | // override this if some events should never be consumed by wxWidgets but |
| 165 | // but have to be left for the native control |
| 166 | // |
| 167 | // base version just calls HandleWindowEvent() |
| 168 | virtual bool GTKProcessEvent(wxEvent& event) const; |
| 169 | |
| 170 | // Map GTK widget direction of the given widget to/from wxLayoutDirection |
| 171 | static wxLayoutDirection GTKGetLayout(GtkWidget *widget); |
| 172 | static void GTKSetLayout(GtkWidget *widget, wxLayoutDirection dir); |
| 173 | |
| 174 | // return true if this window must have a non-NULL parent, false if it can |
| 175 | // be created without parent (normally only top level windows but in wxGTK |
| 176 | // there is also the exception of wxMenuBar) |
| 177 | virtual bool GTKNeedsParent() const { return !IsTopLevel(); } |
| 178 | |
| 179 | // This is called when capture is taken from the window. It will |
| 180 | // fire off capture lost events. |
| 181 | void GTKReleaseMouseAndNotify(); |
| 182 | |
| 183 | GdkWindow* GTKGetDrawingWindow() const; |
| 184 | |
| 185 | bool GTKHandleFocusIn(); |
| 186 | bool GTKHandleFocusOut(); |
| 187 | void GTKHandleFocusOutNoDeferring(); |
| 188 | static void GTKHandleDeferredFocusOut(); |
| 189 | |
| 190 | protected: |
| 191 | // for controls composed of multiple GTK widgets, return true to eliminate |
| 192 | // spurious focus events if the focus changes between GTK+ children within |
| 193 | // the same wxWindow |
| 194 | virtual bool GTKNeedsToFilterSameWindowFocus() const { return false; } |
| 195 | |
| 196 | // Override GTKWidgetNeedsMnemonic and return true if your |
| 197 | // needs to set its mnemonic widget, such as for a |
| 198 | // GtkLabel for wxStaticText, then do the actual |
| 199 | // setting of the widget inside GTKWidgetDoSetMnemonic |
| 200 | virtual bool GTKWidgetNeedsMnemonic() const; |
| 201 | virtual void GTKWidgetDoSetMnemonic(GtkWidget* w); |
| 202 | |
| 203 | // Get the GdkWindows making part of this window: usually there will be |
| 204 | // only one of them in which case it should be returned directly by this |
| 205 | // function. If there is more than one GdkWindow (can be the case for |
| 206 | // composite widgets), return NULL and fill in the provided array |
| 207 | // |
| 208 | // This is not pure virtual for backwards compatibility but almost |
| 209 | // certainly must be overridden in any wxControl-derived class! |
| 210 | virtual GdkWindow *GTKGetWindow(wxArrayGdkWindows& windows) const; |
| 211 | |
| 212 | // Check if the given window makes part of this widget |
| 213 | bool GTKIsOwnWindow(GdkWindow *window) const; |
| 214 | |
| 215 | public: |
| 216 | // Returns the default context which usually is anti-aliased |
| 217 | PangoContext *GTKGetPangoDefaultContext(); |
| 218 | |
| 219 | #if wxUSE_TOOLTIPS |
| 220 | // applies tooltip to the widget (tip must be UTF-8 encoded) |
| 221 | virtual void GTKApplyToolTip(const char* tip); |
| 222 | #endif // wxUSE_TOOLTIPS |
| 223 | |
| 224 | // Called when a window should delay showing itself |
| 225 | // until idle time used in Reparent(). |
| 226 | void GTKShowOnIdle() { m_showOnIdle = true; } |
| 227 | |
| 228 | // This is called from the various OnInternalIdle methods |
| 229 | bool GTKShowFromOnIdle(); |
| 230 | |
| 231 | // is this window transparent for the mouse events (as wxStaticBox is)? |
| 232 | virtual bool GTKIsTransparentForMouse() const { return false; } |
| 233 | |
| 234 | // Common scroll event handling code for wxWindow and wxScrollBar |
| 235 | wxEventType GTKGetScrollEventType(GtkRange* range); |
| 236 | |
| 237 | // position and size of the window |
| 238 | int m_x, m_y; |
| 239 | int m_width, m_height; |
| 240 | int m_oldClientWidth,m_oldClientHeight; |
| 241 | |
| 242 | // see the docs in src/gtk/window.cpp |
| 243 | GtkWidget *m_widget; // mostly the widget seen by the rest of GTK |
| 244 | GtkWidget *m_wxwindow; // mostly the client area as per wxWidgets |
| 245 | |
| 246 | // label for use with GetLabelSetLabel |
| 247 | wxString m_gtkLabel; |
| 248 | |
| 249 | // return true if the window is of a standard (i.e. not wxWidgets') class |
| 250 | bool IsOfStandardClass() const { return m_wxwindow == NULL; } |
| 251 | |
| 252 | // this widget will be queried for GTK's focus events |
| 253 | GtkWidget *m_focusWidget; |
| 254 | |
| 255 | void GTKDisableFocusOutEvent(); |
| 256 | void GTKEnableFocusOutEvent(); |
| 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 | // set the current cursor for all GdkWindows making part of this widget |
| 287 | // (see GTKGetWindow) |
| 288 | void GTKUpdateCursor(bool update_self = true, bool recurse = true); |
| 289 | |
| 290 | // extra (wxGTK-specific) flags |
| 291 | bool m_noExpose:1; // wxGLCanvas has its own redrawing |
| 292 | bool m_nativeSizeEvent:1; // wxGLCanvas sends wxSizeEvent upon "alloc_size" |
| 293 | bool m_hasVMT:1; // set after PostCreation() is called |
| 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 | // implement the base class pure virtuals |
| 307 | virtual void DoGetTextExtent(const wxString& string, |
| 308 | int *x, int *y, |
| 309 | int *descent = NULL, |
| 310 | int *externalLeading = NULL, |
| 311 | const wxFont *font = NULL) const; |
| 312 | virtual void DoClientToScreen( int *x, int *y ) const; |
| 313 | virtual void DoScreenToClient( int *x, int *y ) const; |
| 314 | virtual void DoGetPosition( int *x, int *y ) const; |
| 315 | virtual void DoGetSize( int *width, int *height ) const; |
| 316 | virtual void DoGetClientSize( int *width, int *height ) const; |
| 317 | virtual void DoSetSize(int x, int y, |
| 318 | int width, int height, |
| 319 | int sizeFlags = wxSIZE_AUTO); |
| 320 | virtual void DoSetClientSize(int width, int height); |
| 321 | virtual wxSize DoGetBorderSize() const; |
| 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 | virtual void DoFreeze(); |
| 333 | virtual void DoThaw(); |
| 334 | |
| 335 | void GTKFreezeWidget(GtkWidget *w); |
| 336 | void GTKThawWidget(GtkWidget *w); |
| 337 | |
| 338 | #if wxUSE_TOOLTIPS |
| 339 | virtual void DoSetToolTip( wxToolTip *tip ); |
| 340 | #endif // wxUSE_TOOLTIPS |
| 341 | |
| 342 | // common part of all ctors (not virtual because called from ctor) |
| 343 | void Init(); |
| 344 | |
| 345 | virtual void DoMoveInTabOrder(wxWindow *win, WindowOrder move); |
| 346 | virtual bool DoNavigateIn(int flags); |
| 347 | |
| 348 | |
| 349 | // Copies m_children tab order to GTK focus chain: |
| 350 | void RealizeTabOrder(); |
| 351 | |
| 352 | // Called by ApplyWidgetStyle (which is called by SetFont() and |
| 353 | // SetXXXColour etc to apply style changed to native widgets) to create |
| 354 | // modified GTK style with non-standard attributes. If forceStyle=true, |
| 355 | // creates empty GtkRcStyle if there are no modifications, otherwise |
| 356 | // returns NULL in such case. |
| 357 | GtkRcStyle *GTKCreateWidgetStyle(bool forceStyle = false); |
| 358 | |
| 359 | // Overridden in many GTK widgets who have to handle subwidgets |
| 360 | virtual void GTKApplyWidgetStyle(bool forceStyle = false); |
| 361 | |
| 362 | // helper function to ease native widgets wrapping, called by |
| 363 | // ApplyWidgetStyle -- override this, not ApplyWidgetStyle |
| 364 | virtual void DoApplyWidgetStyle(GtkRcStyle *style); |
| 365 | |
| 366 | // sets the border of a given GtkScrolledWindow from a wx style |
| 367 | static void GTKScrolledWindowSetBorder(GtkWidget* w, int style); |
| 368 | |
| 369 | // Connect the given function to the specified signal on m_widget. |
| 370 | // |
| 371 | // This is just a wrapper for g_signal_connect() and returns the handler id |
| 372 | // just as it does. |
| 373 | gulong GTKConnectWidget(const char *signal, void (*callback)()); |
| 374 | |
| 375 | // Return true from here if PostCreation() should connect to size_request |
| 376 | // signal: this is done by default but doesn't work for some native |
| 377 | // controls which override this function to return false |
| 378 | virtual bool GTKShouldConnectSizeRequest() const { return !IsTopLevel(); } |
| 379 | |
| 380 | void ConstrainSize(); |
| 381 | |
| 382 | private: |
| 383 | enum ScrollUnit { ScrollUnit_Line, ScrollUnit_Page, ScrollUnit_Max }; |
| 384 | |
| 385 | // common part of ScrollLines() and ScrollPages() and could be used, in the |
| 386 | // future, for horizontal scrolling as well |
| 387 | // |
| 388 | // return true if we scrolled, false otherwise (on error or simply if we |
| 389 | // are already at the end) |
| 390 | bool DoScrollByUnits(ScrollDir dir, ScrollUnit unit, int units); |
| 391 | virtual void AddChildGTK(wxWindowGTK* child); |
| 392 | |
| 393 | |
| 394 | DECLARE_DYNAMIC_CLASS(wxWindowGTK) |
| 395 | wxDECLARE_NO_COPY_CLASS(wxWindowGTK); |
| 396 | }; |
| 397 | |
| 398 | #endif // _WX_GTK_WINDOW_H_ |