1 // Generated by gmmproc 2.60.0 -- DO NOT MODIFY! 2 #ifndef _GTKMM_GESTURE_H 3 #define _GTKMM_GESTURE_H 4 5 6 #include <glibmm/ustring.h> 7 #include <sigc++/sigc++.h> 8 9 /* Copyright (C) 2014 The gtkmm Development Team 10 * 11 * This library is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU Lesser General Public 13 * License as published by the Free Software Foundation; either 14 * version 2.1 of the License, or (at your option) any later version. 15 * 16 * This library is distributed in the hope that it will be useful, 17 * but WITHOUT ANY WARRANTY; without even the implied warranty of 18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 19 * Lesser General Public License for more details. 20 * 21 * You should have received a copy of the GNU Lesser General Public 22 * License along with this library. If not, see <http://www.gnu.org/licenses/>. 23 */ 24 25 #include <vector> 26 #include <gtkmm/eventcontroller.h> 27 28 29 #ifndef DOXYGEN_SHOULD_SKIP_THIS 30 using GtkGesture = struct _GtkGesture; 31 using GtkGestureClass = struct _GtkGestureClass; 32 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 33 34 35 #ifndef DOXYGEN_SHOULD_SKIP_THIS 36 namespace Gtk 37 { class Gesture_Class; } // namespace Gtk 38 #endif //DOXYGEN_SHOULD_SKIP_THIS 39 40 namespace Gtk 41 { 42 /** @addtogroup gtkmmEnums gtkmm Enums and Flags */ 43 44 /** 45 * @var EventSequenceState EVENT_SEQUENCE_NONE 46 * The sequence is handled, but not grabbed. 47 * 48 * @var EventSequenceState EVENT_SEQUENCE_CLAIMED 49 * The sequence is handled and grabbed. 50 * 51 * @var EventSequenceState EVENT_SEQUENCE_DENIED 52 * The sequence is denied. 53 * 54 * @enum EventSequenceState 55 * 56 * Describes the state of a Gdk::EventSequence in a Gtk::Gesture. 57 * 58 * @newin{3,14} 59 * 60 * @ingroup gtkmmEnums 61 */ 62 enum EventSequenceState 63 { 64 EVENT_SEQUENCE_NONE, 65 EVENT_SEQUENCE_CLAIMED, 66 EVENT_SEQUENCE_DENIED 67 }; 68 69 } // namespace Gtk 70 71 #ifndef DOXYGEN_SHOULD_SKIP_THIS 72 namespace Glib 73 { 74 75 template <> 76 class Value<Gtk::EventSequenceState> : public Glib::Value_Enum<Gtk::EventSequenceState> 77 { 78 public: 79 static GType value_type() G_GNUC_CONST; 80 }; 81 82 } // namespace Glib 83 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 84 85 namespace Gtk 86 { 87 88 89 /** Abstract base class for gestures. 90 * 91 * This is the base object for gesture recognition. Although this 92 * object is quite generalized to serve as a base for multi-touch gestures, 93 * it is suitable to implement single-touch and pointer-based gestures (using 94 * the special GdkEventSequence value for these). 95 * 96 * The number of touches that a Gesture need to be recognized is controlled 97 * by the n-points property. If a gesture is keeping track of less 98 * or more than that number of sequences, it won't check whether the gesture 99 * is recognized. 100 * 101 * As soon as the gesture has the expected number of touches, the gesture will 102 * run check signal regularly on input events until the gesture 103 * is recognized. The criteria to consider a gesture as "recognized" is left to 104 * Gesture subclasses. 105 * 106 * A recognized gesture will then emit the following signals: 107 * - signal_begin() when the gesture is recognized. 108 * - A number of signal_update(), whenever an input event is processed. 109 * - signal_end() when the gesture is no longer recognized. 110 * 111 * <h2>Event propagation</h2> 112 * 113 * In order to receive events, a gesture needs to either set a propagation phase 114 * through EventController::set_propagation_phase(), or feed those manually 115 * through EventController::handle_event(). 116 * 117 * In the capture phase, events are propagated from the toplevel down to the 118 * target widget, and gestures that are attached to containers above the widget 119 * get a chance to interact with the event before it reaches the target. 120 * 121 * After the capture phase, GTK+ emits the traditional Widget::signal_button_press_event(), 122 * Widget::signal_button_release_event(), Widget::signal_touch_event(), etc. Gestures 123 * with the Gtk::PHASE_TARGET phase are fed events from the default 124 * Widget::signal_event() handlers. 125 * 126 * In the bubble phase, events are propagated up from the target widget to the 127 * toplevel, and gestures that are attached to containers above the widget get 128 * a chance to interact with events that have not been handled yet. 129 * 130 * <h2>States of a sequence</h2> 131 * 132 * Whenever input interaction happens, a single event may trigger a cascade of 133 * Gesture%s, both across the parents of the widget receiving the 134 * event and parallelly within an individual widget. It is a responsibility of the 135 * widgets using those gestures to set the state of touch sequences accordingly 136 * in order to enable cooperation of gestures around the GdkEventSequence%s 137 * triggering those. 138 * 139 * Within a widget, gestures can be grouped through group(). 140 * Grouped gestures synchronize the state of sequences, so calling 141 * set_sequence_state() on one will effectively propagate 142 * the state throughout the group. 143 * 144 * By default, all sequences start out in the Gtk::EVENT_SEQUENCE_NONE state. 145 * Sequences in this state trigger the gesture event handler, but event 146 * propagation will continue unstopped by gestures. 147 * 148 * If a sequence enters into the Gtk::EVENT_SEQUENCE_DENIED state, the gesture 149 * group will effectively ignore the sequence, letting events go unstopped 150 * through the gesture, but the "slot" will still remain occupied while 151 * the touch is active. 152 * 153 * If a sequence enters in the Gtk::EVENT_SEQUENCE_CLAIMED state, the gesture 154 * group will grab all interaction on the sequence, by: 155 * - Setting the same sequence to Gtk::EVENT_SEQUENCE_DENIED on every other gesture 156 * group within the widget, and every gesture on parent widgets in the propagation 157 * chain. 158 * - emitting signal_cancel() on every gesture in widgets underneath in the 159 * propagation chain. 160 * - Stopping event propagation after the gesture group handles the event. 161 * 162 * @note If a sequence is set early to Gtk::EVENT_SEQUENCE_CLAIMED on 163 * Gdk::TOUCH_BEGIN/Gdk::BUTTON_PRESS (so those events are captured before 164 * reaching the event widget, this implies Gtk::PHASE_CAPTURE), one similar 165 * event will be emulated if the sequence changes to Gtk::EVENT_SEQUENCE_DENIED. 166 * This way event coherence is preserved before event propagation is unstopped 167 * again. 168 * 169 * Sequence states can't be changed freely, see set_sequence_state() 170 * to know about the possible lifetimes of a GdkEventSequence. 171 * 172 * @newin{3,14} 173 * 174 * @ingroup Gestures 175 */ 176 177 class Gesture : public EventController 178 { 179 180 #ifndef DOXYGEN_SHOULD_SKIP_THIS 181 182 public: 183 using CppObjectType = Gesture; 184 using CppClassType = Gesture_Class; 185 using BaseObjectType = GtkGesture; 186 using BaseClassType = GtkGestureClass; 187 188 // noncopyable 189 Gesture(const Gesture&) = delete; 190 Gesture& operator=(const Gesture&) = delete; 191 192 private: friend class Gesture_Class; 193 static CppClassType gesture_class_; 194 195 protected: 196 explicit Gesture(const Glib::ConstructParams& construct_params); 197 explicit Gesture(GtkGesture* castitem); 198 199 #endif /* DOXYGEN_SHOULD_SKIP_THIS */ 200 201 public: 202 203 Gesture(Gesture&& src) noexcept; 204 Gesture& operator=(Gesture&& src) noexcept; 205 206 ~Gesture() noexcept override; 207 208 /** Get the GType for this class, for use with the underlying GObject type system. 209 */ 210 static GType get_type() G_GNUC_CONST; 211 212 #ifndef DOXYGEN_SHOULD_SKIP_THIS 213 214 215 static GType get_base_type() G_GNUC_CONST; 216 #endif 217 218 ///Provides access to the underlying C GObject. gobj()219 GtkGesture* gobj() { return reinterpret_cast<GtkGesture*>(gobject_); } 220 221 ///Provides access to the underlying C GObject. gobj()222 const GtkGesture* gobj() const { return reinterpret_cast<GtkGesture*>(gobject_); } 223 224 ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs. 225 GtkGesture* gobj_copy(); 226 227 private: 228 229 230 protected: 231 /** There is no create() method that corresponds to this constructor, 232 * because only derived classes shall be created. 233 */ 234 Gesture(); 235 236 public: 237 // No create() because only derived classes shall be instantiated. 238 239 240 /** Returns the master Gdk::Device that is currently operating 241 * on @a gesture, or <tt>nullptr</tt> if the gesture is not being interacted. 242 * 243 * @newin{3,14} 244 * 245 * @return A Gdk::Device, or <tt>nullptr</tt>. 246 */ 247 Glib::RefPtr<Gdk::Device> get_device(); 248 249 /** Returns the master Gdk::Device that is currently operating 250 * on @a gesture, or <tt>nullptr</tt> if the gesture is not being interacted. 251 * 252 * @newin{3,14} 253 * 254 * @return A Gdk::Device, or <tt>nullptr</tt>. 255 */ 256 Glib::RefPtr<const Gdk::Device> get_device() const; 257 258 /** Sets the state of all sequences that @a gesture is currently 259 * interacting with. See set_sequence_state() 260 * for more details on sequence states. 261 * 262 * @newin{3,14} 263 * 264 * @param state The sequence state. 265 * @return <tt>true</tt> if the state of at least one sequence 266 * was changed successfully. 267 */ 268 bool set_state(EventSequenceState state); 269 270 /** Returns the @a sequence state, as seen by @a gesture. 271 * 272 * @newin{3,14} 273 * 274 * @param sequence A Gdk::EventSequence. 275 * @return The sequence state in @a gesture. 276 */ 277 EventSequenceState get_sequence_state(GdkEventSequence* sequence) const; 278 279 /** Sets the state of @a sequence in @a gesture. Sequences start 280 * in state Gtk::EVENT_SEQUENCE_NONE, and whenever they change 281 * state, they can never go back to that state. Likewise, 282 * sequences in state Gtk::EVENT_SEQUENCE_DENIED cannot turn 283 * back to a not denied state. With these rules, the lifetime 284 * of an event sequence is constrained to the next four: 285 * 286 * * None 287 * * None → Denied 288 * * None → Claimed 289 * * None → Claimed → Denied 290 * 291 * @note Due to event handling ordering, it may be unsafe to 292 * set the state on another gesture within a Gtk::Gesture::signal_begin() 293 * signal handler, as the callback might be executed before 294 * the other gesture knows about the sequence. A safe way to 295 * perform this could be: 296 * 297 * 298 * [C example ellipted] 299 * 300 * If both gestures are in the same group, just set the state on 301 * the gesture emitting the event, the sequence will be already 302 * be initialized to the group's global state when the second 303 * gesture processes the event. 304 * 305 * @newin{3,14} 306 * 307 * @param sequence A Gdk::EventSequence. 308 * @param state The sequence state. 309 * @return <tt>true</tt> if @a sequence is handled by @a gesture, 310 * and the state is changed successfully. 311 */ 312 bool set_sequence_state(GdkEventSequence* sequence, EventSequenceState state); 313 314 /** Returns the list of GdkEventSequence%s currently being interpreted. 315 * 316 * @newin{3,14} 317 * 318 * @return A std::vector of GdkEventSequence pointers. 319 * The GdkEventSequence%s are owned by GTK+ and must not be freed or modified. 320 */ 321 std::vector<const GdkEventSequence*> get_sequences() const; 322 323 324 /** Returns the Gdk::EventSequence that was last updated on @a gesture. 325 * 326 * @newin{3,14} 327 * 328 * @return The last updated sequence. 329 */ 330 GdkEventSequence* get_last_updated_sequence(); 331 332 /** Returns the Gdk::EventSequence that was last updated on @a gesture. 333 * 334 * @newin{3,14} 335 * 336 * @return The last updated sequence. 337 */ 338 const GdkEventSequence* get_last_updated_sequence() const; 339 340 /** Returns <tt>true</tt> if @a gesture is currently handling events corresponding to 341 * @a sequence. 342 * 343 * @newin{3,14} 344 * 345 * @param sequence A Gdk::EventSequence or <tt>nullptr</tt>. 346 * @return <tt>true</tt> if @a gesture is handling @a sequence, <tt>false</tt> otherwise. 347 */ 348 bool handles_sequence(GdkEventSequence* sequence) const; 349 350 /** Returns the last event that was processed for @a sequence. 351 * 352 * Note that the returned pointer is only valid as long as the @a sequence 353 * is still interpreted by the @a gesture. If in doubt, you should make 354 * a copy of the event. 355 * 356 * @param sequence A Gdk::EventSequence. 357 * @return The last event from @a sequence. 358 */ 359 const GdkEvent* get_last_event(GdkEventSequence* sequence) const; 360 361 /** If @a sequence is currently being interpreted by @a gesture, this 362 * function returns <tt>true</tt> and fills in @a x and @a y with the last coordinates 363 * stored for that event sequence. The coordinates are always relative to the 364 * widget allocation. 365 * 366 * @newin{3,14} 367 * 368 * @param sequence A Gdk::EventSequence, or <tt>nullptr</tt> for pointer events. 369 * @param x Return location for X axis of the sequence coordinates. 370 * @param y Return location for Y axis of the sequence coordinates. 371 * @return <tt>true</tt> if @a sequence is currently interpreted. 372 */ 373 bool get_point(GdkEventSequence* sequence, double& x, double& y) const; 374 375 /** If there are touch sequences being currently handled by @a gesture, 376 * this function returns <tt>true</tt> and fills in @a rect with the bounding 377 * box containing all active touches. Otherwise, <tt>false</tt> will be 378 * returned. 379 * 380 * @note This function will yield unexpected results on touchpad 381 * gestures. Since there is no correlation between physical and 382 * pixel distances, these will look as if constrained in an 383 * infinitely small area, @a rect width and height will thus be 0 384 * regardless of the number of touchpoints. 385 * 386 * @newin{3,14} 387 * 388 * @param rect Bounding box containing all active touches. 389 * @return <tt>true</tt> if there are active touches, <tt>false</tt> otherwise. 390 */ 391 bool get_bounding_box(Gdk::Rectangle& rect) const; 392 393 /** If there are touch sequences being currently handled by @a gesture, 394 * this function returns <tt>true</tt> and fills in @a x and @a y with the center 395 * of the bounding box containing all active touches. Otherwise, <tt>false</tt> 396 * will be returned. 397 * 398 * @newin{3,14} 399 * 400 * @param x X coordinate for the bounding box center. 401 * @param y Y coordinate for the bounding box center. 402 * @return <tt>false</tt> if no active touches are present, <tt>true</tt> otherwise. 403 */ 404 bool get_bounding_box_center(double& x, double& y) const; 405 406 /** Returns <tt>true</tt> if the gesture is currently active. 407 * A gesture is active meanwhile there are touch sequences 408 * interacting with it. 409 * 410 * @newin{3,14} 411 * 412 * @return <tt>true</tt> if gesture is active. 413 */ 414 bool is_active() const; 415 416 /** Returns <tt>true</tt> if the gesture is currently recognized. 417 * A gesture is recognized if there are as many interacting 418 * touch sequences as required by @a gesture, and Gtk::Gesture::signal_check() 419 * returned <tt>true</tt> for the sequences being currently interpreted. 420 * 421 * @newin{3,14} 422 * 423 * @return <tt>true</tt> if gesture is recognized. 424 */ 425 bool is_recognized() const; 426 427 /** Returns the user-defined window that receives the events 428 * handled by @a gesture. See set_window() for more 429 * information. 430 * 431 * @newin{3,14} 432 * 433 * @return The user defined window, or <tt>nullptr</tt> if none. 434 */ 435 Glib::RefPtr<Gdk::Window> get_window(); 436 437 /** Returns the user-defined window that receives the events 438 * handled by @a gesture. See set_window() for more 439 * information. 440 * 441 * @newin{3,14} 442 * 443 * @return The user defined window, or <tt>nullptr</tt> if none. 444 */ 445 Glib::RefPtr<const Gdk::Window> get_window() const; 446 447 /** Sets a specific window to receive events about, so @a gesture 448 * will effectively handle only events targeting @a window, or 449 * a child of it. @a window must pertain to Gtk::EventController::get_widget(). 450 * 451 * @newin{3,14} 452 * 453 * @param window A Gdk::Window, or <tt>nullptr</tt>. 454 */ 455 void set_window(const Glib::RefPtr<Gdk::Window>& window); 456 457 /** Undoes the effect of previous calls to set_window(), 458 * so the gesture will handle events targeting any Gdk::Window that pertains 459 * to Gtk::EventController::get_widget(). 460 * 461 * @newin{3,14} 462 */ 463 void unset_window(); 464 465 466 /** Adds @a gesture to the same group than @a group_gesture. Gestures 467 * are by default isolated in their own groups. 468 * 469 * When gestures are grouped, the state of Gdk::EventSequences 470 * is kept in sync for all of those, so calling set_sequence_state(), 471 * on one will transfer the same value to the others. 472 * 473 * Groups also perform an "implicit grabbing" of sequences, if a 474 * Gdk::EventSequence state is set to Gtk::EVENT_SEQUENCE_CLAIMED on one group, 475 * every other gesture group attached to the same Gtk::Widget will switch the 476 * state for that sequence to Gtk::EVENT_SEQUENCE_DENIED. 477 * 478 * @newin{3,14} 479 * 480 * @param group_gesture Gtk::Gesture to group @a gesture with. 481 */ 482 void group(const Glib::RefPtr<Gesture>& group_gesture); 483 484 /** Separates @a gesture into an isolated group. 485 * 486 * @newin{3,14} 487 */ 488 void ungroup(); 489 490 491 /** Returns all gestures in the group of @a gesture 492 * 493 * @newin{3,14} 494 * 495 * @return The list 496 * of Gtk::Gestures. 497 */ 498 std::vector< Glib::RefPtr<Gesture> > get_group(); 499 500 501 /** Returns all gestures in the group of @a gesture 502 * 503 * @newin{3,14} 504 * 505 * @return The list 506 * of Gtk::Gestures. 507 */ 508 std::vector< Glib::RefPtr<const Gesture> > get_group() const; 509 510 511 /** Returns <tt>true</tt> if both gestures pertain to the same group. 512 * 513 * @newin{3,14} 514 * 515 * @param other Another Gtk::Gesture. 516 * @return Whether the gestures are grouped. 517 */ 518 bool is_grouped_with(const Glib::RefPtr<Gesture>& other) const; 519 520 // no_default_handler because GtkGestureClass is private. 521 522 /** 523 * @par Slot Prototype: 524 * <tt>void on_my_%begin(GdkEventSequence* sequence)</tt> 525 * 526 * Flags: Run Last 527 * 528 * This signal is emitted when the gesture is recognized. This means the 529 * number of touch sequences matches Gtk::Gesture::property_n_points(), and the Gtk::Gesture::signal_check() 530 * handler(s) returned #<tt>true</tt>. 531 * 532 * @note These conditions may also happen when an extra touch (eg. a third touch 533 * on a 2-touches gesture) is lifted, in that situation @a sequence won't pertain 534 * to the current set of active touches, so don't rely on this being true. 535 * 536 * @newin{3,14} 537 * 538 * @param sequence The Gdk::EventSequence that made the gesture to be recognized. 539 */ 540 541 Glib::SignalProxy< void,GdkEventSequence* > signal_begin(); 542 543 544 /** 545 * @par Slot Prototype: 546 * <tt>void on_my_%end(GdkEventSequence* sequence)</tt> 547 * 548 * Flags: Run Last 549 * 550 * This signal is emitted when @a gesture either stopped recognizing the event 551 * sequences as something to be handled (the Gtk::Gesture::signal_check() handler returned 552 * <tt>false</tt>), or the number of touch sequences became higher or lower than 553 * Gtk::Gesture::property_n_points(). 554 * 555 * @note @a sequence might not pertain to the group of sequences that were 556 * previously triggering recognition on @a gesture (ie. a just pressed touch 557 * sequence that exceeds Gtk::Gesture::property_n_points()). This situation may be detected 558 * by checking through Gtk::Gesture::handles_sequence(). 559 * 560 * @newin{3,14} 561 * 562 * @param sequence The Gdk::EventSequence that made gesture recognition to finish. 563 */ 564 565 Glib::SignalProxy< void,GdkEventSequence* > signal_end(); 566 567 568 /** 569 * @par Slot Prototype: 570 * <tt>void on_my_%update(GdkEventSequence* sequence)</tt> 571 * 572 * Flags: Run Last 573 * 574 * This signal is emitted whenever an event is handled while the gesture is 575 * recognized. @a sequence is guaranteed to pertain to the set of active touches. 576 * 577 * @newin{3,14} 578 * 579 * @param sequence The Gdk::EventSequence that was updated. 580 */ 581 582 Glib::SignalProxy< void,GdkEventSequence* > signal_update(); 583 584 585 /** 586 * @par Slot Prototype: 587 * <tt>void on_my_%cancel(GdkEventSequence* sequence)</tt> 588 * 589 * Flags: Run Last 590 * 591 * This signal is emitted whenever a sequence is cancelled. This usually 592 * happens on active touches when Gtk::EventController::reset() is called 593 * on @a gesture (manually, due to grabs...), or the individual @a sequence 594 * was claimed by parent widgets' controllers (see Gtk::Gesture::set_sequence_state()). 595 * 596 * @a gesture must forget everything about @a sequence as a reaction to this signal. 597 * 598 * @newin{3,14} 599 * 600 * @param sequence The Gdk::EventSequence that was cancelled. 601 */ 602 603 Glib::SignalProxy< void,GdkEventSequence* > signal_cancel(); 604 605 606 /** 607 * @par Slot Prototype: 608 * <tt>void on_my_%sequence_state_changed(GdkEventSequence* sequence, EventSequenceState state)</tt> 609 * 610 * Flags: Run Last 611 * 612 * This signal is emitted whenever a sequence state changes. See 613 * Gtk::Gesture::set_sequence_state() to know more about the expectable 614 * sequence lifetimes. 615 * 616 * @newin{3,14} 617 * 618 * @param sequence The Gdk::EventSequence that was cancelled. 619 * @param state The new sequence state. 620 */ 621 622 Glib::SignalProxy< void,GdkEventSequence*,EventSequenceState > signal_sequence_state_changed(); 623 624 625 /** The number of touch points that trigger recognition on this gesture, 626 * 627 * 628 * @newin{3,14} 629 * 630 * Default value: 1 631 * 632 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 633 * or receive notification when the value of the property changes. 634 */ 635 Glib::PropertyProxy_ReadOnly< unsigned int > property_n_points() const; 636 637 638 /** If non-<tt>nullptr</tt>, the gesture will only listen for events that happen on 639 * this Gdk::Window, or a child of it. 640 * 641 * @newin{3,14} 642 * 643 * @return A PropertyProxy that allows you to get or set the value of the property, 644 * or receive notification when the value of the property changes. 645 */ 646 Glib::PropertyProxy< Glib::RefPtr<Gdk::Window> > property_window() ; 647 648 /** If non-<tt>nullptr</tt>, the gesture will only listen for events that happen on 649 * this Gdk::Window, or a child of it. 650 * 651 * @newin{3,14} 652 * 653 * @return A PropertyProxy_ReadOnly that allows you to get the value of the property, 654 * or receive notification when the value of the property changes. 655 */ 656 Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::Window> > property_window() const; 657 658 659 public: 660 661 public: 662 //C++ methods used to invoke GTK+ virtual functions: 663 664 protected: 665 //GTK+ Virtual Functions (override these to change behaviour): 666 667 //Default Signal Handlers:: 668 669 670 }; 671 672 } // namespace Gtk 673 674 675 namespace Glib 676 { 677 /** A Glib::wrap() method for this object. 678 * 679 * @param object The C instance. 680 * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref. 681 * @result A C++ instance that wraps this C instance. 682 * 683 * @relates Gtk::Gesture 684 */ 685 Glib::RefPtr<Gtk::Gesture> wrap(GtkGesture* object, bool take_copy = false); 686 } 687 688 689 #endif /* _GTKMM_GESTURE_H */ 690 691