Control.h

Go to the documentation of this file.

//     ____   ______ __
//    / __ \ / ____// /
//   / /_/ // /    / /
//  / ____// /___ / /___   PixInsight Class Library
// /_/     \____//_____/   PCL 2.6.11
// ----------------------------------------------------------------------------
// pcl/Control.h - Released 2024-05-07T15:27:32Z
// ----------------------------------------------------------------------------
// This file is part of the PixInsight Class Library (PCL).
// PCL is a multiplatform C++ framework for development of PixInsight modules.
//
// Copyright (c) 2003-2024 Pleiades Astrophoto S.L. All Rights Reserved.
//
// Redistribution and use in both source and binary forms, with or without
// modification, is permitted provided that the following conditions are met:
//
// 1. All redistributions of source code must retain the above copyright
//    notice, this list of conditions and the following disclaimer.
//
// 2. All redistributions in binary form must reproduce the above copyright
//    notice, this list of conditions and the following disclaimer in the
//    documentation and/or other materials provided with the distribution.
//
// 3. Neither the names "PixInsight" and "Pleiades Astrophoto", nor the names
//    of their contributors, may be used to endorse or promote products derived
//    from this software without specific prior written permission. For written
//    permission, please contact info@pixinsight.com.
//
// 4. All products derived from this software, in any form whatsoever, must
//    reproduce the following acknowledgment in the end-user documentation
//    and/or other materials provided with the product:
//
//    "This product is based on software from the PixInsight project, developed
//    by Pleiades Astrophoto and its contributors (https://pixinsight.com/)."
//
//    Alternatively, if that is where third-party acknowledgments normally
//    appear, this acknowledgment must be reproduced in the product itself.
//
// THIS SOFTWARE IS PROVIDED BY PLEIADES ASTROPHOTO AND ITS CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
// TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL PLEIADES ASTROPHOTO OR ITS
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, BUSINESS
// INTERRUPTION; PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; AND LOSS OF USE,
// DATA OR PROFITS) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
// ----------------------------------------------------------------------------
 
#ifndef __PCL_Control_h
#define __PCL_Control_h
 
 
#ifndef __PCL_BUILDING_PIXINSIGHT_APPLICATION
 
#include <pcl/Defs.h>
 
#include <pcl/AutoPointer.h>
#include <pcl/ButtonCodes.h>
#include <pcl/Color.h>
#include <pcl/Cursor.h>
#include <pcl/Flags.h>
#include <pcl/Font.h>
#include <pcl/KeyCodes.h>
#include <pcl/Rectangle.h>
#include <pcl/Sizer.h>
#include <pcl/UIObject.h>
#include <pcl/UIScaling.h>
 
#endif   // !__PCL_BUILDING_PIXINSIGHT_APPLICATION
 
namespace pcl
{
 
// ----------------------------------------------------------------------------
 
namespace FocusStyle
{
   enum mask_type
   {
      NoFocus     = 0x00,  // The control doesn't accept focus
      Tab         = 0x01,  // Can focus control by pressing the tab key
      Click       = 0x02,  // Can focus control by mouse clicking
      Wheel       = 0x04,  // Can focus control with the mouse wheel
      TextListTab = 0x08   // macOS only
   };
}
 
using FocusStyles = Flags<FocusStyle::mask_type>   ;
 
// ----------------------------------------------------------------------------
 
#ifndef __PCL_BUILDING_PIXINSIGHT_APPLICATION
 
// ----------------------------------------------------------------------------
 
class PCL_CLASS View;
 
class PCL_CLASS Control : public UIObject
{
public:
 
   Control( Control& parent = Null(), uint32 = 0 );
 
   ~Control() override
   {
   }
 
   Control( const Control& ) = delete;
 
   Control& operator =( const Control& ) = delete;
 
   Control( Control&& ) = delete;
 
   Control& operator =( Control&& ) = delete;
 
   void EnsureUnique() override
   {
   }
 
   static Control& Null();
 
   pcl::Rect FrameRect() const;
 
   int FrameWidth() const
   {
      return FrameRect().Width();
   }
 
