splitter.h

Go to the documentation of this file.

//----------------------------------------------------------------------------
// ObjectWindows
// Copyright (c) 1995, 1996 by Borland International, All Rights Reserved
//
/// \file
/// Definition of helper classes for Pane Splitters
//----------------------------------------------------------------------------
 
#if !defined(OWL_SPLITTER_H)
#define OWL_SPLITTER_H
 
#include <owl/private/defs.h>
#if defined(BI_HAS_PRAGMA_ONCE)
# pragma once
#endif
 
#include <owl/layoutwi.h>
#include <owl/shddel.h>
#include <owl/template.h> //added by DLN
 
namespace owl {
 
class _OWLCLASS TDC;
 
#include <owl/preclass.h>
 
//
/// Enumeration describing whether to split a window in the X or Y plane.
//
enum TSplitDirection {
  psHorizontal,               ///< Horizontal split
  psVertical,                 ///< Vertical split
  psNone                      ///< Unspecified split
};
enum TSplitDirection {…};
 
class _OWLCLASS TSplitterIndicator;
class _OWLCLASS TPaneSplitter;
 
//
/// \class TSplitter
// ~~~~~ ~~~~~~~~~
/// Abstract base class for TVSplitter and THSplitter.
//
class _OWLCLASS TSplitter : public TLayoutWindow {
  public:
    TSplitter(TWindow* parent, TPaneSplitter* ps, float percent);
 
    int                         operator ==(const TSplitter& splitter) const;
    float                       GetPercent();
    void                        SetPercent(float p);
    virtual TRect               GetRect() = 0;
    TRect                       GetScreenRect();
    virtual TSplitDirection     SplitDirection() = 0;
    virtual TSplitterIndicator* CreateSplitterIndicator() = 0;
    virtual TWindow*            Pane1() = 0;
    virtual TWindow*            Pane2() = 0;
    virtual void                Split(TWindow* targetPane,
                                      TWindow* newPane,
                                      TSplitDirection sd,
                                      float percent) = 0;
    virtual TLayoutMetrics      Setup(TWindow* targetPane,
                                      TWindow* newPane,
                                      float percent) = 0;
    virtual void                AdjForResize(const TSize& sz) = 0;
    TLayoutWindow*              RemovePane(TWindow* pane,
                                           TShouldDelete::DeleteType dt =
                                             TShouldDelete::DefDelete);
    TRect                       GetMoveArea();
    virtual void                Move(int dist) = 0;
    virtual void                AdjSplitterWidth(int w) = 0;
 
  protected:
    void                        EvLButtonDown(uint modKeys, const TPoint& point);
    void                        EvLButtonUp(uint modKeys, const TPoint& point);
    void                        EvMouseMove(uint modKeys, const TPoint& point);
    bool                        EvSetCursor(HWND hwndCursor, uint codeHitTest, TMsgId mouseMsg);
    void                        EvSize(uint sizeType, const TSize& size);
    void Paint(TDC&, bool erase, TRect&) override;
 
    void                        SetupEpilog(TSplitter* s, TWindow* targetPane,
                                            TWindow* newPane,
                                            TLayoutMetrics& lmOfTargetPane,
                                            TLayoutMetrics& lmOfNewPane);
 
  protected_data:
    // Represents the percent 'pane1' is of splitter (.5, .25, etc.).
    //
    float          PercentOf;
    TPaneSplitter* PaneSplitter;
 
  DECLARE_RESPONSE_TABLE(TSplitter);
};
class _OWLCLASS TSplitter : public TLayoutWindow {…};
 
//
/// \class TVSplitter
// ~~~~~ ~~~~~~~~~~
/// Represents a vertical splitter.
//
class _OWLCLASS TVSplitter : public TSplitter {
  public:
    TVSplitter(TWindow* parent, TPaneSplitter* ps, float percent=50.0f);
 
    // Pane1 is left of splitter and pane2 is right.
    //
    TWindow*             Pane1();
    TWindow*             Pane2();
    void                 Split(TWindow* targetPane, TWindow* newPane,
                               TSplitDirection sd, float percent=50.0f);
    TLayoutMetrics       Setup(TWindow* targetPane, TWindow* newPane, float percent);
    TRect                GetRect();
    TSplitDirection      SplitDirection();
    TSplitterIndicator*  CreateSplitterIndicator();
    void                 AdjForResize(const TSize& sz);
    void                 Move(int dist);
    void                 AdjSplitterWidth(int w);
};
class _OWLCLASS TVSplitter : public TSplitter {…};
 
//
/// \class THSplitter
// ~~~~~ ~~~~~~~~~~
/// Represents a horizontal splitter.
//
class _OWLCLASS THSplitter : public TSplitter {
  public:
    THSplitter(TWindow* parent, TPaneSplitter* ps, float percent=50.0f);
 
