kolourpaint/views/kpView_Selections.cpp

   1
   2 /*
   3    Copyright (c) 2003-2007 Clarence Dang <dang@kde.org>
   4    All rights reserved.
   5
   6    Redistribution and use in source and binary forms, with or without
   7    modification, are permitted provided that the following conditions
   8    are met:
   9
  10    1. Redistributions of source code must retain the above copyright
  11       notice, this list of conditions and the following disclaimer.
  12    2. Redistributions in binary form must reproduce the above copyright
  13       notice, this list of conditions and the following disclaimer in the
  14       documentation and/or other materials provided with the distribution.
  15
  16    THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  17    IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  18    OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  19    IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  20    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  21    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  22    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  23    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  24    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  25    THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 */
  27
  28
  29 #define DEBUG_KP_VIEW 0
  30 #define DEBUG_KP_VIEW_RENDERER ((DEBUG_KP_VIEW && 1) || 0)
  31
  32
  33 #include <kpView.h>
  34 #include <kpViewPrivate.h>
  35
  36 #include <kpAbstractSelection.h>
  37 #include <kpTextSelection.h>
  38 #include <kpTool.h>
  39
  40
  41 // public
  42 QRect kpView::selectionViewRect () const
  43 {
  44     return selection () ?
  45                transformDocToView (selection ()->boundingRect ()) :
  46                QRect ();
  47
  48 }
  49
  50
  51 // public
  52 QPoint kpView::mouseViewPointRelativeToSelection (const QPoint &viewPoint) const
  53 {
  54     if (!selection ())
  55         return KP_INVALID_POINT;
  56
  57     return mouseViewPoint (viewPoint) - transformDocToView (selection ()->topLeft ());
  58 }
  59
  60 // public
  61 bool kpView::mouseOnSelection (const QPoint &viewPoint) const
  62 {
  63     const QRect selViewRect = selectionViewRect ();
  64     if (!selViewRect.isValid ())
  65         return false;
  66
  67     return selViewRect.contains (mouseViewPoint (viewPoint));
  68 }
  69
  70
  71 // public
  72 int kpView::textSelectionMoveBorderAtomicSize () const
  73 {
  74     if (!textSelection ())
  75         return 0;
  76
  77     return qMax (4, zoomLevelX () / 100);
  78 }
  79
  80 // public
  81 bool kpView::mouseOnSelectionToMove (const QPoint &viewPoint) const
  82 {
  83     if (!mouseOnSelection (viewPoint))
  84         return false;
  85
  86     if (!textSelection ())
  87         return true;
  88
  89     if (mouseOnSelectionResizeHandle (viewPoint))
  90         return false;
  91
  92
  93     const QPoint viewPointRelSel = mouseViewPointRelativeToSelection (viewPoint);
  94
  95     // Middle point should always be selectable
  96     const QPoint selCenterDocPoint = selection ()->boundingRect ().center ();
  97     if (tool () &&
  98         tool ()->calculateCurrentPoint () == selCenterDocPoint)
  99     {
 100         return false;
 101     }
 102
 103
 104     const int atomicSize = textSelectionMoveBorderAtomicSize ();
 105     const QRect selViewRect = selectionViewRect ();
 106
 107     return (viewPointRelSel.x () < atomicSize ||
 108             viewPointRelSel.x () >= selViewRect.width () - atomicSize ||
 109             viewPointRelSel.y () < atomicSize ||
 110             viewPointRelSel.y () >= selViewRect.height () - atomicSize);
 111 }
 112
 113
 114 // protected
 115 bool kpView::selectionLargeEnoughToHaveResizeHandlesIfAtomicSize (int atomicSize) const
 116 {
 117     if (!selection ())
 118         return false;
 119
 120     const QRect selViewRect = selectionViewRect ();
 121
 122     return (selViewRect.width () >= atomicSize * 5 ||
 123             selViewRect.height () >= atomicSize * 5);
 124 }
 125
 126 // public
 127 int kpView::selectionResizeHandleAtomicSize () const
 128 {
 129     int atomicSize = qMin (7, qMax (4, zoomLevelX () / 100));
 130     while (atomicSize > 0 &&
 131            !selectionLargeEnoughToHaveResizeHandlesIfAtomicSize (atomicSize))
 132     {
 133         atomicSize--;
 134     }
 135
 136     return atomicSize;
 137 }
 138
 139 // public
 140 bool kpView::selectionLargeEnoughToHaveResizeHandles () const
 141 {
 142     return (selectionResizeHandleAtomicSize () > 0);
 143 }
 144
 145 // public
 146 QRegion kpView::selectionResizeHandlesViewRegion (bool forRenderer) const
 147 {
 148     QRegion ret;
 149
 150     const int atomicLength = selectionResizeHandleAtomicSize ();
 151     if (atomicLength <= 0)
 152         return QRegion ();
 153
 154
 155     // HACK: At low zoom (e.g. 100%), resize handles will probably be too
 156     //       big and overlap text / cursor / too much of selection.
 157     //
 158     //       So limit the _visual_ size of handles at low zoom.  The
 159     //       handles' grab area remains the same for usability; so yes,
 160     //       there are a few pixels that don't look grabable but they are.
 161     //
 162     //       The real solution is to be able to partially render the
 163     //       handles outside of the selection view rect.  If not possible,
 164     //       at least for text boxes, render text on top of handles.
 165     int normalAtomicLength = atomicLength;
 166     int vertEdgeAtomicLength = atomicLength;
 167     if (forRenderer && selection ())
 168     {
 169         if (zoomLevelX () <= 150)
 170         {
 171             if (normalAtomicLength > 1)
 172                 normalAtomicLength--;
 173
 174             if (vertEdgeAtomicLength > 1)
 175                 vertEdgeAtomicLength--;
 176         }
 177
 178         // 1 line of text?
 179         if (textSelection () && textSelection ()->textLines ().size () == 1)
 180         {
 181             if (zoomLevelX () <= 150)
 182                 vertEdgeAtomicLength = qMin (vertEdgeAtomicLength, qMax (2, zoomLevelX () / 100));
 183             else if (zoomLevelX () <= 250)
 184                 vertEdgeAtomicLength = qMin (vertEdgeAtomicLength, qMax (3, zoomLevelX () / 100));
 185         }
 186     }
 187
 188
 189     const QRect selViewRect = selectionViewRect ();
 190
 191 #define ADD_BOX_RELATIVE_TO_SELECTION(type,x,y)    \
 192     ret += QRect ((x), (y), type##AtomicLength, type##AtomicLength)
 193
 194     ADD_BOX_RELATIVE_TO_SELECTION (normal,
 195                                    selViewRect.width () - normalAtomicLength,
 196                                    selViewRect.height () - normalAtomicLength);
 197     ADD_BOX_RELATIVE_TO_SELECTION (normal,
 198                                    selViewRect.width () - normalAtomicLength,
 199                                    0);
 200     ADD_BOX_RELATIVE_TO_SELECTION (normal,
 201                                    0,
 202                                    selViewRect.height () - normalAtomicLength);
 203     ADD_BOX_RELATIVE_TO_SELECTION (normal,
 204                                    0,
 205                                    0);
 206
 207     ADD_BOX_RELATIVE_TO_SELECTION (vertEdge,
 208                                    selViewRect.width () - vertEdgeAtomicLength,
 209                                    (selViewRect.height () - vertEdgeAtomicLength) / 2);
 210     ADD_BOX_RELATIVE_TO_SELECTION (normal,
 211                                    (selViewRect.width () - normalAtomicLength) / 2,
 212                                    selViewRect.height () - normalAtomicLength);
 213     ADD_BOX_RELATIVE_TO_SELECTION (normal,
 214                                    (selViewRect.width () - normalAtomicLength) / 2,
 215                                    0);
 216     ADD_BOX_RELATIVE_TO_SELECTION (vertEdge,
 217                                    0,
 218                                    (selViewRect.height () - vertEdgeAtomicLength) / 2);
 219
 220 #undef ADD_BOX_RELATIVE_TO_SELECTION
 221
 222     ret.translate (selViewRect.x (), selViewRect.y ());
 223     ret = ret.intersect (selViewRect);
 224
 225     return ret;
 226 }
 227
 228 // public
 229 // REFACTOR: use QFlags as the return type for better type safety.
 230 int kpView::mouseOnSelectionResizeHandle (const QPoint &viewPoint) const
 231 {
 232 #if DEBUG_KP_VIEW
 233     kDebug () << "kpView::mouseOnSelectionResizeHandle(viewPoint="
 234                << viewPoint << ")" << endl;
 235 #endif
 236
 237     if (!mouseOnSelection (viewPoint))
 238     {
 239     #if DEBUG_KP_VIEW
 240         kDebug () << "\tmouse not on sel";
 241     #endif
 242         return 0;
 243     }
 244
 245
 246     const QRect selViewRect = selectionViewRect ();
 247 #if DEBUG_KP_VIEW
 248     kDebug () << "\tselViewRect=" << selViewRect;
 249 #endif
 250
 251
 252     const int atomicLength = selectionResizeHandleAtomicSize ();
 253 #if DEBUG_KP_VIEW
 254     kDebug () << "\tatomicLength=" << atomicLength;
 255 #endif
 256
 257     if (atomicLength <= 0)
 258     {
 259     #if DEBUG_KP_VIEW
 260         kDebug () << "\tsel not large enough to have resize handles";
 261     #endif
 262         // Want to make it possible to move a small selection
 263         return 0;
 264     }
 265
 266
 267     const QPoint viewPointRelSel = mouseViewPointRelativeToSelection (viewPoint);
 268 #if DEBUG_KP_VIEW
 269     kDebug () << "\tviewPointRelSel=" << viewPointRelSel;
 270 #endif
 271
 272
 273 #define LOCAL_POINT_IN_BOX_AT(x,y)  \
 274     QRect ((x), (y), atomicLength, atomicLength).contains (viewPointRelSel)
 275
 276     // Favour the bottom & right and the corners.
 277     if (LOCAL_POINT_IN_BOX_AT (selViewRect.width () - atomicLength,
 278                                selViewRect.height () - atomicLength))
 279     {
 280         return kpView::Bottom | kpView::Right;
 281     }
 282     else if (LOCAL_POINT_IN_BOX_AT (selViewRect.width () - atomicLength, 0))
 283     {
 284         return kpView::Top | kpView::Right;
 285     }
 286     else if (LOCAL_POINT_IN_BOX_AT (0, selViewRect.height () - atomicLength))
 287     {
 288         return kpView::Bottom | kpView::Left;
 289     }
 290     else if (LOCAL_POINT_IN_BOX_AT (0, 0))
 291     {
 292         return kpView::Top | kpView::Left;
 293     }
 294     else if (LOCAL_POINT_IN_BOX_AT (selViewRect.width () - atomicLength,
 295                                     (selViewRect.height () - atomicLength) / 2))
 296     {
 297         return kpView::Right;
 298     }
 299     else if (LOCAL_POINT_IN_BOX_AT ((selViewRect.width () - atomicLength) / 2,
 300                                     selViewRect.height () - atomicLength))
 301     {
 302         return kpView::Bottom;
 303     }
 304     else if (LOCAL_POINT_IN_BOX_AT ((selViewRect.width () - atomicLength) / 2, 0))
 305     {
 306         return kpView::Top;
 307     }
 308     else if (LOCAL_POINT_IN_BOX_AT (0, (selViewRect.height () - atomicLength) / 2))
 309     {
 310         return kpView::Left;
 311     }
 312     else
 313     {
 314     #if DEBUG_KP_VIEW
 315         kDebug () << "\tnot on sel resize handle";
 316     #endif
 317         return 0;
 318     }
 319 #undef LOCAL_POINT_IN_BOX_AT
 320 }
 321
 322 // public
 323 bool kpView::mouseOnSelectionToSelectText (const QPoint &viewPoint) const
 324 {
 325 #if DEBUG_KP_VIEW
 326     kDebug () << "kpView::mouseOnSelectionToSelectText(viewPoint="
 327                << viewPoint << ")" << endl;
 328 #endif
 329
 330     if (!mouseOnSelection (viewPoint))
 331     {
 332     #if DEBUG_KP_VIEW
 333         kDebug () << "\tmouse non on sel";
 334     #endif
 335         return false;
 336     }
 337
 338     if (!textSelection ())
 339     {
 340     #if DEBUG_KP_VIEW
 341         kDebug () << "\tsel not text";
 342     #endif
 343         return false;
 344     }
 345
 346 #if DEBUG_KP_VIEW
 347     kDebug () << "\tmouse on sel: to move=" << mouseOnSelectionToMove ()
 348                << " to resize=" << mouseOnSelectionResizeHandle ()
 349                << endl;
 350 #endif
 351
 352     return (!mouseOnSelectionToMove (viewPoint) &&
 353             !mouseOnSelectionResizeHandle (viewPoint));
 354 }