   int FrameHeight() const
   {
      return FrameRect().Height();
   }
 
   pcl::Rect ClientRect() const;
 
   int ClientWidth() const
   {
      return ClientRect().Width();
   }
 
   int Width() const
   {
      return ClientWidth();
   }
 
   int ClientHeight() const
   {
      return ClientRect().Height();
   }
 
   int Height() const
   {
      return ClientHeight();
   }
 
   pcl::Rect BoundsRect() const
   {
      pcl::Rect r( ClientRect() );
      return pcl::Rect( r.Width(), r.Height() );
   }
 
   void SetClientRect( const pcl::Rect& r )
   {
      SetClientRect( r.x0, r.y0, r.x1, r.y1 );
   }
 
   void SetClientRect( int x0, int y0, int x1, int y1 );
 
   void Resize( int w, int h );
 
   void AdjustToContents();
 
   int MinWidth() const
   {
      int w, dum; GetMinSize( w, dum ); return w;
   }
 
   int MinHeight() const
   {
      int dum, h; GetMinSize( dum, h ); return h;
   }
 
   void GetMinSize( int& w, int& h ) const;
 
   void SetMinWidth( int w )
   {
      SetMinSize( w, -1 );
   }
 
   void SetMinWidth()
   {
      SetMinWidth( Width() );
   }
 
   void SetMinHeight( int h )
   {
      SetMinSize( -1, h );
   }
 
   void SetMinHeight()
   {
      SetMinHeight( Height() );
   }
 
   void SetMinSize( int w, int h );
 
   void SetMinSize()
   {
      SetMinSize( Width(), Height() );
   }
 
   int MaxWidth() const
   {
      int w, dum; GetMaxSize( w, dum ); return w;
   }
 
   int MaxHeight() const
   {
      int dum, h; GetMaxSize( dum, h ); return h;
   }
 
   void GetMaxSize( int& w, int& h ) const;
 
   void SetMaxWidth( int w )
   {
      SetMaxSize( w, -1 );
   }
 
   void SetMaxWidth()
   {
      SetMaxWidth( Width() );
   }
 
   void SetMaxHeight( int h )
   {
      SetMaxSize( -1, h );
   }
 
   void SetMaxHeight()
   {
      SetMaxHeight( Height() );
   }
 
   void SetMaxSize( int w, int h );
 
   void SetMaxSize()
   {
      SetMaxSize( Width(), Height() );
   }
 
   void SetFixedWidth( int w )
   {
      SetFixedSize( w, -1 );
   }
 
   void SetFixedWidth()
   {
      SetFixedWidth( Width() );
   }
 
   void SetFixedHeight( int h )
   {
      SetFixedSize( -1, h );
   }
 
   void SetFixedHeight()
   {
      SetFixedHeight( Height() );
   }
 
   void SetFixedSize( int w, int h );
 
   void SetFixedSize()
   {
      SetFixedSize( Width(), Height() );
   }
 
   bool IsFixedWidth() const
   {
      return MinWidth() == MaxWidth();
   }
 
   bool IsFixedHeight() const
   {
      return MinHeight() == MaxHeight();
   }
 
   void SetVariableSize()
   {
      SetMinSize( 0, 0 );
      SetMaxSize( int_max, int_max );
   }
 
   void SetVariableWidth()
   {
      SetMinWidth( 0 );
      SetMaxWidth( int_max );
   }
 
   void SetVariableHeight()
   {
      SetMinHeight( 0 );
      SetMaxHeight( int_max );
   }
 
   int ScaledMinWidth() const
   {
      int w, dum; GetMinSize( w, dum ); return PhysicalPixelsToLogical( w );
   }
 
   int ScaledMinHeight() const
   {
      int dum, h; GetMinSize( dum, h ); return PhysicalPixelsToLogical( h );
   }
 
   void GetScaledMinSize( int& w, int& h ) const
   {
      GetMinSize( w, h ); w = PhysicalPixelsToLogical( w ); h = PhysicalPixelsToLogical( h );
   }
 
   void SetScaledMinWidth( int w )
   {
      SetMinSize( LogicalPixelsToPhysical( w ), -1 );
   }
 
