formelemselect.h

Go to the documentation of this file.

/**
 * \file mgui/formelemselect.h
 * \brief MGUI::FORM_ELEMENT_SELECT class definitions
 *
 * \if NODOC
 * $Id: formelemselect.h_v 1.14 2005/03/08 14:32:49 mju Exp $
 *
 * $Log: formelemselect.h_v $
 * Revision 1.14  2005/03/08 14:32:49  mju
 * Update for form_object_list change for onObjectSelected.
 *
 * Revision 1.13  2004/10/22 17:41:10  scowan
 * Added ability to apply region selection to all selected objects.
 *
 * Revision 1.12  2004/07/19 19:13:38  scowan
 * Added more to option selection.
 *
 * Revision 1.11  2004/07/08 21:01:50  scowan
 * Updated to better reuse code.
 *
 * Revision 1.10  2004/07/07 17:09:49  scowan
 * Set method pointer to null initialy.
 *
 * Revision 1.9  2004/07/02 19:27:06  scowan
 * Added a virtual method.
 *
 * Revision 1.8  2004/07/02 14:27:34  scowan
 * Added current object item number.
 *
 * Revision 1.7  2004/07/01 19:58:27  scowan
 * Now is working mostly.
 *
 * Revision 1.6  2004/07/01 16:34:57  scowan
 * Now compiles.
 *
 * Revision 1.5  2003/12/16 15:57:43  mju
 * Use dlgshell.
 *
 * Revision 1.4  2003/10/03 19:58:19  linux32build!build
 * Doxygen
 *
 * Revision 1.3  2003/09/15 13:49:32  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.2  2003/06/19 19:10:35  scowan
 * *** empty log message ***
 *
 * Revision 1.1  2003/04/24 19:08:45  scowan
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_MGUI_FORMELEMSELECT_H
#define  INC_MGUI_FORMELEMSELECT_H

#ifndef  INC_MGUI_CTRL_H
#include <mgui/ctrl.h>
#endif

#ifndef  INC_MGUI_GRID_H
#include <mgui/grid.h>
#endif

#ifndef  INC_MGUI_DLGSHELL_H
#include <mgui/dlgshell.h>
#endif

#ifndef  INC_MGUI_FORMOBJL_H
#include <mgui/formobjl.h>
#endif

#ifndef  INC_MGUI_COMBOBOX_H
#include <mgui/combobox.h>
#endif

#ifndef  INC_RVC_GEOMETRC_H
#include <rvc/geometrc.h>
#endif

#ifndef  INC_RVC_DBASE_H
#include <rvc/dbase.h>
#endif

#ifndef  INC_RVC_DBTABLE_H
#include <rvc/dbtable.h>
#endif

#ifndef  INC_MI32_REGION2D_H
#include <mi32/region2d.h>
#endif

#ifndef  INC_MI32_TEXTID_H
#include <mi32/textid.h>
#endif

#ifndef  INC_MI32_BITSET_H
#include <mi32/bitset.h>
#endif

#ifndef  INC_MI32_OBSERVER_H
   #include <mi32/observer.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
class ELEMTYPESET;
#endif // GENERATING_DOXYGEN_OUTPUT

namespace MGUI {
   
class FORM_ELEMENT_SELECT_BASE : public MGUI::FORM_COMPOSITE {
   public:
   
      //! Constructor.
      FORM_ELEMENT_SELECT_BASE (
         );

      //! Destructor.
      virtual ~FORM_ELEMENT_SELECT_BASE (
         );
   
      void SetGeometricObject (
         const RVC::OBJITEM& ObjItem
         );
         
   protected:
      ERRVALUE CreateBase (MGUI::LAYOUT_PANE_BASE& ParentPane, bool AllowNone = true);
      TEXTID GetTextID (ELEMTYPE ElemType);
      void SetElemSelectParmsItemBase (RVC::GEOMETRIC::ELEMSELECTPARMS::ITEM& item);
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MGUI::CTRL_COMBOBOX_T<FORM_ELEMENT_SELECT_BASE> m_ElemSelect;
      MGUI::CTRL_PUSHBUTTON_T<FORM_ELEMENT_SELECT_BASE> m_Select;
      RVC::OBJITEM m_ObjItem;
      
      virtual ELEMTYPE v_GetCurElemType () const = 0;
      virtual RVC::GEOMETRIC::ELEMSELECTPARMS::ITEM& v_GetCurSelectParmItem () = 0;

      void OnSelection ();
      void OnSelectPressed ();
      void UpdateState ();
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

   
class FORM_ELEMENT_SELECT : public FORM_ELEMENT_SELECT_BASE {
   public:
   
      //! Constructor.
      FORM_ELEMENT_SELECT (
         );

      //! Destructor.
      virtual ~FORM_ELEMENT_SELECT (
         );
   
      ERRVALUE Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,          //!< Parent pane
         ELEMTYPE ElemType,
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize
         );
         
      const RVC::GEOMETRIC::ELEMSELECTPARMS::ITEM& GetElemSelectParmsItem (
         );
         
      CTRL_LABEL& GetLabel (
         );
         
      void SetElemSelectParmsItem (
         const RVC::GEOMETRIC::ELEMSELECTPARMS::ITEM& item
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MGUI::CTRL_LABEL m_Label;
      RVC::GEOMETRIC::ELEMSELECTPARMS::ITEM m_SelectItem;
      ELEMTYPE m_ElemType;

      virtual ELEMTYPE v_GetCurElemType () const;
      virtual RVC::GEOMETRIC::ELEMSELECTPARMS::ITEM& v_GetCurSelectParmItem ();
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   

class FORM_ELEMENT_SELECT_OPTION : public FORM_ELEMENT_SELECT_BASE {
   public:
   
      //! Constructor.
      FORM_ELEMENT_SELECT_OPTION (
         );

      //! Destructor.
      virtual ~FORM_ELEMENT_SELECT_OPTION (
         );
   
      ERRVALUE Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,          //!< Parent pane
         RVC::OBJTYPE ObjType,
         const ELEMTYPESET& ValidTypes,
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize
         );
         
      const RVC::GEOMETRIC::ELEMSELECTPARMS& GetElemSelectParms (
         );
         
      void SetElemSelectParms (
         const RVC::GEOMETRIC::ELEMSELECTPARMS& parms
         );
         
      void SetElemTypeSet (
         const ELEMTYPESET& ValidTypes
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MGUI::CTRL_COMBOBOX_T<FORM_ELEMENT_SELECT_OPTION> m_ElemTypeSelect;
      RVC::GEOMETRIC::ELEMSELECTPARMS m_SelectParms;
      ELEMTYPE m_ElemType;
      RVC::OBJTYPE m_ObjType;

      virtual ELEMTYPE v_GetCurElemType () const;
      virtual RVC::GEOMETRIC::ELEMSELECTPARMS::ITEM& v_GetCurSelectParmItem ();
      
      void OnElemTypeSelect ();
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


   
class FORM_REGION_SELECT : public MGUI::FORM_COMPOSITE {
   public:
   
      //! Constructor.
      FORM_REGION_SELECT (
         );

      //! Destructor.
      virtual ~FORM_REGION_SELECT (
         );
   
      ERRVALUE Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,          //!< Parent pane
         RVC::OBJTYPE DestObjType,
         bool AddApplyToAllBtn = false,
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize
         );
         
      RVC::GEOMETRIC::ELEMSELECTPARMS::EXTRACT GetExtractMode (
         ) const;
         
      CTRL_LABEL& GetLabel (
         );
         
      const REGION2D& GetRegion (
         ) const;
         
      bool IsAddBorderEnabled (
         ) const;
         
      void SetAddBorder (
         bool value
         );
         
      void SetExtractMode (
         RVC::GEOMETRIC::ELEMSELECTPARMS::EXTRACT ExtractMode
         );
         
      void SetGeometricObject (
         const RVC::OBJITEM& ObjItem
         );
   
      void SetRegion (
         const REGION2D& region
         );
         
   private:
      virtual void v_OnApplyToAll ();
   
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MGUI::FORM_COMBOBOX_T<FORM_REGION_SELECT> m_ExtractSelect;
      MGUI::CTRL_PUSHBUTTON_T<FORM_REGION_SELECT> m_Select;
      MGUI::CTRL_PUSHBUTTON_T<FORM_REGION_SELECT> m_ApplyToAll;
      MGUI::CTRL_TOGGLEBUTTON m_AddBorder;
      RVC::OBJITEM m_ObjItem;
      REGION2D m_Region;
      RVC::OBJTYPE m_DestObjType;

      void OnApplyToAllPressed ();
      void OnSelection ();
      void OnSelectPressed ();
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//-------------------------------------------------------------------------------------------------------------------
//! Convenience template for FORM_REGION_SELECT form to allow method in container class to be called.
//! This template allows a method in a 'container' class to be called when the button is pressed,
//! rather than requiring that a subclass be defined with the OnPressed() virtual method overridden.
template <class _CT> class FORM_REGION_SELECT_T : public MGUI::FORM_REGION_SELECT {
   public:

      //! Constructor.
      FORM_REGION_SELECT_T (
         ) : m_pContainer(0), m_pfOnApplyToAll(0) {}

      //! Create control with label from resource lookup.
      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    //!< Parent pane
         _CT *pContainer,                       //!< Pointer to callback container class
         void (_CT::*pfOnApplyToAll)(),         //! Callback function pointer
         RVC::OBJTYPE DestObjType,
         bool AddApplyToAllBtn = false,
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize
         ) {
         m_pContainer = pContainer;
         m_pfOnApplyToAll = pfOnApplyToAll;
         FORM_REGION_SELECT::Create(ParentPane, DestObjType, AddApplyToAllBtn, sizealign);
         }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      _CT *m_pContainer;
      void (_CT::*m_pfOnApplyToAll)();
      
      virtual void v_OnApplyToAll () { if (m_pfOnApplyToAll != 0) (m_pContainer->*m_pfOnApplyToAll)(); }
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward Declarations
class FORM_BASE_ELEMENT_SELECT_OBSERVER;
#endif // GENERATING_DOXYGEN_OUTPUT

class FORM_BASE_ELEMENT_SELECT : public MGUI::FORM_COMPOSITE, public SUBJECT<FORM_BASE_ELEMENT_SELECT_OBSERVER> {
   public:
   
      enum REGIONFLAGS {
         REGIONFLAG_None = 0,
         REGIONFLAG_NoSelection = 1,
         REGIONFLAG_AddApplyToAllBtn = 2
         };
   
      //! Constructor.
      FORM_BASE_ELEMENT_SELECT (
         );

      //! Destructor.
      virtual ~FORM_BASE_ELEMENT_SELECT (
         );
   
      ERRVALUE Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,          //!< Parent pane
         RVC::OBJTYPE DestObjType,
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_FixedSize,
         REGIONFLAGS RegionFlags = REGIONFLAG_None
         );
         
      const RVC::GEOMETRIC::ELEMSELECTPARMS& GetElemSelectParms (
         );
         
      bool IsAddBorderEnabled (
         ) const;
         
      void SetAddBorder (
         bool value
         );
         
      void SetElemSelectParms (
         const RVC::GEOMETRIC::ELEMSELECTPARMS& parms
         );
         
      void SetObject (
         const RVC::OBJITEM& ObjItem
         );
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      FORM_REGION_SELECT_T<FORM_BASE_ELEMENT_SELECT> m_Region;
      RVC::GEOMETRIC::ELEMSELECTPARMS m_SelectParms;

      void CallOnApplyToAll ();
            
      virtual ERRVALUE v_CreateContent (MGUI::LAYOUT_PANE_BASE& ParentPane, MGUI::LAYOUT_EQUALIZER& eq) = 0;
      virtual void v_GetElemSelectParms (RVC::GEOMETRIC::ELEMSELECTPARMS& parms) = 0;
      virtual void v_SetElemSelectParms (const RVC::GEOMETRIC::ELEMSELECTPARMS& parms) = 0;
      virtual void v_SetObject (const RVC::OBJITEM& ObjItem) = 0;
   
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
DEFINE_ENUM_OP_BITWISE(FORM_BASE_ELEMENT_SELECT::REGIONFLAGS);
   

class FORM_BASE_ELEMENT_SELECT_OBSERVER : public OBSERVER_BASE {
   public:

      FORM_BASE_ELEMENT_SELECT_OBSERVER (
         FORM_BASE_ELEMENT_SELECT& fbes
         ) :
         OBSERVER_BASE(fbes)
         {}
         
      virtual ~FORM_BASE_ELEMENT_SELECT_OBSERVER (
         ) {}

      virtual void v_OnApplyToAll (
         ) { return; }
   };

   
class FORM_VECTOR_ELEMENT_SELECT : public FORM_BASE_ELEMENT_SELECT {
   public:
   
      //! Constructor.
      FORM_VECTOR_ELEMENT_SELECT (
         );

      //! Destructor.
      virtual ~FORM_VECTOR_ELEMENT_SELECT (
         );
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      FORM_ELEMENT_SELECT m_Point;
      FORM_ELEMENT_SELECT m_Line;
      FORM_ELEMENT_SELECT m_Polygon;
      FORM_ELEMENT_SELECT m_Label;

      virtual ERRVALUE v_CreateContent (MGUI::LAYOUT_PANE_BASE& ParentPane, MGUI::LAYOUT_EQUALIZER& eq);
      virtual void v_GetElemSelectParms (RVC::GEOMETRIC::ELEMSELECTPARMS& parms);
      virtual void v_SetElemSelectParms (const RVC::GEOMETRIC::ELEMSELECTPARMS& parms);
      virtual void v_SetObject (const RVC::OBJITEM& ObjItem);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
   
class FORM_CAD_ELEMENT_SELECT : public FORM_BASE_ELEMENT_SELECT {
   public:
   
      //! Constructor.
      FORM_CAD_ELEMENT_SELECT (
         );

      //! Destructor.
      virtual ~FORM_CAD_ELEMENT_SELECT (
         );
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      FORM_ELEMENT_SELECT m_Element;

      virtual ERRVALUE v_CreateContent (MGUI::LAYOUT_PANE_BASE& ParentPane, MGUI::LAYOUT_EQUALIZER& eq);
      virtual void v_GetElemSelectParms (RVC::GEOMETRIC::ELEMSELECTPARMS& parms);
      virtual void v_SetElemSelectParms (const RVC::GEOMETRIC::ELEMSELECTPARMS& parms);
      virtual void v_SetObject (const RVC::OBJITEM& ObjItem);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
   
class FORM_TIN_ELEMENT_SELECT : public FORM_BASE_ELEMENT_SELECT {
   public:
   
      //! Constructor.
      FORM_TIN_ELEMENT_SELECT (
         );

      //! Destructor.
      virtual ~FORM_TIN_ELEMENT_SELECT (
         );
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      FORM_ELEMENT_SELECT m_Node;
      FORM_ELEMENT_SELECT m_Edge;
      FORM_ELEMENT_SELECT m_Triangle;

      virtual ERRVALUE v_CreateContent (MGUI::LAYOUT_PANE_BASE& ParentPane, MGUI::LAYOUT_EQUALIZER& eq);
      virtual void v_GetElemSelectParms (RVC::GEOMETRIC::ELEMSELECTPARMS& parms);
      virtual void v_SetElemSelectParms (const RVC::GEOMETRIC::ELEMSELECTPARMS& parms);
      virtual void v_SetObject (const RVC::OBJITEM& ObjItem);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
   
class FORM_SHAPE_ELEMENT_SELECT : public FORM_BASE_ELEMENT_SELECT {
   public:
   
      //! Constructor.
      FORM_SHAPE_ELEMENT_SELECT (
         );

      //! Destructor.
      virtual ~FORM_SHAPE_ELEMENT_SELECT (
         );
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      FORM_ELEMENT_SELECT m_Element;

      virtual ERRVALUE v_CreateContent (MGUI::LAYOUT_PANE_BASE& ParentPane, MGUI::LAYOUT_EQUALIZER& eq);
      virtual void v_GetElemSelectParms (RVC::GEOMETRIC::ELEMSELECTPARMS& parms);
      virtual void v_SetElemSelectParms (const RVC::GEOMETRIC::ELEMSELECTPARMS& parms);
      virtual void v_SetObject (const RVC::OBJITEM& ObjItem);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
   
class FORM_REGION_ELEMENT_SELECT : public FORM_BASE_ELEMENT_SELECT {
   public:
      //! Constructor.
      FORM_REGION_ELEMENT_SELECT (
         );

      //! Destructor.
      virtual ~FORM_REGION_ELEMENT_SELECT (
         );
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      FORM_ELEMENT_SELECT m_Element;

      virtual ERRVALUE v_CreateContent (MGUI::LAYOUT_PANE_BASE& ParentPane, MGUI::LAYOUT_EQUALIZER& eq);
      virtual void v_GetElemSelectParms (RVC::GEOMETRIC::ELEMSELECTPARMS& parms);
      virtual void v_SetElemSelectParms (const RVC::GEOMETRIC::ELEMSELECTPARMS& parms);
      virtual void v_SetObject (const RVC::OBJITEM& ObjItem);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
   
class FORM_GEOMETRIC_EXTRACT_SELECT : public MGUI::FORM_COMPOSITE {
   public:
   
      //! Constructor.
      FORM_GEOMETRIC_EXTRACT_SELECT (
         );

      //! Destructor.
      virtual ~FORM_GEOMETRIC_EXTRACT_SELECT (
         );
         
      void Clear (
         );
   
      ERRVALUE Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,                   //!< Parent pane
         const RVC::OBJTYPESET& GeometricSet,                  //!< Set of geometric objects to work on
         RVC::OBJTYPE DestObjType,
         TEXTID TextID = TEXTID_Prompt_Objects_ToProcess,      //!< Usually in the form of TEXTID_Prompt_XXXs_Input
         GETOBJFLAGS GetObjFlags = GETOBJFLAG_None,
         RVC::GETOBJFILTER* GetObjFilter = 0,
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_Expand,
         FORM_BASE_ELEMENT_SELECT::REGIONFLAGS RegionFlags = FORM_BASE_ELEMENT_SELECT::REGIONFLAG_None
         );
         
      const BITSET_UNOWNED& GetAddBorderSet (
         );
         
      const MILIST<RVC::GEOMETRIC::ELEMSELECTPARMS>& GetElemSelectParms (
         );
         
      const RVC::OBJITEMLIST& GetGeometricList (
         ) const;
         
   protected:
   
      virtual void v_OnObjectSelected (const RVC::OBJITEM& ObjItem);
      virtual void v_OnObjectAdded (const RVC::OBJITEM& ObjItem, INT32 ItemNum);
   
   private:
      class SELECT_OBSERVER : public FORM_BASE_ELEMENT_SELECT_OBSERVER {
         public:
            SELECT_OBSERVER (
               FORM_GEOMETRIC_EXTRACT_SELECT& fges,
               FORM_BASE_ELEMENT_SELECT& fbes
               ) : 
               FORM_BASE_ELEMENT_SELECT_OBSERVER(fbes), 
               m_fges(fges) 
               {}
               
            virtual ~SELECT_OBSERVER () {}
         private:
            FORM_GEOMETRIC_EXTRACT_SELECT& m_fges;
            virtual void v_OnApplyToAll ();
         };
      friend class SELECT_OBSERVER;
   
      #ifndef GENERATING_DOXYGEN_OUTPUT
      FORM_OBJECT_LIST_T<FORM_GEOMETRIC_EXTRACT_SELECT> m_GeometricList;
      FORM_VECTOR_ELEMENT_SELECT m_VectorSelect;
      SELECT_OBSERVER* m_VectorObserver;
      FORM_CAD_ELEMENT_SELECT m_CADSelect;
      SELECT_OBSERVER* m_CADObserver;
      FORM_TIN_ELEMENT_SELECT m_TINSelect;
      SELECT_OBSERVER* m_TINObserver;
      FORM_SHAPE_ELEMENT_SELECT m_ShapeSelect;
      SELECT_OBSERVER* m_ShapeObserver;
      FORM_REGION_ELEMENT_SELECT m_RegionSelect;
      SELECT_OBSERVER* m_RegionObserver;
      
      MILIST<RVC::GEOMETRIC::ELEMSELECTPARMS> m_SelectParms;
      BITSET m_AddBorder;
      INT32 m_CurItem;

      bool GetCurAddBorderFlag (RVC::OBJTYPE ObjType);
      const RVC::GEOMETRIC::ELEMSELECTPARMS& GetCurElemSelectParms (RVC::OBJTYPE ObjType);
      void SetCurAddBorderFlag (RVC::OBJTYPE ObjType, bool value);
      void SetCurElemSelectParms (RVC::OBJTYPE ObjType, const RVC::GEOMETRIC::ELEMSELECTPARMS& SelectParms);
      void SetCurElemSelectParmObjItem (const RVC::OBJITEM& ObjItem);
      void SetRegionForAllObjects ();
            
      void OnObjectAdded (const RVC::OBJITEM& ObjItem, INT32 ItemNum);
      void OnObjectRemoved (INT32 ItemNum);
      void OnObjectSelected (const RVC::OBJITEM& ObjItem, INT32 ItemNum);
      void OnObjectsRemoved ();
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   

//-------------------------------------------------------------------------------------------------------------------
//! Convenience template for OBJECT_LIST form to allow method in container class to be called.
//! This template allows a method in a 'container' class to be called when the button is pressed,
//! rather than requiring that a subclass be defined with the OnPressed() virtual method overridden.
template <class _CT> class FORM_GEOMETRIC_EXTRACT_SELECT_T : public MGUI::FORM_GEOMETRIC_EXTRACT_SELECT {
   public:

      //! Constructor.
      FORM_GEOMETRIC_EXTRACT_SELECT_T (
         ) : m_pContainer(0), m_pfOnObjectSelected(0), m_pfOnObjectAdded(0) {}

      //! Create control with label from resource lookup.
      void Create (
         MGUI::LAYOUT_PANE_BASE& ParentPane,    //!< Parent pane
         _CT *pContainer,                       //!< Pointer to callback container class
         void (_CT::*pfOnObjectSelected)(const RVC::OBJITEM& ObjItem),        //! Callback function pointer
         const RVC::OBJTYPESET& GeometricSet,                  //!< Set of geometric objects to work on
         RVC::OBJTYPE DestObjType,
         TEXTID TextID = TEXTID_Prompt_Objects_ToProcess,      //!< Usually in the form of TEXTID_Prompt_XXXs_Input
         GETOBJFLAGS GetObjFlags = GETOBJFLAG_None,
         RVC::GETOBJFILTER* GetObjFilter = 0,
         MGUI::LAYOUT_SIZEALIGN sizealign = MGUI::LAYOUT_SIZEALIGN_Expand,
         FORM_BASE_ELEMENT_SELECT::REGIONFLAGS RegionFlags = FORM_BASE_ELEMENT_SELECT::REGIONFLAG_None
         ) {
         m_pContainer = pContainer;
         m_pfOnObjectSelected = pfOnObjectSelected;
         FORM_GEOMETRIC_EXTRACT_SELECT::Create(ParentPane, GeometricSet, DestObjType, TextID, GetObjFlags, GetObjFilter, sizealign, RegionFlags);
         }

      //! Set method to call when user adds an object to the list
      void SetObjectAdded (
         void (_CT::*ObjectAdded)(const RVC::OBJITEM& ObjItem, INT32 ItemNum)
         ) { m_pfOnObjectAdded = ObjectAdded; };

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      _CT *m_pContainer;
      void (_CT::*m_pfOnObjectSelected)(const RVC::OBJITEM& ObjItem);
      void (_CT::*m_pfOnObjectAdded)(const RVC::OBJITEM& ObjItem, INT32 ItemNum);
      
      virtual void v_OnObjectAdded (const RVC::OBJITEM& ObjItem, INT32 ItemNum) { if (m_pfOnObjectAdded != 0) (m_pContainer->*m_pfOnObjectAdded)(ObjItem, ItemNum); }
      virtual void v_OnObjectSelected (const RVC::OBJITEM& ObjItem) { (m_pContainer->*m_pfOnObjectSelected)(ObjItem); }
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

   
class DLG_RECORD_SET_SELECT : public MGUI::DLGSHELL {
   public:

      //! Constructor.
      DLG_RECORD_SET_SELECT (
         const RVC::OBJITEM& ParentObjItem,
         ELEMTYPE ElemType
         );
   
      //! Destructor.
      virtual ~DLG_RECORD_SET_SELECT (
         );
         
      const BITSET& GetRecordSet (
         ) const { return (m_RecordSet); }
   
      const RVC::OBJECTNAME& GetTableName (
         ) const { return (m_TableName); }
   
      void SetRecordSet (
         const BITSET& RecordSet
         );
   
      void SetTableName (
         const RVC::OBJECTNAME& TableName
         );
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MGUI::LAYOUT_PANE m_IconPane;
      MGUI::FORM_COMBOBOX_T<DLG_RECORD_SET_SELECT> m_FieldSelect;
      MGUI::CTRL_PUSHBUTTON_T<DLG_RECORD_SET_SELECT> m_Select;
      MGUI::CTRL_PUSHBUTTON_T<DLG_RECORD_SET_SELECT> m_SelectAll;
      MGUI::CTRL_PUSHBUTTON_T<DLG_RECORD_SET_SELECT> m_Unselect;
      MGUI::CTRL_PUSHBUTTON_T<DLG_RECORD_SET_SELECT> m_UnselectAll;
      MGUI::CTRL_GRID_T<DLG_RECORD_SET_SELECT> m_RecGrid;
      RVC::OBJITEM m_ObjItem;
      RVC::DBASE m_DBaseObj;
      RVC::DBTABLE m_TableObj;
      RVC::DBTABLE::RECORD m_Record;
      SIMPLE_ARRAY<INT32> m_RecIndex;
      BITSET m_DuplicateBits;
      RVC::OBJECTNAME m_TableName;
      INT32 m_FieldNum;
      BITSET m_RecordSet;
      ELEMTYPE m_ElemType;

      virtual ERRVALUE v_CreateContent ();

      void OnClickItem (int itemnum, int column, KEYSTATE state);    
      void OnFieldSelect ();
      bool OnGetDispInfo (int row, int col, CTRL_GRID::DISPINFO& dispinfo);
      void OnSelectPressed ();
      void OnSelectAllPressed ();
      void OnUnselectPressed ();
      void OnUnselectAllPressed ();
      #endif // GENERATING_DOXYGEN_OUTPUT

   };
   
}     // End of MGUI namespace

#endif   // INC_MGUI_FORMELEMSELECT_H

---