HelpSource/Classes/View.schelp

   1 CLASS:: View
   2 redirect:: implClass
   3 summary:: The basic visible element of GUI
   4 categories:: GUI>Views
   5
   6 DESCRIPTION::
   7 The View class is the superclass of all view classes.
   8
   9 The view is the basic visible element of which the graphical user interface is composed. It occupies a rectangular space on screen within which it draws itself to display some data or to indicate a mode of interaction between the user and the program. Views receive keyboard and mouse events generated by the user and respond to them by controlling the behavior of the program. They also display information about the state of the program and the data on which it operates.
  10
  11
  12
  13 CLASSMETHODS::
  14
  15 PRIVATE:: key
  16
  17 METHOD:: new
  18
  19 Creates a new instance of View and makes it a child of another View or Window, effectively placing it within the parent's visual space. If there is a link::#-decorator#decorator:: installed on the parent, it will manage the position of the new View.
  20
  21 note::
  22
  23 strong::Qt GUI: ::
  24
  25 The 'parent' argument may be omitted, in which case the view will be displayed as a window on its own, when link::Classes/QView#-front#shown::.
  26
  27 The 'bounds' argument may be omitted, in which case the view will be created with its preferred size at position (0,0).
  28
  29 If a parent is given and there is a layout installed on it, the layout will manage the position and size of this view and the 'bounds' argument will have no effect.
  30 ::
  31
  32 argument:: parent
  33 The instance of View or Window that the new View will become a child of.
  34
  35 argument:: bounds
  36 A Rect or a Point describing size and position of the new View. If a Point is given, its coordinates will denote the view's size, while the view's position will be (0,0). Position is measured relative to the parent's top-left corner.
  37
  38 returns::
  39 note::
  40 SuperCollider has different GUI kits implementing the same functionality on different platforms. The View's constructor will return an instance of the equivalent class of the currently active GUI kit. See link::Guides/GUI-Introduction:: for detailed explanation.
  41 ::
  42
  43
  44 METHOD:: globalKeyDownAction
  45
  46         A settable class variable containing an object (e.g. an instance of Function or FunctionList) which is evaluated (i.e. link::Classes/Object#-value#value:: method is called on it) whenever a key is pressed, independently of keyboard focus. See also link::#-addAction::.
  47
  48         When the action object is evaluated, it is passed the following arguments: view, char, modifiers, unicode, keycode.
  49
  50
  51 METHOD:: globalKeyUpAction
  52
  53         A settable class variable containing an object (e.g. an instance of Function or FunctionList) which is evaluated (i.e. link::Classes/Object#-value#value:: method is called on it) whenever a key is released, independently of keyboard focus. See also link::#-addAction::.
  54
  55         When the action object is evaluated, it is passed the following arguments: view, char, modifiers, unicode, keycode.
  56
  57
  58 METHOD:: currentDrag
  59
  60         A class variable holding the content of the current drag. It is set by beginDrag.
  61
  62
  63 METHOD:: currentDragString
  64
  65         A class variable holding the content of the current drag as link::Classes/Object#-asCompileString#"compile string"::. It is set by beginDrag.
  66
  67
  68
  69
  70 INSTANCEMETHODS::
  71
  72 SUBSECTION:: Hierarchy and existence
  73
  74 METHOD:: parent
  75         returns:: The view's parent view, or nil if the view is a top view.
  76
  77 METHOD:: parents
  78         returns:: An array of all the parents, grandparents, etc., of the view.
  79
  80 METHOD:: getParents
  81         returns:: Same as link::-parents::.
  82
  83 METHOD:: children
  84         returns:: An array of all immediate children of the view.
  85
  86 METHOD:: remove
  87         Removes the view from its parent view (if any) and destroys the view. After this method is called, the view is not usable anymore.
  88
  89 METHOD:: removeAll
  90         Removes all the children of the view and destroys them. After this method is called, the former child views are not usable anymore.
  91
  92 METHOD:: close
  93         note:: only in Qt GUI ::
  94
  95         If link::#-deleteOnClose:: is true, this method has the same effect as link::#-remove::, otherwise makes the view invisible.
  96
  97 METHOD:: isClosed
  98         returns:: A Boolean stating whether the view has been destroyed.
  99
 100 METHOD:: notClosed
 101         returns:: A Boolean, the opposite of 'isClosed'.
 102
 103 METHOD:: asView
 104         Method that allows compatibility with Window and other classes that are not real subclasses of View, but implement a part of its interface.
 105
 106         returns:: This view.
 107
 108 SUBSECTION:: Visibility
 109
 110 METHOD:: visible
 111         Gets or sets wether the view is visible.
 112
 113         In Qt:
 114
 115         Making a child view invisible means it does not occupy any space from the standpoint of the layout that contains it, so the layout will distribute the space the view occupied when visible among other views. When the view becomes visible again it is given back the same space.
 116
 117         If the view has no parent, setting this to true has the same effect as link::#-front::, and setting it to false closes the window without destroying it.
 118
 119         argument::
 120                 A Boolean stating the visibility of the view.
 121
 122 METHOD:: front
 123         note:: only in Qt GUI ::
 124         If the view does not have a parent, displays it on the screen as a window (it has the same effect as setting link::#-visible:: to true), otherwise it has no effect.
 125
 126 METHOD:: minimize
 127         note:: only in Qt GUI ::
 128         If the view is a window, hides it (only keep it present in the dock/taskbar/etc.).
 129
 130 METHOD:: unminimize
 131         note:: only in Qt GUI ::
 132         If the view is a window, restores the its previous state after being minimized.
 133
 134 METHOD:: fullScreen
 135         note:: only in Qt GUI ::
 136         If the view is a window, displays it full-screen.
 137
 138 METHOD:: endFullScreen
 139         note:: only in Qt GUI ::
 140         If the view is a window, restores its previous state after being displayed full-screen.
 141
 142 METHOD:: alwaysOnTop
 143         note:: only in Qt GUI ::
 144
 145         If the view is a window, gets or sets whether it should always stay on top of other windows.
 146
 147         argument:: boolean
 148                 A Boolean stating whether the view should always stay on top.
 149
 150
 151
 152
 153 SUBSECTION:: Size and position
 154
 155 METHOD:: bounds
 156
 157         Gets or sets both the position and the size of the view. The position is relative to the parent view's top-left corner. Some containers, such as HLayoutView and VLayoutView, will use only the width and height of a child view's bounds.
 158
 159         The setter takes a Rect or a Point interpreted link::Classes/Point#-asRect#as Rect::. The getter always returns a Rect.
 160
 161 METHOD:: absoluteBounds
 162
 163         returns:: A Rect describing the absolute position and the size of the view on the screen.
 164
 165 METHOD:: sizeHint
 166         note:: only in Qt GUI ::
 167         returns:: A Size describing the preferred size of the view to comfortably display its contents and allow useful interaction.
 168
 169 METHOD:: minSizeHint
 170         note:: only in Qt GUI ::
 171
 172         returns:: A Size describing the minimum size of the view to be able to display its contents and allow any interaction.
 173
 174 METHOD:: maxSize
 175         note:: only in Qt GUI ::
 176         Set maximum allowed size of the view. The view will not be able to grow larger than this size, neither by user interaction nor programmatically.
 177
 178         argument:: size
 179                 A Size.
 180
 181 METHOD:: minSize
 182         note:: only in Qt GUI ::
 183         Set minimum allowed size of the view. The view will not be able to shrink smaller than this size, neither by user interaction nor programmatically.
 184
 185         argument:: size
 186                 A Size.
 187
 188
 189 METHOD:: fixedSize
 190         note:: only in Qt GUI ::
 191         Set both minimum and maximum allowed size of the view, thus making it non-resizable.
 192
 193         argument:: size
 194                 A Size.
 195
 196 METHOD:: maxWidth
 197         note:: only in Qt GUI ::
 198         Set maximum allowed width of the view, the view will not be able to grow larger in width, neither by user interaction nor programmatically.
 199
 200         argument:: width
 201                 An Int.
 202
 203
 204 METHOD:: minWidth
 205         note:: only in Qt GUI ::
 206         Set minimum allowed width of the view, the view will not be able to shrink smaller in width, neither by user interaction nor programmatically.
 207
 208         argument:: width
 209                 An Int.
 210
 211
 212 METHOD:: maxHeight
 213         note:: only in Qt GUI ::
 214         Set maximum allowed height of the view, the view will not be able to grow larger in height, neither by user interaction nor programmatically.
 215
 216         argument:: height
 217                 An Int.
 218
 219
 220
 221 METHOD:: minHeight
 222         note:: only in Qt GUI ::
 223         Set minimum allowed height of the view, the view will not be able to shrink smaller in height, neither by user interaction nor programmatically.
 224
 225         argument:: height
 226                 An Int.
 227
 228 METHOD:: moveTo
 229         note:: only in Qt GUI ::
 230         Move the view to new position, preserving its size.
 231
 232         argument:: x
 233                 An Int: the horizontal position of the new position.
 234
 235         argument:: y
 236                         An Int: the vertical position of the new position.
 237
 238 METHOD:: resizeTo
 239         note:: only in Qt GUI ::
 240         Resize the view, preserving its position.
 241
 242         argument:: width
 243                 An Int: the new horizontal size of the view.
 244
 245         argument:: height
 246                 An Int: the new vertical size of the view.
 247
 248 METHOD:: resize
 249         Determines what happens with the view's position and size when its parent is resized. See link::Guides/GUI-Introduction#view:: for further explanation.
 250
 251         argument::
 252                 An Int (1 to 9) defining the auto-resize behavior. See link::Reference/Resize:: for a list of valid resize modes.
 253
 254 METHOD:: decorator
 255         note:: only in Qt GUI ::
 256
 257         Get or set the decorator object, that automatically manages the positioning of new children of the view when they are created. See link::Guides/GUI-Introduction#decorators:: for further explanation.
 258
 259         argument::
 260                 An instance of a decorator class (e.g. FlowLayout).
 261
 262 METHOD:: addFlowLayout
 263         note:: only in Qt GUI ::
 264
 265         A convenience method which sets decorator to a new instance of FlowLayout. See link::Classes/FlowLayout:: for examples.
 266
 267         argument:: margin
 268                 A Point describing the link::Classes/FlowLayout#-margin#margin:: of the FlowLayout.
 269
 270         argument:: gap
 271                 A Point describing the link::Classes/FlowLayout#-gap#gap:: of the FlowLayout.
 272
 273         returns:: The new FlowLayout instance.
 274
 275 METHOD:: flow
 276         note:: only in Qt GUI ::
 277
 278         Creates a FlowView as a child of the view, and then evalutes the object given in the 'func' argument. It is most common to pass a Function for 'func' in which the FlowView is filled with other child views.
 279
 280         argument:: func
 281                 The object that will be evaluated after the creation of the FlowView, passing the new FlowView instance as an argument.
 282
 283         argument:: bounds
 284                 A Rect to set as the bounds of the FlowView, or nil, implying the size of this view and position (0,0).
 285
 286                 After 'func' is evaluated, the FlowView will be resized to fit its contents and cast away any extra space it occupies.
 287
 288         returns:: The new FlowView instance.
 289
 290 METHOD:: layout
 291         note:: only in Qt GUI ::
 292
 293         Get or set the layout object, that automatically manages the position and the size of the children of the view dynamically, in relation to the view's size. See link::Guides/GUI-Introduction#layouts:: for further explanation.
 294
 295         argument::
 296                 An instance of a subclass of QLayout.
 297
 298
 299
 300
 301 METHOD:: mapToGlobal
 302         note:: only in Qt GUI ::
 303
 304         Map a point relative to this view's top-left to absolute position on screen.
 305
 306         argument::
 307                 A Point describing a position relative to the view.
 308
 309         returns::
 310                 A Point describing the same position, but relative to the screen.
 311
 312
 313 SUBSECTION:: Appearance
 314
 315 METHOD:: name
 316         note:: only in Qt GUI ::
 317
 318         If the view is a window, sets its title
 319
 320         argument::
 321                 A String containing text for the window title.
 322
 323
 324 METHOD:: alpha
 325         note:: only in Qt GUI ::
 326
 327         If the view is a window, this controls its transparency.
 328
 329         argument:: aFloat
 330                 A Float between 0.0 (invisible) and 1.0 (opaque).
 331
 332 METHOD:: font
 333         note:: Only in Qt every view has this method. In other GUI kits, only some views have it. ::
 334         The font used by the view to display text (if any).
 335
 336         argument::
 337                 A Font.
 338
 339
 340 METHOD:: background
 341         Get or set the color of whatever is considered the background of the view.
 342
 343         argument::
 344                 A Color.
 345
 346
 347 METHOD:: focusColor
 348         Get or set the color used to display keyboard focus on the view.
 349
 350         argument::
 351                 A Color.
 352
 353 METHOD:: refresh
 354         Redraws the view and all its children.
 355
 356
 357 SUBSECTION:: Common behavior
 358
 359
 360 METHOD:: userCanClose
 361         note:: only in Qt GUI ::
 362
 363         If the view is a window, sets or gets whether the user can close it via mouse or key actions.
 364
 365         argument::
 366                 A Boolean.
 367
 368
 369 METHOD:: deleteOnClose
 370         note:: only in Qt GUI ::
 371
 372         Sets or gets whether the view should be destroyed when closed.
 373
 374         argument::
 375                 A Boolean.
 376
 377 METHOD:: enabled
 378         Sets or gets whether the view allows the user to interact with it. Usually, when a view is disabled it will be displayed differently (typically it will be greyed out).
 379
 380         argument::
 381                 A Boolean.
 382
 383
 384 METHOD:: canFocus
 385         Sets or gets whether the view can receive keyboard focus.
 386
 387         argument::
 388                 A Boolean.
 389
 390 METHOD:: focus
 391         If 'flag' is true, gives keyboard focus to the view (if possible), otherwise removes the keayboard focus from it.
 392
 393         argument:: flag
 394                 A Boolean.
 395
 396 METHOD:: hasFocus
 397
 398         returns:: A Boolean, stating whether the view currently has the keyboard focus.
 399
 400
 401
 402
 403 SUBSECTION:: Actions in general
 404
 405 METHOD:: action
 406         Gets or sets the default action of the view, i.e. the object to be evaluated when the user interacts with the view in an essential way (e.g. a Button is clicked, a ListView item is selected, etc.).
 407
 408         argument:: func
 409                 Any object to set as default action, usually a Function or a FunctionList. When evaluated, it will be passed the view as an argument.
 410
 411
 412 METHOD:: doAction
 413         Evaluates the default link::#-action#action::.
 414
 415
 416 METHOD:: addAction
 417 METHOD:: removeAction
 418
 419         Adds/removes 'func' to or from the list of objects in the variable determined by 'selector'. If 'selector' is not an Array or a List, it will become one, containing the previous object plus 'func'.
 420
 421         This is useful for adding functionality to existing frameworks that have action functions already.
 422
 423         argument:: func
 424                 Any object to add as an action, usually a Function.
 425
 426         argument:: selector
 427                 A Symbol containing the name of the action variable to which 'func' will be added. In other words, 'add' method will be invoked on that variable; by default that is \action, but any other (sensible) instance or class variable of the view could work (e.g. \globalKeyDownAction or \mouseUpAction or \onClose, etc.). See the other action variables below.
 428
 429
 430
 431
 432 SUBSECTION:: Mouse actions
 433
 434 Use the methods below to set or get the view's actions in response to mouse interaction with the view. A view must be enabled for the mouse actions to work.
 435
 436 When the action object is evaluated, it is passed one or more arguments from the following list (in that order):
 437
 438 list::
 439 ## strong::view:: - the view
 440 ## strong::x:: - the x coordinate
 441 ## strong::y:: - the y coordinate
 442 ## strong::modifiers:: - A bitwise or of integers indicating the modifier keys in effect. For a list of these, see link::Reference/Modifiers::.
 443 ## strong::buttonNumber:: - 0-left, 1-right, 2-middle, etc.
 444 ## strong::clickCount:: - the number of clicks within the system click time limit. At least 1.
 445 ::
 446
 447 METHOD:: mouseDownAction
 448         Sets or gets the object to be evaluated when a mouse button is pressed on the view.
 449
 450                 It is passed the following arguments: view, x, y, modifiers, buttonNumber, clickCount.
 451
 452 METHOD:: mouseUpAction
 453         Sets or gets the object to be evaluated when a mouse button is released after it was pressed on the view.
 454
 455                 It is passed the following arguments: view, x, y, modifiers.
 456
 457 METHOD:: mouseMoveAction
 458         Sets or gets the object to be evaluated whenever the mouse pointer moves after a mouse button was pressed on the view.
 459
 460                 It is passed the following arguments: view, x, y, modifiers.
 461
 462 METHOD:: mouseOverAction
 463         Sets or gets the object to be evaluated when the mouse pointer enters the view.
 464
 465                 It is passed the following arguments: view, x, y.
 466
 467 METHOD:: mouseLeaveAction
 468         note:: strong:: Only in Qt GUI :: ::
 469
 470         Sets or gets the object to be evaluated when the mouse pointer leaves the view.
 471
 472                 It is passed the following arguments: view, x, y.
 473
 474
 475 SUBSECTION:: Key actions
 476
 477 Use the methods below to set or get the view's actions in response to keyboard interaction when the view has the keyboard focus.
 478
 479 If evaluating the action object returns nil, or there is no action set, keyboard event will propagate up to the parent view which may then respond and trigger its actions. On the same condition, it will continue to propagate up unless some view responds or it hits the top of the view hierarchy. You may register an action on the Window's top view to respond to all unhandled keyboard events for the window.
 480
 481 note::
 482 In Qt GUI, event propagation works differently. After handling a key event within SuperCollider language, the event processing continues in the Qt implementation of the view, and if it is not handled there it propagates to the parent view. If you want to have control over key event propagation, you can return true or false from key actions (meaning that the event was handled and will not propagate, or converse), but note that this will also prevent the Qt view implementation to respond to the key event.
 483 ::
 484
 485 When the action object is evaluated, it is passed one or more arguments from the following list (in that order):
 486
 487 list::
 488 ## strong::view:: - The view.
 489
 490 ## strong::char:: - The character associated with the key, possibly unprintable. Character sequences (for example é) get passed as two characters, the first one blank ( ), the second one is the unmodified character (e). This will also vary depending on the nationality the keyboard is set to. note:: In Qt GUI only printable characters are passed. If a key is not associated with any printable character, nil will be passed instead.::
 491
 492 ## strong::modifiers:: - A bitwise or of integers indicating the modifier keys in effect. You can examine individual flag settings using the C bitwise AND operator. For a list of these, see link::Reference/Modifiers::.
 493
 494 ## strong::unicode:: - The Integer unicode number associated with the 'char' passed.
 495
 496 ## strong::keycode:: - The hardware dependent keycode indicating the physical key. This will vary from machine to machine, but is useful for building musical interfaces using the computer keyboard. warning::Function key modifier in combination with another key may change the latter's keycode.::
 497 ::
 498
 499 note::
 500 In Cocoa GUI, for various reasons the following key events don't make it through to SuperCollider:
 501 list::
 502 ## most command modifiers
 503 ## ctl-tab
 504 ## ctl-escape
 505 ## tab and shift tab are currently trapped by SC itself for cycling the focus through the views.
 506 ::
 507 ::
 508
 509
 510 METHOD:: keyDownAction
 511         Sets or gets the object to be evaluated when a key is pressed.
 512
 513                 It is passed the following arguments: strong::view, char, modifiers, unicode, keycode::.
 514
 515 METHOD:: keyUpAction
 516         Sets or gets the object to be evaluated when a key is released.
 517
 518                 It is passed the following arguments: strong::view, char, modifiers, unicode, keycode::.
 519
 520 METHOD:: keyModifiersChangedAction
 521         Sets or gets the object to be evaluated when a modifier key is pressed or released.
 522
 523                 It is passed the following arguments: strong::view, modifiers::.
 524
 525
 526 SUBSECTION:: Drag and drop
 527
 528 Use the methods below to define or override how the view handles drag&drop operations.
 529
 530 METHOD:: beginDragAction
 531         Sets or gets the object evaluated when a drag&drop operation is initiated.
 532
 533         At evaluation, the following arguments will be passed: strong:: view, x, y ::. The view expects an object to be returned which will become the data subject to the drag&drop operation. Returning nil will prevent the drag&drop operation to begin.
 534
 535         If this variable is nil (the default) the view's link::#-defaultGetDrag:: method is called instead.
 536
 537 METHOD:: canReceiveDragHandler
 538         Sets or gets the object evaluated when the mouse pointer moves over the view while a drag&drop operation is taking place.
 539
 540         At evaluation, the following arguments will be passed: strong:: view, x, y ::. The view expects the link::#*currentDrag#drag&drop data:: to be examined, and a Boolean returned stating whether the view can make use of that data. If true is returned, the data may be dropped on the view, otherwise the drop event will not be handled by this view.
 541
 542         If this variable is nil (the default) the view's link::#-defaultCanReceiveDrag:: method is called instead.
 543
 544 METHOD:: receiveDragHandler
 545         Sets or gets the object evaluated when a drag&drop operation finishes on this view.
 546
 547         At evaluation, the following arguments will be passed: strong:: view, x, y ::. The link::#*currentDrag#drag&drop data:: is expected to be applied to the view in some way.
 548
 549         If this variable is nil (the default) the view's link::#-defaultReceiveDrag:: method is called instead.
 550
 551
 552 METHOD:: dragLabel
 553         Sets or gets the text displayed by the mouse pointer during the drag&drop operation. It is expected to be set while handling the beginning of the operation, i.e. in link::#-beginDragAction:: or link::#-defaultGetDrag::.
 554
 555         argument::
 556                 A String containing the text to be displayed.
 557
 558
 559
 560
 561 SUBSECTION:: Other actions and hooks
 562
 563 METHOD:: focusGainedAction
 564         note:: only in Qt and SwingOSC GUI::
 565
 566         Sets or gets the object to be evaluated when the view gains the keyboard focus. It is passed the view as an argument.
 567
 568 METHOD:: focusLostAction
 569         note:: only in Qt and SwingOSC GUI::
 570
 571         Sets or gets the object to be evaluated when the view looses the keyboard focus. It is passed the view as an argument.
 572
 573 METHOD:: toFrontAction
 574         note:: only in Qt GUI ::
 575
 576         Sets or gets the object to be evaluated when the view becomes the active window. It is passed the view as an argument.
 577
 578 METHOD:: endFrontAction
 579         note:: only in Qt GUI ::
 580
 581         Sets or gets the object to be evaluated when the view becomes the active window. It is passed the view as an argument.
 582
 583 METHOD:: onClose
 584
 585         Sets or gets the object to be evaluated when the view is destroyed (i.e. link::#-close#closed:: or link::#-remove#removed::). It is passed the view as an argument.
 586
 587
 588
 589
 590 SUBSECTION:: Subclassing
 591
 592 The following methods are the default handlers of key press and release events. When subclassing, override them to implement custom functionality. Many view classes in the standard library do that.
 593
 594 METHOD:: defaultKeyDownAction
 595
 596         The method called when a key is pressed and link::#-keyDownAction:: is nil. Subclass it to define your own functionality on key-press.
 597
 598         See link::#key_actions#Key actions :: for explanation of arguments.
 599
 600         returns:: nil, if the key event is not handled by the view, which will propagated it to the parent.
 601
 602 METHOD:: defaultKeyUpAction
 603
 604         The method called when a key is released and link::#-keyUpAction:: is nil.  Subclass it to define your own functionality on key-release.
 605
 606         See link::#key_actions#Key actions :: for explanation of arguments.
 607
 608         returns:: nil, if the key event is not handled by the view, which will propagated it to the parent.
 609
 610
 611 METHOD:: keyDown
 612         Handles response to a key press event. First evaluates link::#*globalKeyDownAction::, then calls link::#-handleKeyDownBubbling::.
 613
 614         note::
 615         In Qt GUI, instead of calling link::#-handleKeyDownBubbling::, this method directly triggers the action and returns, forwarding the action's return value. See link::#key_actions#Key Actions :: for detailed explanation.
 616         ::
 617
 618         See link::#key_actions#Key actions :: for explanation of arguments.
 619
 620         returns:: strong:: Only in Qt GUI: :: A Boolean, stating whether the event was handled or not (and will not or will propagate to the parent view, respectively), or the view, in which case it lets the Qt view implementation handle the event.
 621
 622 METHOD:: keyUp
 623
 624         Handles response to a key release event. Sets link::#-keyTyped:: to 'char', evaluates link::#*globalKeyUpAction::, and then calls link::#-handleKeyUpBubbling::.
 625
 626         note::
 627         In Qt GUI, instead of calling link::#-handleKeyUpBubbling::, this method directly triggers the action and returns, forwarding the action's return value. See link::#key_actions#Key Actions :: for detailed explanation.
 628         ::
 629
 630         See link::#key_actions#Key actions :: for explanation of arguments.
 631
 632         returns:: strong:: Only in Qt GUI: :: A Boolean, stating whether the event was handled or not (and will not or will propagate to the parent view, respectively), or the view, in which case it lets the Qt view implementation handle the event.
 633
 634 METHOD:: keyModifiersChanged
 635         Handles response to a modifier key press or release event. Calls link::#-handleKeyModifiersChangedBubbling::.
 636
 637         note::
 638         In Qt GUI, instead of calling link::#-handleKeyModifiersChangedBubbling::, a modifier key press or release event also produces a normal key press or release event, and it is the handling of those events that will determine propagation to the parent.
 639         ::
 640
 641         See link::#key_actions#Key actions :: for explanation of arguments.
 642
 643 METHOD:: handleKeyDownBubbling
 644         note:: Only in Cocoa and SwingOSC GUI ::
 645         Triggers key-down action and propagates the key event to the parent view, if the action returns nil.
 646
 647 METHOD:: handleKeyUpBubbling
 648         note:: Only in Cocoa and SwingOSC GUI ::
 649         Triggers key-up action and propagates the key event to the parent view, if the action returns nil.
 650
 651 METHOD:: handleKeyModifiersChangedBubbling
 652         note:: Only in Cocoa and SwingOSC GUI ::
 653         Triggers key-modifiers-changed action and propagates the key event to the parent view, if the action returns nil.
 654
 655 METHOD:: keyTyped
 656
 657         An instance variable containing the key just typed (after it is released).
 658
 659
 660
 661 METHOD:: mouseDown
 662         Handles response to a mouse button press event. Evaluates link::#-mouseDownAction::.
 663
 664         See link::#mouse_actions#Mouse actions :: for explanation of arguments.
 665
 666 METHOD:: mouseUp
 667         Handles response to a mouse button release event. Evaluates link::#-mouseDownAction::.
 668
 669         See link::#mouse_actions#Mouse actions :: for explanation of arguments.
 670
 671 METHOD:: mouseMove
 672         Handles response to mouse pointer moving over the view after a mouse button has been pressed. Evaluates link::#-mouseMoveAction::.
 673
 674         See link::#mouse_actions#Mouse actions :: for explanation of arguments.
 675
 676 METHOD:: mouseOver
 677         Handles response to mouse pointer entering the view. Evaluates link::#-mouseOverAction::.
 678
 679         See link::#mouse_actions#Mouse actions :: for explanation of arguments.
 680
 681 METHOD:: mouseLeave
 682         note:: strong:: Only in Qt GUI :: ::
 683
 684         Handles response to mouse pointer leaving the view. Evaluates link::#-mouseLeaveAction::.
 685
 686         See link::#mouse_actions#Mouse actions :: for explanation of arguments.
 687
 688
 689
 690 METHOD:: defaultGetDrag
 691
 692         The view's default method to determine the content of the drag&drop operation just initiated.
 693
 694         returns:: The object to be set as link::#*currentDrag::. If nil is returned, the drag&drop operation will not begin.
 695
 696 METHOD:: defaultCanReceiveDrag
 697
 698         The view's default evaluation whether the content of the ongoing drag&drop operation can be accepted.
 699
 700         returns:: A Boolean stating whether link::#*currentDrag:: is useful. If false is returned, the drop will not be handled by this view.
 701
 702 METHOD:: defaultReceiveDrag
 703
 704         The view's default handling of the data dropped on it (stored in link::#*currentDrag::).
 705
 706 METHOD:: beginDrag
 707         Handles initiation of a drag&drop operation. Evaluates link::#-beginDragAction:: or calls link::#-defaultGetDrag:: if the former is nil, then stores the object returned into link::#*currentDrag::, and the object interpreted as link::Classes/Object#-asCompileString#"compile string":: into link::#*currentDragString::. Returns whether link::#*currentDrag:: is not nil.
 708
 709         note:: The description of arguments and return value is valid strong:: only for Qt GUI: ::. In other GUI kits this method has no arguments and its return value is insignificant. ::
 710
 711         argument:: x
 712                 Current horizontal position of the mouse pointer.
 713
 714         argument:: y
 715                 Current vertical position of the mouse pointer.
 716
 717         returns:: A Boolean stating whether the drag&drop operation shall begin.
 718
 719 METHOD:: canReceiveDrag
 720         Handles evaluation whether the view can accept the current drag&drop data. Evaluates link::#-canReceiveDragHandler:: or calls link::#-defaultCanReceiveDrag:: if the former is nil, then forwards the return value.
 721
 722         note:: The description of arguments is valid strong:: only for Qt GUI: ::. In other GUI kits this method has no arguments. ::
 723
 724         argument:: x
 725                 Current horizontal position of the mouse pointer.
 726
 727         argument:: y
 728                 Current vertical position of the mouse pointer.
 729
 730         returns:: A Boolean stating whether the current drag&drop content can be dropped on the view.
 731
 732 METHOD:: receiveDrag
 733         Handles the end of the drag&drop operation. Evaluates link::#-receiveDragHandler:: or calls link::#-defaultReceiveDrag:: if the former is nil, then sets link::#*currentDrag:: and link::#*currentDragString:: to nil.
 734
 735         argument:: x
 736                 Current horizontal position of the mouse pointer.
 737
 738         argument:: y
 739                 Current vertical position of the mouse pointer.