   void SetScaledMinHeight( int h )
   {
      SetMinSize( -1, LogicalPixelsToPhysical( h ) );
   }
 
   void SetScaledMinSize( int w, int h )
   {
      SetMinSize( LogicalPixelsToPhysical( w ), LogicalPixelsToPhysical( h ) );
   }
 
   int ScaledMaxWidth() const
   {
      int w, dum; GetMaxSize( w, dum ); return PhysicalPixelsToLogical( w );
   }
 
   int ScaledMaxHeight() const
   {
      int dum, h; GetMaxSize( dum, h ); return PhysicalPixelsToLogical( h );
   }
 
   void GetScaledMaxSize( int& w, int& h ) const
   {
      GetMaxSize( w, h ); w = PhysicalPixelsToLogical( w ); h = PhysicalPixelsToLogical( h );
   }
 
   void SetScaledMaxWidth( int w )
   {
      SetMaxSize( LogicalPixelsToPhysical( w ), -1 );
   }
 
   void SetScaledMaxHeight( int h )
   {
      SetMaxSize( -1, LogicalPixelsToPhysical( h ) );
   }
 
   void SetScaledMaxSize( int w, int h )
   {
      SetMaxSize( LogicalPixelsToPhysical( w ), LogicalPixelsToPhysical( h ) );
   }
 
   void SetScaledFixedWidth( int w )
   {
      SetFixedSize( LogicalPixelsToPhysical( w ), -1 );
   }
 
   void SetScaledFixedHeight( int h )
   {
      SetFixedSize( -1, LogicalPixelsToPhysical( h ) );
   }
 
   void SetScaledFixedSize( int w, int h )
   {
      SetFixedSize( LogicalPixelsToPhysical( w ), LogicalPixelsToPhysical( h ) );
   }
 
   bool IsHorizontalExpansionEnabled() const;
 
   bool IsVerticalExpansionEnabled() const;
 
   void EnableExpansion( bool horzEnable = true, bool vertEnable = true );
 
   void DisableExpansion( bool horzDisable = true, bool vertDisable = true )
   {
      EnableExpansion( !horzDisable, !vertDisable );
   }
 
   pcl::Point Position() const;
 
   int X() const
   {
      return Position().x;
   }
 
   int Y() const
   {
      return Position().y;
   }
 
   void Move( const pcl::Point& p )
   {
      Move( p.x, p.y );
   }
 
   void Move( int x, int y );
 
   bool IsUnderMouse() const;
 
   void BringToFront();
 
   void SendToBack();
 
   void StackUnder( Control& );
 
   pcl::Sizer Sizer() const;
 
   pcl::Sizer GetSizer() const
   {
      return this->Sizer();
   }
 
   void SetSizer( pcl::Sizer& );
 
   pcl::Point GlobalToLocal( const pcl::Point& p ) const
   {
      pcl::Point p1 = p; GlobalToLocal( p1.x, p1.y ); return p1;
   }
 
   void GlobalToLocal( int& x, int& y ) const;
 
   pcl::Point LocalToGlobal( const pcl::Point& p ) const
   {
      pcl::Point p1 = p; LocalToGlobal( p1.x, p1.y ); return p1;
   }
 
   void LocalToGlobal( int& x, int& y ) const;
 
   pcl::Point ParentToLocal( const pcl::Point& p ) const
   {
      pcl::Point p1 = p; ParentToLocal( p1.x, p1.y ); return p1;
   }
 
   void ParentToLocal( int& x, int& y ) const;
 
   pcl::Point LocalToParent( const pcl::Point& p ) const
   {
      pcl::Point p1 = p; LocalToParent( p1.x, p1.y ); return p1;
   }
 
   void LocalToParent( int& x, int& y ) const;
 
   pcl::Point ControlToLocal( const Control& w, const pcl::Point& p ) const
   {
      pcl::Point p1 = p; ControlToLocal( w, p1.x, p1.y ); return p1;
   }
 
   void ControlToLocal( const Control&, int& x, int& y ) const;
 
