Skip to content
Snippets Groups Projects
FXApp.i 23 KiB
Newer Older
  • Learn to ignore specific revisions
  • /***********************************************************************
     * FXRuby -- the Ruby language bindings for the FOX GUI toolkit.
    
     * Copyright (c) 2001-2009 by Lyle Johnson. All Rights Reserved.
    
     *
     * This library is free software; you can redistribute it and/or
     * modify it under the terms of the GNU Lesser General Public
     * License as published by the Free Software Foundation; either
     * version 2.1 of the License, or (at your option) any later version.
     *
     * This library is distributed in the hope that it will be useful,
     * but WITHOUT ANY WARRANTY; without even the implied warranty of
     * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     * Lesser General Public License for more details.
     *
     * You should have received a copy of the GNU Lesser General Public
     * License along with this library; if not, write to the Free Software
     * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
     *
     * For further information please contact the author by e-mail
    
     * at "lyle@lylejohnson.name".
    
     ***********************************************************************/
    
    // Forward declarations
    class FXWindow;
    class FXIcon;
    class FXBitmap;
    class FXCursor;
    class FXRootWindow;
    class FXMainWindow;
    class FXPopup;
    class FXFont;
    class FXDC;
    class FXDCWindow;
    class FXVisual;
    class FXGLVisual;
    class FXGLContext;
    
    
    /// File input modes for addInput
    enum FXInputMode {
      INPUT_NONE   = 0,                 /// Inactive
      INPUT_READ   = 1,                 /// Read input fd
      INPUT_WRITE  = 2,                 /// Write input fd
      INPUT_EXCEPT = 4                  /// Except input fd
      };
    
    
    /// All ways of being modal
    enum FXModality {
      MODAL_FOR_NONE,                 /// Non modal event loop (dispatch normally)
      MODAL_FOR_WINDOW,               /// Modal dialog (beep if outside of modal dialog)
      MODAL_FOR_POPUP                 /// Modal for popup (always dispatch to popup)
      };
    
    
    /// Default cursors provided by the application
    enum FXDefaultCursor {
      DEF_ARROW_CURSOR,                     /// Arrow cursor
      DEF_RARROW_CURSOR,                    /// Reverse arrow cursor
      DEF_TEXT_CURSOR,                      /// Text cursor
      DEF_HSPLIT_CURSOR,                    /// Horizontal split cursor
      DEF_VSPLIT_CURSOR,                    /// Vertical split cursor
      DEF_XSPLIT_CURSOR,                    /// Cross split cursor
      DEF_SWATCH_CURSOR,                    /// Color swatch drag cursor
      DEF_MOVE_CURSOR,                      /// Move cursor
      DEF_DRAGH_CURSOR,                     /// Resize horizontal edge
      DEF_DRAGV_CURSOR,                     /// Resize vertical edge
      DEF_DRAGTL_CURSOR,                    /// Resize upper-leftcorner
      DEF_DRAGBR_CURSOR=DEF_DRAGTL_CURSOR,  /// Resize bottom-right corner
      DEF_DRAGTR_CURSOR,                    /// Resize upper-right corner
      DEF_DRAGBL_CURSOR=DEF_DRAGTR_CURSOR,  /// Resize bottom-left corner
      DEF_DNDSTOP_CURSOR,                   /// Drag and drop stop
      DEF_DNDCOPY_CURSOR,                   /// Drag and drop copy
      DEF_DNDMOVE_CURSOR,                   /// Drag and drop move
      DEF_DNDLINK_CURSOR,                   /// Drag and drop link
      DEF_CROSSHAIR_CURSOR,                 /// Cross hair cursor
      DEF_CORNERNE_CURSOR,                  /// North-east cursor
      DEF_CORNERNW_CURSOR,                  /// North-west cursor
      DEF_CORNERSE_CURSOR,                  /// South-east cursor
      DEF_CORNERSW_CURSOR,                  /// South-west cursor
      DEF_HELP_CURSOR,                      /// Help arrow cursor
      DEF_HAND_CURSOR,                      /// Hand cursor
      DEF_ROTATE_CURSOR,                    /// Rotate cursor
      DEF_WAIT_CURSOR                       /// Wait cursor
      };
    
    
    /// FOX Event 
    struct FXEvent {
      FXEvent();
      FXuint      type;           /// Event type
      FXuint      time;           /// Time of last event
      FXint       win_x;          /// Window-relative x-coord
      FXint       win_y;          /// Window-relative y-coord
      FXint       root_x;         /// Root x-coord
      FXint       root_y;         /// Root y-coord
      FXint       state;          /// Keyboard/Modifier state
      FXint       code;           /// Button, Keysym, or mode; DDE Source
      FXString    text;           /// Text of keyboard event
      FXint       last_x;         /// Window-relative x-coord of previous mouse location
      FXint       last_y;         /// Window-relative y-coord of previous mouse location
      FXint       click_x;        /// Window-relative x-coord of mouse press
      FXint       click_y;        /// Window-relative y-coord of mouse press
      FXint       rootclick_x;    /// Root-relative x-coord of mouse press
      FXint       rootclick_y;    /// Root-relative y-coord of mouse press
      FXuint      click_time;     /// Time of mouse button press
      FXuint      click_button;   /// Mouse button pressed
      FXint       click_count;    /// Click-count
      FXbool      moved;          /// Moved cursor since press
      FXRectangle rect;           /// Rectangle
      FXbool      synthetic;      /// True if synthetic expose event
      FXDragType  target;         /// Target drag type being requested
      ~FXEvent();
      };
    
    
    // FXChore is an opaque struct for FOX; this is just a declaration for SWIG
    struct FXChore {
      };
    
    
    // FXTimer is an opaque struct for FOX; this is just a declaration for SWIG
    struct FXTimer {
      };
    
    %rename("hasInputMethod?") FXApp::hasInputMethod() const;
    %rename("hasChore?") FXApp::hasChore(FXObject *tgt,FXSelector sel) const;
    %rename("hasTimeout?") FXApp::hasTimeout(FXObject *tgt,FXSelector sel) const;
    %rename("focusWindow") FXApp::getFocusWindow() const;
    %rename("activeWindow") FXApp::getActiveWindow() const;
    %rename("scrollBarSize") FXApp::getScrollBarSize() const;
    %rename("scrollBarSize=") FXApp::setScrollBarSize(FXint);
    
    /// Application Object
    class FXApp : public FXObject {
    protected:
    
      /// Return TRUE when new raw event is available
      virtual bool getNextEvent(FXRawEvent& ev,FXbool blocking=TRUE);
    
      /// Dispatch raw event
      virtual bool dispatchEvent(FXRawEvent& ev);
    
    public:
      long onCmdQuit(FXObject*,FXSelector,void* PTR_IGNORE);
      long onCmdDump(FXObject*,FXSelector,void* PTR_IGNORE);
      long onCmdHover(FXObject*,FXSelector,void* PTR_IGNORE);
    
    public:
    
      // Messages applications understand
      enum {
        ID_QUIT=1,    /// Terminate the application normally
        ID_DUMP,      /// Dump the current widget tree
        ID_HOVER,
        ID_LAST
        };
    
    public:
    
      %extend {
        // Copyright notice for library
        static VALUE copyright() {
          return rb_str_new2((const char *) FXApp::copyright);
        }
      }
    
    public:
    
      %extend {
        /**
        * Construct application object; the name and vendor strings are used
        * as keys into the registry database for this application's settings
        */
        FXApp(const FXchar* name="Application",const FXchar* vendor="FoxDefault"){
    
          if(FXApp::instance()){
            rb_raise(rb_eRuntimeError,"attempted to create more than one FXApp instance");
            return 0;
            }
          else{
    	      return FXRbApp::constructAndInit(name,vendor);
            }
    
          }
      }
    
      /// Get application name
      const FXString& getAppName() const;
    
      /// Get vendor name
      const FXString& getVendorName() const;
    
      /// Connection to display; this is called by init()
      bool openDisplay(const FXchar* dpyname=NULL);
      
      /// Close connection to the display
      bool closeDisplay();
    
      %extend {
        /// Return pointer to display
        unsigned long getDisplay() const {
          return reinterpret_cast<unsigned long>(self->getDisplay());
          }
        }
    
      /// Is application initialized
      bool isInitialized() const;
    
      /// Get argument count
      FXint getArgc() const;
    
      /// Get argument vector
      const FXchar *const *getArgv() const; // FIXME
    
      /// Return true if input method support
      bool hasInputMethod() const;
    
      /// Get default visual
      FXVisual* getDefaultVisual() const;
    
      %extend {
        /// Change default visual
        void setDefaultVisual(FXVisual* vis){
          FXASSERT(vis);
          if(vis->isMemberOf(FXMETACLASS(FXRbVisual))){
            dynamic_cast<FXRbVisual*>(vis)->ownedByApp=TRUE;
            }
          else if(vis->isMemberOf(FXMETACLASS(FXRbGLVisual))){
            dynamic_cast<FXRbGLVisual*>(vis)->ownedByApp=TRUE;
            }
          self->setDefaultVisual(vis);
          }
      }
    
      /// Get monochrome visual
      FXVisual* getMonoVisual() const;
    
      /// Get root Window
      FXRootWindow* getRootWindow() const;
    
      /// Set root Window
      void setRootWindow(FXRootWindow* rt);
    
      /// Return window at the end of the focus chain
      FXWindow *getFocusWindow() const;
    
      /// Get the window under the cursor, if any  
      FXWindow *getCursorWindow() const;
    
      /// Get the active toplevel window, if any
      FXWindow *getActiveWindow() const;
    
      /// Get current popup window, if any
      FXPopup* getPopupWindow() const;
    
      /// Find window from id
      FXWindow* findWindowWithId(FXID xid) const;
    
      /// Find window from root x,y, starting from given window
      FXWindow* findWindowAt(FXint rx,FXint ry,FXID window=0) const;
    
      /**
      * Add timeout message to be sent to target object in ms milliseconds;
      * the timer fires only once after the interval expires.  The void* ptr
      * is user data which will be passed into the void* ptr of the message
      * handler.  If a timer with the same target and message already exists,
      * it will be rescheduled.
      */
      void addTimeout(FXObject* tgt,FXSelector sel,FXuint ms=1000,void* ptr=NULL);
    
      /**
      * Remove timeout identified by tgt and sel.
      */
      void removeTimeout(FXObject* tgt,FXSelector sel);
    
       /**
       * Return TRUE if given timeout has been set
       */
      bool hasTimeout(FXObject *tgt,FXSelector sel) const;
    
       /**
      * Return, in ms, the time remaining until the given timer fires.
      * If the timer is past due, 0 is returned.  If there is no such
      * timer, infinity (UINT_MAX) is returned.
      */
      FXuint remainingTimeout(FXObject *tgt,FXSelector sel);
    
      /**
       * Process any timeouts due at this time.
       */
      void handleTimeouts();
    
      /**
      * Add a idle processing message to be sent to target object when
      * the system becomes idle, i.e. there are no events to be processed.
      * The void* ptr is user data which will be passed into the void* ptr
      * of the message handler. If a chore with the same target and message
      * already exists, it will be rescheduled.
      */
      void addChore(FXObject* tgt,FXSelector sel,void *ptr=NULL);
    
      /**
      * Remove idle processing message(s) identified by tgt and sel.
      */
      void removeChore(FXObject* tgt,FXSelector sel);
    
       /**
      * Return TRUE if given chore has been set
      */
      bool hasChore(FXObject *tgt,FXSelector sel) const;
    
      %extend {
        /**
        * Add signal processing message to be sent to target object when 
        * the signal sig is raised; flags are to be set as per POSIX definitions.
        * When immediate is TRUE, the message will be sent to the target right away;
        * this should be used with extreme care as the application is interrupted
        * at an unknown point in its execution.
        */
        void addSignal(VALUE sigObj,FXObject* tgt,FXSelector sel,FXbool immediate=FALSE,FXuint flags=0){
          const char *s;
          FXint sig;
          switch(TYPE(sigObj)){
            case T_STRING:
    
              s=StringValuePtr(sigObj);
    
              sig=FXRbSignalNameToNumber(s);
              if(sig==0) rb_raise(rb_eArgError,"unrecognized signal name `%s'",s);
              break;
            case T_FIXNUM:
              sig=(FXint)NUM2INT(sigObj);
              break;
            default:
              rb_raise(rb_eArgError,"bad signal type %s",rb_class2name(CLASS_OF(sigObj)));
              break;
            }
          self->addSignal(sig,tgt,sel,immediate,flags);
          }
    
        /// Remove signal message for signal sig
        void removeSignal(VALUE sigObj){
          const char *s;
          FXint sig;
          switch(TYPE(sigObj)){
            case T_STRING:
    
              s=StringValuePtr(sigObj);
    
    345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735
              sig=FXRbSignalNameToNumber(s);
              if(sig==0) rb_raise(rb_eArgError,"unrecognized signal name `%s'",s);
              break;
            case T_FIXNUM:
              sig=(FXint)NUM2INT(sigObj);
              break;
            default:
              rb_raise(rb_eArgError,"bad signal type %s",rb_class2name(CLASS_OF(sigObj)));
              break;
            }
          self->removeSignal(sig);
          }
      }
    
      %extend {
        /**
        * Add a file descriptor fd to be watched for activity as determined
        * by mode, where mode is a bitwise OR (INPUT_READ, INPUT_WRITE, INPUT_EXCEPT).
        * A message of type SEL_IO_READ, SEL_IO_WRITE, or SEL_IO_EXCEPT will be sent 
        * to the target when the specified activity is detected on the file descriptor.
        */
        bool addInput(VALUE obj,FXuint mode,FXObject *tgt,FXSelector sel){
          FXInputHandle fd;
          FXuint m;
          if(mode&INPUT_READ){
            m=INPUT_READ;
    	if(mode&INPUT_EXCEPT) m|=INPUT_EXCEPT;
            fd=FXRbGetReadFileHandle(obj);
    	self->addInput(fd,m,tgt,sel);
            }
          if(mode&INPUT_WRITE){
            m=INPUT_WRITE;
    	if(mode&INPUT_EXCEPT) m|=INPUT_EXCEPT;
            fd=FXRbGetWriteFileHandle(obj);
    	self->addInput(fd,m,tgt,sel);
            }
          return true;
          }
    
        /**
        * Remove input message and target object for the specified file descriptor
        * and mode, which is a bitwise OR of (INPUT_READ, INPUT_WRITE, INPUT_EXCEPT).
        */
        bool removeInput(VALUE obj,FXuint mode){
          FXInputHandle fd;
          FXuint m;
          if(mode&INPUT_READ){
            m=INPUT_READ;
    	if(mode&INPUT_EXCEPT) m|=INPUT_EXCEPT;
            fd=FXRbGetReadFileHandle(obj);
    	self->removeInput(fd,m);
            }
          if(mode&INPUT_WRITE){
            m=INPUT_WRITE;
    	if(mode&INPUT_EXCEPT) m|=INPUT_EXCEPT;
            fd=FXRbGetWriteFileHandle(obj);
    	self->removeInput(fd,m);
            }
          return true;
          }
      }
    
      /// Return key state
      bool getKeyState(FXuint keysym) const;
    
      /// Peek to determine if there's an event
      bool peekEvent();
    
      /// Perform one event dispatch; return true if event was dispatched
      bool runOneEvent(bool blocking=true);
    
      /**
      * Run the main application event loop until stop() is called,
      * and return the exit code passed as argument to stop().
      */
      FXint run();
    
      /**
      * Run an event loop till some flag becomes non-zero, and
      * then return.
      */
      FXint runUntil(FXuint& condition); // FIXME
    
      /**
      * Run event loop while events are available, non-modally.
      * Return when no more events, timers, or chores are outstanding.
      */
      FXint runWhileEvents();
    
      /**
      * Run event loop while there are events are available in the queue.
      * Returns 1 when all events in the queue have been handled, and 0 when
      * the event loop was terminated due to stop() or stopModal().
      * Except for the modal window and its children, user input to all windows 
      * is blocked; if the modal window is NULL, all user input is blocked.
      */
      FXint runModalWhileEvents(FXWindow* window=NULL);
    
      /**
      * Run modal event loop, blocking keyboard and mouse events to all windows
      * until stopModal is called.
      */
      FXint runModal();
    
      /**
      * Run a modal event loop for the given window, until stop() or stopModal() is 
      * called. Except for the modal window and its children, user input to all
      * windows is blocked; if the modal window is NULL all user input is blocked.
      */
      FXint runModalFor(FXWindow* window);
    
      /**
      * Run modal while window is shown, or until stop() or stopModal() is called. 
      * Except for the modal window and its children, user input to all windows
      * is blocked; if the modal window is NULL all user input is blocked.
      */
      FXint runModalWhileShown(FXWindow* window);
    
      /**
      * Run popup menu while shown, until stop() or stopModal() is called.
      * Also returns when entering previous cascading popup menu.
      */
      FXint runPopup(FXWindow* window);
    
      /// True if the window is modal
      bool isModal(FXWindow* window) const;
    
      /// Return window of current modal loop
      FXWindow* getModalWindow() const;
    
      /// Return mode of current modal loop
      FXModality getModality() const;
    
      /**
      * Terminate the outermost event loop, and all inner modal loops;
      * All more deeper nested event loops will be terminated with code equal
      * to 0, while the outermost event loop will return code equal to value.
      */
      void stop(FXint value=0);
    
      /**
      * Break out of the matching modal loop, returning code equal to value.
      * All deeper nested event loops are terminated with code equal to 0.
      */
      void stopModal(FXWindow* window,FXint value=0);
    
      /** 
      * Break out of the innermost modal loop, returning code equal to value.
      */
      void stopModal(FXint value=0);
    
      /// Force GUI refresh
      void forceRefresh();
    
      /// Schedule a refresh
      void refresh();
    
      /// Flush pending repaints
      void flush(bool sync=false);
    
      /**
      * Paint all windows marked for repainting.
      * On return all the applications windows have been painted.
      */
      void repaint();
    
      /**
       * Return a reference to the registry.  The registry keeps
       * settings and configuration information for an application,
       * which are automatically loaded when the application starts
       * up, and saved when the application terminates.
       */
      FXRegistry& reg();
    
      /// Register new DND type
      FXDragType registerDragType(const FXString& name) const;
    
      /// Get drag type name
      FXString getDragTypeName(FXDragType type) const;
    
      /// Return drag window if a drag operation is in progress
      FXWindow* getDragWindow() const;
    
      /// Beep
      void beep();
    
      /// Return application instance
      static inline FXApp* instance();
    
      %extend {
        /// Change default font
        void setNormalFont(FXFont* font){
          FXASSERT(font);
          if(font->isMemberOf(FXMETACLASS(FXRbFont))){
            dynamic_cast<FXRbFont*>(font)->ownedByApp=TRUE;
    	}
          self->setNormalFont(font);
          }
      }
    
      /// Return default font
      FXFont* getNormalFont() const;
    
      /// Begin of wait-cursor block; wait-cursor blocks may be nested.
      void beginWaitCursor();
    
      /// End of wait-cursor block
      void endWaitCursor();
    
      %extend {
        /// Change to a new wait cursor
        void setWaitCursor(FXCursor *cur){
          FXASSERT(cur);
          if(cur->isMemberOf(FXMETACLASS(FXRbCursor))){
            dynamic_cast<FXRbCursor*>(cur)->ownedByApp=TRUE;
    	}
          else if(cur->isMemberOf(FXMETACLASS(FXRbCURCursor))){
            dynamic_cast<FXRbCURCursor*>(cur)->ownedByApp=TRUE;
    	}
          else if(cur->isMemberOf(FXMETACLASS(FXRbGIFCursor))){
            dynamic_cast<FXRbGIFCursor*>(cur)->ownedByApp=TRUE;
    	}
          self->setWaitCursor(cur);
          }
      }
    
      /// Return current wait cursor  
      FXCursor* getWaitCursor() const;
    
      /// Obtain a default cursor
      FXCursor* getDefaultCursor(FXDefaultCursor which) const;
    
      %extend {
        /// Change default cursor
        void setDefaultCursor(FXDefaultCursor which,FXCursor* cur){
          FXASSERT(cur);
          if(cur->isMemberOf(FXMETACLASS(FXRbCursor))){
            dynamic_cast<FXRbCursor*>(cur)->ownedByApp=TRUE;
    	}
          else if(cur->isMemberOf(FXMETACLASS(FXRbCURCursor))){
            dynamic_cast<FXRbCURCursor*>(cur)->ownedByApp=TRUE;
    	}
          else if(cur->isMemberOf(FXMETACLASS(FXRbGIFCursor))){
            dynamic_cast<FXRbGIFCursor*>(cur)->ownedByApp=TRUE;
    	}
          self->setDefaultCursor(which,cur);
          }
      }
    
      /**
       * Write a window and its children, and all resources reachable from this
       * window, into the stream store.
       */
      FXbool writeWindow(FXStream& store,FXWindow *window);
    
      %extend {
        /**
         * Read a window and its children from the stream store, and append
         * it under father; note it is initially not created yet.
         */
        FXWindow* readWindow(FXStream& store,FXWindow*& window,FXWindow* father,FXWindow* owner){
          window=0;
          self->readWindow(store,window,father,owner);
          return window;
          }
      }
    
      /**
      * Return a reference to the application-wide mutex.
      * Normally, the main user interface thread holds this mutex,
      * insuring that no other threads are modifying data during the
      * processing of user interface messages. However, whenever the
      * main user interface thread blocks for messages, it releases
      * this mutex, to allow other threads to modify the same data.
      * When a new message becomes available, the main user interface
      * thread regains the mutex prior to dispatching the message.
      * Other threads should hold this mutex only for short durations,
      * so as to not starve the main user interface thread.
      */
      FXMutex& mutex();
    
      /**
      * Change message translator.
      * The new translator will be owned by FXApp.
      */
      void setTranslator(FXTranslator* trans);
    
      /// Return message translator
      FXTranslator* getTranslator() const;
    
      /// Obtain application-wide settings
      FXuint getTypingSpeed() const;
      FXuint getClickSpeed() const;
      FXuint getScrollSpeed() const;
      FXuint getScrollDelay() const;
      FXuint getBlinkSpeed() const;
      FXuint getAnimSpeed() const;
      FXuint getMenuPause() const;
      FXuint getTooltipPause() const;
      FXuint getTooltipTime() const;
      FXint getDragDelta() const;
      FXint getWheelLines() const;
      FXint getScrollBarSize() const;
    
      /// Change application-wide settings
      void setTypingSpeed(FXuint speed);
      void setClickSpeed(FXuint speed);
      void setScrollSpeed(FXuint speed);
      void setScrollDelay(FXuint delay);
      void setBlinkSpeed(FXuint speed);
      void setAnimSpeed(FXuint speed);
      void setMenuPause(FXuint pause);
      void setTooltipPause(FXuint pause);
      void setTooltipTime(FXuint time);
      void setDragDelta(FXint delta);
      void setWheelLines(FXint lines);
      void setScrollBarSize(FXint size);
    
      /// Obtain default colors
      FXColor getBorderColor() const;
      FXColor getBaseColor() const;
      FXColor getHiliteColor() const;
      FXColor getShadowColor() const;
      FXColor getBackColor() const;
      FXColor getForeColor() const;
      FXColor getSelforeColor() const;
      FXColor getSelbackColor() const;
      FXColor getTipforeColor() const;
      FXColor getTipbackColor() const;
      FXColor getSelMenuTextColor() const;
      FXColor getSelMenuBackColor() const;
    
      /// Change default colors
      void setBorderColor(FXColor color);
      void setBaseColor(FXColor color);
      void setHiliteColor(FXColor color);
      void setShadowColor(FXColor color);
      void setBackColor(FXColor color);
      void setForeColor(FXColor color);
      void setSelforeColor(FXColor color);
      void setSelbackColor(FXColor color);
      void setTipforeColor(FXColor color);
      void setTipbackColor(FXColor color);
      void setSelMenuTextColor(FXColor color);
      void setSelMenuBackColor(FXColor color);
    
      /// Dump widget information
      void dumpWidgets() const;
    
      /// Get number of existing windows
      FXuint getWindowCount() const;
    
      /// Destroy the application and all reachable resources
      virtual ~FXApp();
      };
    
    DECLARE_FXOBJECT_VIRTUALS(FXApp)
    DECLARE_FXAPP_VIRTUALS(FXApp)
    
    #ifdef SWIGRUBY
    
    %rename("threadsEnabled=") FXApp::setThreadsEnabled(FXbool);
    %rename("threadsEnabled?") FXApp::threadsEnabled() const;
    
    %extend FXApp {
      // Enable (or disable) support for multithreaded applications
      void setThreadsEnabled(FXbool enabled){
        FXASSERT(self->isMemberOf(FXMETACLASS(FXRbApp)));
        dynamic_cast<FXRbApp*>(self)->setThreadsEnabled(enabled);
        }
    
      // Are threads enabled?
      FXbool threadsEnabled() const {
        FXASSERT(self->isMemberOf(FXMETACLASS(FXRbApp)));
        return dynamic_cast<const FXRbApp*>(self)->threadsEnabled();
        }
    
      // Set the amount of time to sleep
      void setSleepTime(FXuint sleepTime){
        FXASSERT(self->isMemberOf(FXMETACLASS(FXRbApp)));
        dynamic_cast<FXRbApp*>(self)->setSleepTime(sleepTime);
        }
    
      // Get the amount of time to sleep
      FXuint getSleepTime() const {
        FXASSERT(self->isMemberOf(FXMETACLASS(FXRbApp)));
        return dynamic_cast<const FXRbApp*>(self)->getSleepTime();
        }
      }
    
    #endif