src/servers/app/stackandtile/SATGroup.h

   1 /*
   2  * Copyright 2010-2014 Haiku, Inc. All rights reserved.
   3  * Distributed under the terms of the MIT License.
   4  *
   5  * Authors:
   6  *              John Scipione, jscipione@gmail.com
   7  *              Clemens Zeidler, haiku@clemens-zeidler.de
   8  */
   9 #ifndef SAT_GROUP_H
  10 #define SAT_GROUP_H
  11
  12
  13 #include <Rect.h>
  14
  15 #include "ObjectList.h"
  16 #include "Referenceable.h"
  17
  18 #include "MagneticBorder.h"
  19
  20 #include "LinearSpec.h"
  21
  22
  23 class SATWindow;
  24 class Tab;
  25 class WindowArea;
  26
  27 typedef BObjectList<SATWindow> SATWindowList;
  28
  29
  30 class Corner {
  31 public:
  32                 enum info_t
  33                 {
  34                         kFree,
  35                         kUsed,
  36                         kNotDockable
  37                 };
  38
  39                 enum position_t
  40                 {
  41                         kLeftTop = 0,
  42                         kRightTop = 1,
  43                         kLeftBottom = 2,
  44                         kRightBottom = 3
  45                 };
  46
  47                                                 Corner();
  48                 void                    Trace() const;
  49
  50                 info_t                  status;
  51                 WindowArea*             windowArea;
  52 };
  53
  54
  55 class Crossing : public BReferenceable {
  56 public:
  57                                                                 Crossing(Tab* vertical, Tab* horizontal);
  58                                                                 ~Crossing();
  59
  60                         Corner*                         GetCorner(Corner::position_t corner) const;
  61                         Corner*                         GetOppositeCorner(
  62                                                                         Corner::position_t corner) const;
  63
  64                         Corner*                         LeftTopCorner()
  65                                                                         { return &fCorners[Corner::kLeftTop]; }
  66                         Corner*                         RightTopCorner()
  67                                                                         { return &fCorners[Corner::kRightTop]; }
  68                         Corner*                         LeftBottomCorner()
  69                                                                         { return &fCorners[Corner::kLeftBottom]; }
  70                         Corner*                         RightBottomCorner()
  71                                                                         { return &fCorners[Corner::kRightBottom]; }
  72
  73                         Tab*                            VerticalTab() const;
  74                         Tab*                            HorizontalTab() const;
  75
  76                         void                            Trace() const;
  77 private:
  78                         Corner                          fCorners[4];
  79
  80                         BReference<Tab>         fVerticalTab;
  81                         BReference<Tab>         fHorizontalTab;
  82 };
  83
  84
  85 typedef BObjectList<Constraint> ConstraintList;
  86 class SATGroup;
  87
  88 typedef BObjectList<Crossing> CrossingList;
  89
  90
  91 // make all coordinates positive needed for the solver
  92 const float kMakePositiveOffset = 5000;
  93
  94
  95 class Tab : public BReferenceable {
  96 public:
  97                 enum orientation_t
  98                 {
  99                         kVertical,
 100                         kHorizontal
 101                 };
 102
 103                                                                 Tab(SATGroup* group, Variable* variable,
 104                                                                         orientation_t orientation);
 105                                                                 ~Tab();
 106
 107                         float                           Position() const;
 108                         void                            SetPosition(float position);
 109                         orientation_t           Orientation() const;
 110                         Variable*                       Var() { return fVariable;       }
 111
 112                         //! Caller takes ownership of the constraint.
 113                         Constraint*                     Connect(Variable* variable);
 114
 115                         BReference<Crossing>    AddCrossing(Tab* tab);
 116                         bool                            RemoveCrossing(Crossing* crossing);
 117                         int32                           FindCrossingIndex(Tab* tab);
 118                         int32                           FindCrossingIndex(float tabPosition);
 119                         Crossing*                       FindCrossing(Tab* tab);
 120                         Crossing*                       FindCrossing(float tabPosition);
 121
 122                         const CrossingList*     GetCrossingList() const;
 123
 124         static  int                                     CompareFunction(const Tab* tab1,
 125                                                                         const Tab* tab2);
 126
 127 private:
 128                         SATGroup*                       fGroup;
 129                         Variable*                       fVariable;
 130                         orientation_t           fOrientation;
 131
 132                         CrossingList            fCrossingList;
 133 };
 134
 135
 136 class WindowArea : public BReferenceable {
 137 public:
 138                                                                 WindowArea(Crossing* leftTop,
 139                                                                         Crossing* rightTop, Crossing* leftBottom,
 140                                                                         Crossing* rightBottom);
 141                                                                 ~WindowArea();
 142
 143                         bool                            Init(SATGroup* group);
 144                         SATGroup*                       Group() { return fGroup; }
 145
 146                         void                            DoGroupLayout();
 147                         void                            UpdateSizeLimits();
 148                         void                            UpdateSizeConstaints(const BRect& frame);
 149
 150         const   SATWindowList&          WindowList() { return fWindowList; }
 151         const   SATWindowList&          LayerOrder() { return fWindowLayerOrder; }
 152                         bool                            MoveWindowToPosition(SATWindow* window,
 153                                                                         int32 index);
 154                         SATWindow*                      TopWindow();
 155
 156                         Crossing*                       LeftTopCrossing()
 157                                                                         { return fLeftTopCrossing.Get(); }
 158                         Crossing*                       RightTopCrossing()
 159                                                                         { return fRightTopCrossing.Get(); }
 160                         Crossing*                       LeftBottomCrossing()
 161                                                                         { return fLeftBottomCrossing.Get(); }
 162                         Crossing*                       RightBottomCrossing()
 163                                                                         { return fRightBottomCrossing.Get(); }
 164
 165                         Tab*                            LeftTab();
 166                         Tab*                            RightTab();
 167                         Tab*                            TopTab();
 168                         Tab*                            BottomTab();
 169
 170                         Variable*                       LeftVar() { return LeftTab()->Var(); }
 171                         Variable*                       RightVar() { return RightTab()->Var(); }
 172                         Variable*                       TopVar() { return TopTab()->Var(); }
 173                         Variable*                       BottomVar() { return BottomTab()->Var(); }
 174
 175                         BRect                           Frame();
 176
 177                         bool                            PropagateToGroup(SATGroup* group);
 178
 179                         bool                            MoveToTopLayer(SATWindow* window);
 180
 181 private:
 182                 friend class SATGroup;
 183                         void                            _UninitConstraints();
 184                         void                            _UpdateConstraintValues();
 185
 186                         /*! SATGroup adds new windows to the area. */
 187                         bool                            _AddWindow(SATWindow* window,
 188                                                                         SATWindow* after = NULL);
 189                         /*! After the last window has been removed the WindowArea delete
 190                         himself and clean up all crossings. */
 191                         bool                            _RemoveWindow(SATWindow* window);
 192
 193         inline  void                            _InitCorners();
 194         inline  void                            _CleanupCorners();
 195         inline  void                            _SetToWindowCorner(Corner* corner);
 196         inline  void                            _SetToNeighbourCorner(Corner* neighbour);
 197         inline  void                            _UnsetWindowCorner(Corner* corner);
 198                 //! opponent is the other neighbour of the neighbour
 199         inline  void                            _UnsetNeighbourCorner(Corner* neighbour,
 200                                                                         Corner* opponent);
 201
 202                         // Find crossing by tab position in group and if not exist create
 203                         // it.
 204                         BReference<Crossing>    _CrossingByPosition(Crossing* crossing,
 205                                                                                 SATGroup* group);
 206
 207                         void                            _MoveToSAT(SATWindow* topWindow);
 208
 209                         BReference<SATGroup>    fGroup;
 210
 211                         SATWindowList           fWindowList;
 212
 213                         SATWindowList           fWindowLayerOrder;
 214
 215                         BReference<Crossing>    fLeftTopCrossing;
 216                         BReference<Crossing>    fRightTopCrossing;
 217                         BReference<Crossing>    fLeftBottomCrossing;
 218                         BReference<Crossing>    fRightBottomCrossing;
 219
 220                         Constraint*                     fMinWidthConstraint;
 221                         Constraint*                     fMinHeightConstraint;
 222                         Constraint*                     fMaxWidthConstraint;
 223                         Constraint*                     fMaxHeightConstraint;
 224                         Constraint*                     fWidthConstraint;
 225                         Constraint*                     fHeightConstraint;
 226
 227                         MagneticBorder          fMagneticBorder;
 228 };
 229
 230
 231 typedef BObjectList<WindowArea> WindowAreaList;
 232 typedef BObjectList<Tab> TabList;
 233
 234 class BMessage;
 235 class StackAndTile;
 236
 237
 238 class SATGroup : public BReferenceable {
 239 public:
 240                 friend class Tab;
 241                 friend class WindowArea;
 242                 friend class GroupCookie;
 243
 244                                                                 SATGroup();
 245                                                                 ~SATGroup();
 246
 247                         LinearSpec*                     GetLinearSpec() { return fLinearSpec; }
 248
 249                         /*! Create a new WindowArea from the crossing and add the window. */
 250                         bool                            AddWindow(SATWindow* window, Tab* left,
 251                                                                         Tab* top, Tab* right, Tab* bottom);
 252                         /*! Add a window to an existing window area. */
 253                         bool                            AddWindow(SATWindow* window, WindowArea* area,
 254                                                                         SATWindow* after = NULL);
 255                         /*! If stayBelowMouse is true move the removed window below the
 256                         cursor if necessary. */
 257                         bool                            RemoveWindow(SATWindow* window,
 258                                                                         bool stayBelowMouse = true);
 259                         int32                           CountItems();
 260                         SATWindow*                      WindowAt(int32 index);
 261
 262                         SATWindow*                      ActiveWindow() const;
 263                         void                            SetActiveWindow(SATWindow* window);
 264
 265                         const WindowAreaList&   GetAreaList() { return fWindowAreaList; }
 266
 267                         /*! \return a sorted tab list. */
 268                         const TabList*          HorizontalTabs();
 269                         const TabList*          VerticalTabs();
 270
 271                         Tab*                            FindHorizontalTab(float position);
 272                         Tab*                            FindVerticalTab(float position);
 273
 274                         void                            WindowAreaRemoved(WindowArea* area);
 275
 276         static  status_t                        RestoreGroup(const BMessage& archive,
 277                                                                         StackAndTile* sat);
 278                         status_t                        ArchiveGroup(BMessage& archive);
 279
 280 private:
 281                         BReference<Tab>         _AddHorizontalTab(float position = 0);
 282                         BReference<Tab>         _AddVerticalTab(float position = 0);
 283
 284                         bool                            _RemoveHorizontalTab(Tab* tab);
 285                         bool                            _RemoveVerticalTab(Tab* tab);
 286
 287                         Tab*                            _FindTab(const TabList& list, float position);
 288
 289                         void                            _SplitGroupIfNecessary(
 290                                                                         WindowArea* removedArea);
 291                         void                            _FillNeighbourList(
 292                                                                         WindowAreaList& neighbourWindows,
 293                                                                         WindowArea* area);
 294                         void                            _LeftNeighbours(
 295                                                                         WindowAreaList& neighbourWindows,
 296                                                                         WindowArea* window);
 297                         void                            _TopNeighbours(
 298                                                                         WindowAreaList& neighbourWindows,
 299                                                                         WindowArea* window);
 300                         void                            _RightNeighbours(
 301                                                                         WindowAreaList& neighbourWindows,
 302                                                                         WindowArea* window);
 303                         void                            _BottomNeighbours(
 304                                                                         WindowAreaList& neighbourWindows,
 305                                                                         WindowArea* window);
 306                         bool                            _FindConnectedGroup(WindowAreaList& seedList,
 307                                                                         WindowArea* removedArea,
 308                                                                         WindowAreaList& newGroup);
 309                         void                            _FollowSeed(WindowArea* area, WindowArea* veto,
 310                                                                         WindowAreaList& seedList,
 311                                                                         WindowAreaList& newGroup);
 312                         void                            _SpawnNewGroup(const WindowAreaList& newGroup);
 313
 314                         void                            _EnsureGroupIsOnScreen(SATGroup* group);
 315         inline  void                            _CallculateXOffset(BPoint& offset, BRect& frame,
 316                                                                         BRect& screen);
 317         inline  void                            _CallculateYOffset(BPoint& offset, BRect& frame,
 318                                                                         BRect& screen);
 319
 320 protected:
 321                         WindowAreaList          fWindowAreaList;
 322                         SATWindowList           fSATWindowList;
 323
 324                         LinearSpec*                     fLinearSpec;
 325
 326 private:
 327                         TabList                         fHorizontalTabs;
 328                         bool                            fHorizontalTabsSorted;
 329                         TabList                         fVerticalTabs;
 330                         bool                            fVerticalTabsSorted;
 331
 332                         SATWindow*                      fActiveWindow;
 333 };
 334
 335
 336 typedef BObjectList<SATGroup> SATGroupList;
 337
 338 #endif