   pcl::Point LocalToControl( const Control& w, const pcl::Point& p ) const
   {
      pcl::Point p1 = p; LocalToControl( w, p1.x, p1.y ); return p1;
   }
 
   void LocalToControl( const Control&, int& x, int& y ) const;
 
   Control& ChildByPos( const pcl::Point& p ) const
   {
      return ChildByPos( p.x, p.y );
   }
 
   Control& ChildByPos( int x, int y ) const;
 
   pcl::Rect ChildrenRect() const;
 
   bool IsAncestorOf( const Control& ) const;
 
   Control& Parent() const;
 
   void SetParent( Control& );
 
   Control& Window() const;
 
   virtual bool IsEnabled() const;
 
   virtual void Enable( bool enabled = true );
 
   void Disable( bool disabled = true )
   {
      Enable( !disabled );
   }
 
   bool IsMouseTrackingEnabled() const;
 
   void EnableMouseTracking( bool = true );
 
   void DisableMouseTracking( bool disable = true )
   {
      EnableMouseTracking( !disable );
   }
 
   bool IsVisible() const;
 
   void SetVisible( bool visible )
   {
      if ( visible )
         Show();
      else
         Hide();
   }
 
   void Show();
 
   pcl::Rect VisibleRect() const;
 
   bool IsHidden() const
   {
      return !IsVisible();
   }
 
   void Hide();
 
   bool IsMaximized() const;
 
   bool IsMinimized() const;
 
   bool IsModal() const;
 
   bool IsWindow() const;
 
   bool IsActiveWindow() const;
 
   void ActivateWindow();
 
   bool IsFocused() const;
 
   void Focus( bool focus = true );
 
   void Unfocus()
   {
      Focus( false );
   }
 
   FocusStyles FocusStyle() const;
 
   void SetFocusStyle( FocusStyles );
 
   Control& FocusedChild() const;
 
   Control& ChildToFocus() const;
 
   void SetChildToFocus( Control& );
 
   Control& NextSiblingToFocus() const;
 
   void SetNextSiblingToFocus( Control& );
 
   bool CanUpdate() const;
 
   void EnableUpdates( bool enable = true );
 
   void DisableUpdates( bool disable = true )
   {
      EnableUpdates( !disable );
   }
 
   void Update();
 
   void Update( const pcl::Rect& r )
   {
      Update( r.x0, r.y0, r.x1, r.y1 );
   }
 
   void Update( int x0, int y0, int x1, int y1 );
 
   void Repaint();
 
   void Repaint( const pcl::Rect& r )
   {
      Repaint( r.x0, r.y0, r.x1, r.y1 );
   }
 
   void Repaint( int x0, int y0, int x1, int y1 );
 
   void Restyle();
 
   void EnsureLayoutUpdated();
 
   void Scroll( const pcl::Point& d )
   {
      Scroll( d.x, d.y );
   }
 
   void Scroll( int dx, int dy );
 
   void Scroll( const pcl::Point& d, const pcl::Rect& r )
   {
      Scroll( d.x, d.y, r.x0, r.y0, r.x1, r.y1 );
   }
 
   void Scroll( int dx, int dy, int x0, int y0, int x1, int y1 );
 
   pcl::Cursor Cursor() const;
 
   pcl::Cursor GetCursor() const
   {
      return this->Cursor();
   }
 
   void SetCursor( const pcl::Cursor& );
 
   void SetCursorToParent();
 
   String StyleSheet() const;
 
   void SetStyleSheet( const String& css );
 
   RGBA BackgroundColor() const;
 
   void SetBackgroundColor( RGBA );
 
   RGBA ForegroundColor() const;
 
   void SetForegroundColor( RGBA );
 
   RGBA CanvasColor();
 
   void SetCanvasColor( RGBA );
 
   RGBA AlternateCanvasColor() const;
 
   void SetAlternateCanvasColor( RGBA );
 
   RGBA TextColor() const;
 
   void SetTextColor( RGBA );
 
   RGBA ButtonColor() const;
 
   void SetButtonColor( RGBA );
 
   RGBA ButtonTextColor() const;
 