    // Pane1 is above splitter and pane2 is below.
    //
    TWindow*             Pane1();
    TWindow*             Pane2();
    void                 Split(TWindow* targetPane, TWindow* newPane,
                               TSplitDirection sd, float percent=50.0f);
    TLayoutMetrics       Setup(TWindow* targetPane, TWindow* newPane, float percent);
    TRect                GetRect();
    TSplitDirection      SplitDirection();
    TSplitterIndicator*  CreateSplitterIndicator();
    void                 AdjForResize(const TSize& sz);
    void                 Move(int dist);
    void                 AdjSplitterWidth(int w);
};
class _OWLCLASS THSplitter : public TSplitter {…};
 
//
/// \class TSplitterIndicator
// ~~~~~ ~~~~~~~~~~~~~~~~~~
/// Indicates to the user where the splitter will be moved to when dragging
/// completes. Abstract base class for TVSplitterIndicator and
/// THSplitterIndicator.
//
class _OWLCLASS TSplitterIndicator : public TRect {
  public:
    TSplitterIndicator(TSplitter* splitter, const TRect& rect, uint cushion=0);
    virtual ~TSplitterIndicator() {}
 
    bool              operator == (const TSplitterIndicator& si) const;
    // make happy STL
    bool              operator < (const TSplitterIndicator& si) const;
    virtual void      ConnectToRect(const TRect& rect) = 0;
    virtual void      Move(int dist) = 0;
    uint              GetDistMoved();
    void              Draw();
    void              Clear();
    virtual int       CalcDistMoved(const TPoint& start, const TPoint& cur) = 0;
    virtual bool      CouldContain(const TPoint& point) = 0;
    TSplitter*        GetSplitter();
    virtual TRect     CalcAreaOfSplitterMove() = 0;
    void              SetCushion(const uint cushion);
 
  protected:
    TSplitter*  Splitter;
    bool        Showing;
    uint        DistMoved;
    //
    // Minimum distance btwn separators.
    //
    uint        Cushion;
};
class _OWLCLASS TSplitterIndicator : public TRect {…};
 
//
/// \class TVSplitterIndicator
// ~~~~~ ~~~~~~~~~~~~~~~~~~~
/// Vertical indicator.
//
class _OWLCLASS TVSplitterIndicator : public TSplitterIndicator {
  public:
    TVSplitterIndicator(TSplitter* splitter, const TRect& rect, uint cushion=0);
 
    // Override virtuals
    //
    void    ConnectToRect(const TRect& rect);
    void    Move(int dist);
    int     CalcDistMoved(const TPoint& start, const TPoint& cur);
    bool    CouldContain(const TPoint& point);
    TRect   CalcAreaOfSplitterMove();
};
class _OWLCLASS TVSplitterIndicator : public TSplitterIndicator {…};
 
//
/// \class THSplitterIndicator
// ~~~~~ ~~~~~~~~~~~~~~~~~~~
/// Horizontal indicator.
//
class _OWLCLASS THSplitterIndicator : public TSplitterIndicator {
  public:
    THSplitterIndicator(TSplitter* splitter, const TRect& rect, uint cushion=0);
 
    // Override virtuals
    //
    void    ConnectToRect(const TRect& rect);
    void    Move(int dist);
    int     CalcDistMoved(const TPoint& start, const TPoint& cur);
    bool    CouldContain(const TPoint& point);
    TRect   CalcAreaOfSplitterMove();
};
class _OWLCLASS THSplitterIndicator : public TSplitterIndicator {…};
 
//
//DLN replaced by class decl below class TSplitterIndicatorList;
 
//------------------------------------------------------------------------------
/// \class TSplitterIndicatorList
// ~~~~~ ~~~~~~~~~~~~~~~~~~~~~~
class _OWLCLASS TSplitterIndicatorList: public TBaseList<TSplitterIndicator*>{
  public:
    TSplitterIndicatorList(){;}
    uint  NSplitterIndicators() { return Size(); }
    TSplitterIndicator* FindIndicatorWithSplitter(TSplitter* splitter);
    void Flush(bool del);
};
class _OWLCLASS TSplitterIndicatorList: public TBaseList<TSplitterIndicator*> {…};
typedef TSplitterIndicatorList::Iterator TSplitterIndicatorListIterator;
 
//
/// \class TSplitterIndicatorMgr
// ~~~~~ ~~~~~~~~~~~~~~~~~~~~~
/// Handles the moving of the indicators.
//
class _OWLCLASS TSplitterIndicatorMgr {
  public:
    TSplitterIndicatorMgr();
 
