Flu_DND.h
上传用户:yhdzpy8989
上传日期:2007-06-13
资源大小:13604k
文件大小:8k
源码类别:

生物技术

开发平台:

C/C++

  1. /*
  2.  * ===========================================================================
  3.  * PRODUCTION $Log: Flu_DND.h,v $
  4.  * PRODUCTION Revision 1000.0  2004/04/12 18:21:29  gouriano
  5.  * PRODUCTION PRODUCTION: IMPORTED [CATCHUP_003] Dev-tree R1.1
  6.  * PRODUCTION
  7.  * ===========================================================================
  8.  */
  9. /*
  10.  * These files were imported into NCBI's CVS directly from FLU version 2.9.1.
  11.  * Modifications to the source are listed below.
  12.  *
  13.  * ==========================================================================
  14.  * $Log: Flu_DND.h,v $
  15.  * Revision 1000.0  2004/04/12 18:21:29  gouriano
  16.  * PRODUCTION: IMPORTED [CATCHUP_003] Dev-tree R1.1
  17.  *
  18.  * Revision 1.1  2004/03/11 13:51:54  dicuccio
  19.  * Imported FLU version 2.9.1.  Altered export specifiers to match NCBI layout.
  20.  * Altered include paths to match NCBI toolkit layout.
  21.  *
  22.  * ==========================================================================
  23.  */
  24. // $Id: Flu_DND.h,v 1000.0 2004/04/12 18:21:29 gouriano Exp $
  25. /***************************************************************
  26.  *                FLU - FLTK Utility Widgets 
  27.  *  Copyright (C) 2002 Ohio Supercomputer Center, Ohio State University
  28.  *
  29.  * This file and its content is protected by a software license.
  30.  * You should have received a copy of this license with this file.
  31.  * If not, please contact the Ohio Supercomputer Center immediately:
  32.  * Attn: Jason Bryan Re: FLU 1224 Kinnear Rd, Columbus, Ohio 43212
  33.  * 
  34.  ***************************************************************/
  35. #ifndef _FLU_DND_H
  36. #define _FLU_DND_H
  37. #include <FL/Fl.H>
  38. #include <FL/fl_draw.H>
  39. #include <stdlib.h>
  40. #include <string.h>
  41. #include <gui/widgets/FLU/Flu_Enumerations.h>
  42. #define FLU_DND_MAX_TYPES 32
  43. //! This class encapsulates the event state for a single dragged object, and is designed to work exclusively with Flu_DND
  44. class NCBI_GUIWIDGETS_FLU_EXPORT Flu_DND_Event
  45. {
  46.   friend class Flu_DND;
  47.  public:
  48.   //! Default constructor
  49.   Flu_DND_Event();
  50.   //! Default destructor
  51.   ~Flu_DND_Event();
  52.   //! return c true if currently dragging an object, c false otherwise
  53.   inline bool event_is_valid() const
  54.     { return dragging; }
  55.   //! return c true if the dragged object is normal FLTK text (see Fl::copy() ), else c false if it is an object derived from Flu_DND
  56.   inline bool event_is_text() const
  57.     { return( _text != 0 ); }
  58.   //! return c true if the dragged object is an object derived from Flu_DND, else c false if it is normal FLTK text (see Fl::copy() )
  59.   inline bool event_is_other() const
  60.     { return( _text == 0 ); }
  61.   //! return the text from Fl::copy() if this event is a text event (see event_is_text() )
  62.   /*! note This is valid only after the object has been dropped (i.e. in Flu_DND::on_dnd_drop() )*/
  63.   inline const char* text() const
  64.     { return _text; }
  65.   //! return the dragged object data as added in Flu_DND::dnd_grab() if this event is an "other" event (see event_is_other() )
  66.   /*! note This is valid only after the object has been dropped (i.e. in Flu_DND::on_dnd_drop() )*/
  67.   inline void* data() const
  68.     { return _data; }
  69.   //! return the type of the data object that was dropped. This is c NULL for FLTK text events
  70.   /*! note This is valid only after the object has been dropped (i.e. in Flu_DND::on_dnd_drop() )*/
  71.   inline const char* data_type() const
  72.     { return _dataType; }
  73.   //! return c true if the type of the data object that was dropped is equal to b t, c false otherwise
  74.   inline bool is_data_type( const char *t ) const
  75.     { if( !_dataType ) return 0; else return( strcmp( _dataType, t ) == 0 ); }
  76.   //! return the x coordinate (from Fl::event_x() ) of when the object was grabbed
  77.   inline int grab_x() const
  78.     { return _grab_x; }
  79.   //! return the y coordinate (from Fl::event_y() ) of when the object was grabbed
  80.   inline int grab_y() const
  81.     { return _grab_y; }
  82.   //! return the x coordinate (from Fl::event_x() ) of when the object was dropped
  83.   inline int drop_x() const
  84.     { return _drop_x; }
  85.   //! return the y coordinate (from Fl::event_y() ) of when the object was dropped
  86.   inline int drop_y() const
  87.     { return _drop_y; }
  88.  private:
  89.   bool dragging;
  90.   void *objUnderMouse;
  91.   char *_text, *_dataType;
  92.   void *_data;
  93.   int _grab_x, _grab_y, _drop_x, _drop_y;
  94.   bool exit;
  95.   void clear();
  96. };
  97. //! This class augments the existing FLTK drag-n-drop feature, working with Flu_DND_Event to achieve new functionality
  98. /*! It adds the ability to create specific DND objects, allowing classes that handle
  99.   DND to discriminate between which objects are "allowed" to be dropped on them.
  100.   Almost all functions are protected, since only a derived class should be in charge of what kinds of events
  101.   to handle and what kinds of objects to support.
  102. */
  103. class NCBI_GUIWIDGETS_FLU_EXPORT Flu_DND
  104. {
  105.  public:
  106.   //! Set the function that is called when the dragged object is dropped. This is called in addition to the member function on_dnd_drop()
  107.   inline void dnd_callback( void (*cb)(const Flu_DND_Event*,void*), void *cbd = 0 )
  108.     { dndCallback = cb; dndCallbackData = cbd; }
  109.  protected:
  110.   //! Default constructor
  111.   Flu_DND( const char *thisType );
  112.   //! Default destructor
  113.   virtual ~Flu_DND();
  114.   //! See Flu_DND_Event::event_is_text()
  115.   inline bool dnd_event_is_text() const
  116.     { return( dndEvent.dragging && !dndEvent._data ); }
  117.   //! See Flu_DND_Event::event_is_other()
  118.   inline bool dnd_event_is_other() const
  119.     { return( dndEvent.dragging && dndEvent._data ); }
  120.   //! See Flu_DND_Event::event_is_valid()
  121.   inline bool dnd_is_dragging() const
  122.     { return dndEvent.dragging; }
  123.   //! See Flu_DND_Event::is_data_type()
  124.   inline bool dnd_is_data_type( const char *t ) const
  125.     { return dndEvent.is_data_type( t ); }
  126.   //! Set whether standard FLTK text events can be dropped on this object
  127.   inline void dnd_allow_text( bool b )
  128.     { allowTextEvents = b; }
  129.   //! Get whether standard FLTK text events can be dropped on this object
  130.   inline bool dnd_allow_text() const
  131.     { return allowTextEvents; }
  132.   //! Set whether this object can be dragged to another object
  133.   inline void dnd_allow_dragging( bool b )
  134.     { allowDragging = b; }
  135.   //! Get whether this object can be dragged to another object
  136.   inline bool dnd_allow_dragging() const
  137.     { return allowDragging; }
  138.   //! Set whether this object can have other objects dropped on it
  139.   inline void dnd_allow_dropping( bool b )
  140.     { allowDropping = b; }
  141.   //! Get whether this object can have other objects dropped on it
  142.   inline bool dnd_allow_dropping() const
  143.     { return allowDropping; }
  144.   //! Add type b t to the list of types that are allowed to be dropped on this object (up to a compiled maximum of c b FLU_DND_MAX_TYPES)
  145.   void dnd_allow_type( const char *t );
  146.   //! return c true if type b t is allowed to be dropped on this object, c false otherwise
  147.   bool dnd_type_allowed( const char *t ) const;
  148.   //! Descendents should call this when they detect themselves being grabbed for a drag-n-drop
  149.   void dnd_grab( void *data, const char *type );
  150.   //! Descendents should call this at the start of their handle() method to handle DND processing
  151.   int dnd_handle( int event );
  152.   //! Descendents can override this to respond to when the mouse is let go during a drag-n-drop (regardless of whether the item was dropped on you)
  153.   virtual void on_dnd_release();
  154.   //! Descendents can override this to respond to when the mouse has entered you during a drag-n-drop
  155.   virtual void on_dnd_enter();
  156.   //! Descendents can override this to respond to when the mouse has left you during a drag-n-drop
  157.   virtual void on_dnd_leave();
  158.   //! Descendents should override this to respond to when the dragged object has been dropped on you
  159.   virtual void on_dnd_drop( const Flu_DND_Event *e );
  160.   //! Descendents should override this to indicate whether the currently dragged item is allowed to be dropped on you (for example, if the item can only be dropped at certain locations)
  161.   virtual bool on_dnd_drag( int X, int Y );
  162.  private:
  163.   bool ok2drop();
  164.   static Flu_DND_Event dndEvent;
  165.   bool allowTextEvents, allowDragging, allowDropping;
  166.   char* _thisType;
  167.   char* allowedTypes[FLU_DND_MAX_TYPES];
  168.   int nTypes;
  169.   void (*dndCallback)(const Flu_DND_Event*,void*);
  170.   void *dndCallbackData;
  171. };
  172. #endif