   void SetButtonTextColor( RGBA );
 
   RGBA HighlightColor() const;
 
   void SetHighlightColor( RGBA );
 
   RGBA HighlightedTextColor() const;
 
   void SetHighlightedTextColor( RGBA );
 
   pcl::Font Font() const;
 
   pcl::Font GetFont() const
   {
      return this->Font();
   }
 
   void SetFont( const pcl::Font& );
 
   double WindowOpacity() const;
 
   void SetWindowOpacity( double );
 
   String WindowTitle() const;
 
   void SetWindowTitle( const String& );
 
   /*
    * Information areas on processing interface control bars.
    */
 
   String InfoText() const;
 
   void SetInfoText( const String& );
 
   void ClearInfoText()
   {
      SetInfoText( String() );
   }
 
   /*
    * Track View check boxes on processing interface control bars.
    */
 
   bool IsTrackViewActive() const;
 
   void SetTrackViewActive( bool = true );
 
   void ActivateTrackView()
   {
      SetTrackViewActive( true );
   }
 
   void DeactivateTrackView()
   {
      SetTrackViewActive( false );
   }
 
   /*
    * Real-Time Preview check boxes on processing interface control bars.
    */
 
   bool IsRealTimePreviewActive() const;
 
   void SetRealTimePreviewActive( bool = true );
 
   void ActivateRealTimePreview()
   {
      SetRealTimePreviewActive( true );
   }
 
   void DeactivateRealTimePreview()
   {
      SetRealTimePreviewActive( false );
   }
 
   //
 
   String ToolTip() const;
 
   void SetToolTip( const String& );
 
   static void ShowToolTip( int x, int y, const String& text,
                  const Control& control = Control::Null(), const Rect& rect = Rect( 0 ) );
 
   static void ShowToolTip( const Point& pos, const String& text,
                  const Control& control = Control::Null(), const Rect& rect = Rect( 0 ) )
   {
      ShowToolTip( pos.x, pos.y, text, control, rect );
   }
 
   static void HideToolTip();
 
   static String ToolTipText();
 
   //
 
   double DisplayPixelRatio() const;
 
   double ResourcePixelRatio() const;
 
   template <class R>
   String ScaledResource( R resource ) const
   {
      return UIScaledResource( ResourcePixelRatio(), resource );
   }
 
   template <class S>
   String ScaledStyleSheet( S cssCode, int fontDPI = 0 ) const
   {
      return UIScaledStyleSheet( DisplayPixelRatio(), ResourcePixelRatio(), cssCode, fontDPI );
   }
 
   Point ScaledCursorHotSpot( int xHot, int yHot ) const
   {
      double r = ResourcePixelRatio();
      return Point( RoundInt( r*(xHot + 0.499) ), RoundInt( r*(yHot + 0.499) ) );
   }
 
   Point ScaledCursorHotSpot( const Point& hotSpot ) const
   {
      return ScaledCursorHotSpot( hotSpot.x, hotSpot.y );
   }
 
   int LogicalPixelsToPhysical( int size ) const
   {
      return RoundInt( DisplayPixelRatio()*size );
   }
 
   int PhysicalPixelsToLogical( int size ) const
   {
      return RoundInt( size/DisplayPixelRatio() );
   }
 
   int LogicalPixelsToResource( int size ) const
   {
      return RoundInt( ResourcePixelRatio()*size );
   }
 
   int ResourcePixelsToLogical( int size ) const
   {
      return RoundInt( size/ResourcePixelRatio() );
   }
 