    void            StartMove(TSplitterIndicatorList& sil, const TPoint& point);
    void            EndMove();
    void            MoveIndicators(const TPoint& point);
 
  private:
    TSplitterIndicatorList*   SplitterIndicatorList;
    TPoint                    StartDragPoint;
 
    void            DrawIndicators();
    void            ClearIndicators();
};
class _OWLCLASS TSplitterIndicatorMgr {…};
 
#include <owl/posclass.h>
 
 
//----------------------------------------------------------------------------
// Inline implementations
 
//
inline int TSplitter::operator ==(const TSplitter& splitter) const
{
  return this == &splitter;
}
inline int TSplitter::operator ==(const TSplitter& splitter) const {…}
 
//
inline float TSplitter::GetPercent()
{
  return PercentOf;
}
inline float TSplitter::GetPercent() {…}
 
//
inline void TSplitter::SetPercent(float p)
{
  PercentOf = p;
}
inline void TSplitter::SetPercent(float p) {…}
 
//
/// Return the area the splitter can move in (bounding rectangle).
/// The rect is in client coordinates.
//
inline TRect TSplitter::GetMoveArea()
{
  return GetWindowRect();
}
inline TRect TSplitter::GetMoveArea() {…}
 
//
/// Similar to above except rect is in screen coordinates.
//
inline TRect TSplitter::GetScreenRect()
{
  TRect  rect = GetRect();
  MapWindowPoints(nullptr, reinterpret_cast<TPoint*>(&rect), 2);  // map to screen
  return rect;
}
inline TRect TSplitter::GetScreenRect() {…}
 
//
inline TSplitDirection TVSplitter::SplitDirection()
{
  return psVertical;
}
inline TSplitDirection TVSplitter::SplitDirection() {…}
 
//
inline TSplitDirection
THSplitter::SplitDirection()
{
  return psHorizontal;
}
THSplitter::SplitDirection() {…}
 
//
inline TSplitterIndicator::TSplitterIndicator(TSplitter* splitter, const TRect& rect, uint cushion)
:
  TRect(rect), Splitter(splitter), Showing(false), DistMoved(0), Cushion(cushion)
{
}
inline TSplitterIndicator::TSplitterIndicator(TSplitter* splitter, const TRect& rect, uint cushion) {…}
 
//
inline bool TSplitterIndicator::operator ==(const TSplitterIndicator& si) const
{
  return this == &si;
}
inline bool TSplitterIndicator::operator ==(const TSplitterIndicator& si) const {…}
 
//
inline uint
TSplitterIndicator::GetDistMoved()
{
  return DistMoved;
}
TSplitterIndicator::GetDistMoved() {…}
 
//
/// Clear indicator from screen.
//
inline void
TSplitterIndicator::Clear()
{
  if (Showing) {
    Showing = false;
    Draw();
    Showing = false;
  }
}
TSplitterIndicator::Clear() {…}
 
//
/// Return splitter from which this indicator was created.
//
inline TSplitter*
TSplitterIndicator::GetSplitter()
{
  return Splitter;
}
TSplitterIndicator::GetSplitter() {…}
 
//
/// Set cushion
//
inline void
TSplitterIndicator::SetCushion(const uint cushion)
{
   Cushion = cushion;
}
TSplitterIndicator::SetCushion(const uint cushion) {…}
 
//
inline TVSplitterIndicator::TVSplitterIndicator(TSplitter* splitter, const TRect& rect, uint cushion)
:
  TSplitterIndicator(splitter, rect, cushion)
{
}
inline TVSplitterIndicator::TVSplitterIndicator(TSplitter* splitter, const TRect& rect, uint cushion) {…}
 
//
inline THSplitterIndicator::THSplitterIndicator(TSplitter* splitter, const TRect& rect, uint cushion)
:
  TSplitterIndicator(splitter, rect, cushion)
{
}
inline THSplitterIndicator::THSplitterIndicator(TSplitter* splitter, const TRect& rect, uint cushion) {…}
 
/*
inline uint TSplitterIndicatorList::NSplitterIndicators()
{
  return size();
}
inline void TSplitterIndicatorList::Flush(bool del){
  if(del){
    TSplitterIndicatorList::iterator i = begin();
    while(i != end())
      delete *i;
  }
  this->erase(begin(),end());
}
*/
//
inline TSplitterIndicatorMgr::TSplitterIndicatorMgr()
:
  SplitterIndicatorList(nullptr)
{
}
inline TSplitterIndicatorMgr::TSplitterIndicatorMgr() {…}
 
} // OWL namespace
 
 
#endif // OWL_SPLITTER_H