   // -------------------------------------------------------------------------
   // Event handlers
   //
   // void OnDestroy( Control& sender );
   // void OnShow( Control& sender );
   // void OnHide( Control& sender );
   // void OnGetFocus( Control& sender );
   // void OnLoseFocus( Control& sender );
   // void OnEnter( Control& sender );
   // void OnLeave( Control& sender );
   // void OnMove( Control& sender, const pcl::Point& newPos, const pcl::Point& oldPos );
   // void OnResize( Control& sender, int newWidth, int newHeight, int oldWidth, int oldHeight );
   // void OnPaint( Control& sender, const pcl::Rect& updateRect );
   // void OnKeyPress( Control& sender, int key, unsigned modifiers, bool& wantsKey );
   // void OnKeyRelease( Control& sender, int key, unsigned modifiers, bool& wantsKey );
   // void OnMouseMove( Control& sender, const pcl::Point& pos, unsigned buttons, unsigned modifiers );
   // void OnMouseDoubleClick( Control& sender, const pcl::Point& pos, unsigned buttons, unsigned modifiers );
   // void OnMousePress( Control& sender, const pcl::Point& pos, int button, unsigned buttons, unsigned modifiers );
   // void OnMouseRelease( Control& sender, const pcl::Point& pos, int button, unsigned buttons, unsigned modifiers );
   // void OnMouseWheel( Control& sender, const pcl::Point& pos, int delta, unsigned buttons, unsigned modifiers );
   // void OnFileDrag( Control& sender, const pcl::Point& pos, const StringList& files, unsigned modifiers, bool& wantsFiles )
   // void OnFileDrop( Control& sender, const pcl::Point& pos, const StringList& files, unsigned modifiers )
   // void OnViewDrag( Control& sender, const pcl::Point& pos, const View& view, unsigned modifiers, bool& wantsView )
   // void OnViewDrop( Control& sender, const pcl::Point& pos, const View& view, unsigned modifiers )
   // void OnChildCreate( Control& sender, Control& child );
   // void OnChildDestroy( Control& sender, Control& child );
 
   using event_handler = void (Control::*)( Control& sender );
 
   using close_event_handler = void (Control::*)( Control& sender, bool& allowClose );
 
   using move_event_handler = void (Control::*)( Control& sender, const pcl::Point& newPos, const pcl::Point& oldPos );
 
   using resize_event_handler = void (Control::*)( Control& sender, int newWidth, int newHeight, int oldWidth, int oldHeight );
 
   using paint_event_handler = void (Control::*)( Control& sender, const pcl::Rect& updateRect );
 
   using keyboard_event_handler = void (Control::*)( Control& sender, int key, unsigned modifiers, bool& wantsKey );
 
   using mouse_event_handler = void (Control::*)( Control& sender, const pcl::Point& pos, unsigned buttons, unsigned modifiers );
 
   using mouse_button_event_handler = void (Control::*)( Control& sender, const pcl::Point& pos, int button, unsigned buttons, unsigned modifiers );
 
   using mouse_wheel_event_handler = void (Control::*)( Control& sender, const pcl::Point& pos, int delta, unsigned buttons, unsigned modifiers );
 
   using file_drag_event_handler = void (Control::*)( Control& sender, const pcl::Point& pos, const StringList& files, unsigned modifiers, bool& wantsFiles );
 
   using file_drop_event_handler = void (Control::*)( Control& sender, const pcl::Point& pos, const StringList& files, unsigned modifiers );
 
   using view_drag_event_handler = void (Control::*)( Control& sender, const pcl::Point& pos, const View& view, unsigned modifiers, bool& wantsView );
 
   using view_drop_event_handler = void (Control::*)( Control& sender, const pcl::Point& pos, const View& view, unsigned modifiers );
 
   using child_event_handler = void (Control::*)( Control& sender, Control& child );
 
   void OnDestroy( event_handler, Control& );
 
   void OnShow( event_handler, Control& );
 
   void OnHide( event_handler, Control& );
 
   void OnClose( close_event_handler, Control& );
 
   void OnGetFocus( event_handler, Control& );
 
   void OnLoseFocus( event_handler, Control& );
 
   void OnEnter( event_handler, Control& );
 
   void OnLeave( event_handler, Control& );
 
   void OnMove( move_event_handler, Control& );
 
   void OnResize( resize_event_handler, Control& );
 
   void OnPaint( paint_event_handler, Control& );
 
   void OnKeyPress( keyboard_event_handler, Control& );
 
   void OnKeyRelease( keyboard_event_handler, Control& );
 
   void OnMouseMove( mouse_event_handler, Control& );
 
   void OnMouseDoubleClick( mouse_event_handler, Control& );
 
   void OnMousePress( mouse_button_event_handler, Control& );
 
   void OnMouseRelease( mouse_button_event_handler, Control& );
 
   void OnMouseWheel( mouse_wheel_event_handler, Control& );
 
   void OnFileDrag( file_drag_event_handler, Control& );
 
   void OnFileDrop( file_drop_event_handler, Control& );
 
   void OnViewDrag( view_drag_event_handler, Control& );
 
   void OnViewDrop( view_drop_event_handler, Control& );
 
   void OnChildCreate( child_event_handler, Control& );
 
   void OnChildDestroy( child_event_handler, Control& );
 
   // -------------------------------------------------------------------------
 
private:
 
   struct EventHandlers
   {
      event_handler              onDestroy          = nullptr;
      event_handler              onShow             = nullptr;
      event_handler              onHide             = nullptr;
      close_event_handler        onClose            = nullptr;
      event_handler              onGetFocus         = nullptr;
      event_handler              onLoseFocus        = nullptr;
      event_handler              onEnter            = nullptr;
      event_handler              onLeave            = nullptr;
      move_event_handler         onMove             = nullptr;
      resize_event_handler       onResize           = nullptr;
      paint_event_handler        onPaint            = nullptr;
      keyboard_event_handler     onKeyPress         = nullptr;
      keyboard_event_handler     onKeyRelease       = nullptr;
      mouse_event_handler        onMouseMove        = nullptr;
      mouse_event_handler        onMouseDoubleClick = nullptr;
      mouse_button_event_handler onMousePress       = nullptr;
      mouse_button_event_handler onMouseRelease     = nullptr;
      mouse_wheel_event_handler  onMouseWheel       = nullptr;
      file_drag_event_handler    onFileDrag         = nullptr;
      file_drop_event_handler    onFileDrop         = nullptr;
      view_drag_event_handler    onViewDrag         = nullptr;
      view_drop_event_handler    onViewDrop         = nullptr;
      child_event_handler        onChildCreate      = nullptr;
      child_event_handler        onChildDestroy     = nullptr;
 
      EventHandlers() = default;
      EventHandlers( const EventHandlers& ) = default;
      EventHandlers& operator =( const EventHandlers& ) = default;
   };
 
   AutoPointer<EventHandlers> m_handlers;
 
protected:
 
   Control( void* h ) : UIObject( h )
   {
   }
 
   void* CloneHandle() const override;
 
   friend class BitmapBox;
   friend class CheckBox;
   friend class CodeEditor;
   friend class ComboBox;
   friend class ControlEventDispatcher;
   friend class Dialog;
   friend class Edit;
   friend class Frame;
   friend class GraphicsContextBase;
   friend class GroupBox;
   friend class ImageView;
   friend class Label;
   friend class PushButton;
   friend class RadioButton;
   friend class ScrollBox;
   friend class Sizer;
   friend class Slider;
   friend class SpinBox;
   friend class TabBox;
   friend class TextBox;
   friend class ToolButton;
   friend class TreeBox;
   friend class ViewList;
   friend class WebView;
};
 
// ----------------------------------------------------------------------------
 
template <class C> inline
int CanonicalControlHeightImplementation()
{
   Control       container;
   VerticalSizer sizer;
   C             control;
 
   sizer.Add( control );
   container.SetSizer( sizer );
   container.Restyle();
   container.AdjustToContents();
   container.SetFixedSize();
   return container.Height();
}
 
#define CanonicalControlHeight( control_type ) \
   CanonicalControlHeightImplementation<control_type>()
 
// ----------------------------------------------------------------------------
 
#define __PCL_NO_ALIAS_HANDLERS \
   if ( IsAlias() )             \
      throw Error( "Aliased controls cannot set event handlers." )
 
// ----------------------------------------------------------------------------
 
#endif   // !__PCL_BUILDING_PIXINSIGHT_APPLICATION
 
} // pcl
 
#endif   // __PCL_Control_h
 
// ----------------------------------------------------------------------------
// EOF pcl/Control.h - Released 2024-05-07T15:27:32Z