Subversion Repositories Scribus

Rev

Rev 13510 | Rev 13660 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
12775 jghali 1
/*
2
 For general Scribus (>=1.3.2) copyright and licensing information please refer
3
 to the COPYING file provided with the program. Following this notice may exist
4
 a copyright and/or license notice that predates the release of Scribus 1.3.2
5
 for which a new license (GPL+exception) is in place.
6
 */
7
/***************************************************************************
8
*                                                                         *
9
*   This program is free software; you can redistribute it and/or modify  *
10
*   it under the terms of the GNU General Public License as published by  *
11
*   the Free Software Foundation; either version 2 of the License, or     *
12
*   (at your option) any later version.                                   *
13
*                                                                         *
14
***************************************************************************/
15
 
16
 
17
#include "canvasmode_edit.h"
18
 
19
#include <QApplication>
20
#include <QButtonGroup>
21
#include <QCheckBox>
22
#include <QCursor>
23
#include <QEvent>
24
#include <QMessageBox>
25
#include <QMouseEvent>
26
#include <QPainterPath>
27
#include <QPoint>
28
#include <QRect>
29
#include <QTimer>
30
#include <QWidgetAction>
31
#include <QDebug>
32
 
33
#include "aligndistribute.h"
34
#include "canvas.h"
35
#include "canvasgesture_resize.h"
36
#include "contextmenu.h"
37
#include "customfdialog.h"
38
#include "fpoint.h"
39
#include "fpointarray.h"
40
#include "hyphenator.h"
41
#include "insertTable.h"
42
#include "pageitem_textframe.h"
43
#include "pageselector.h"
44
#include "prefscontext.h"
45
#include "prefsfile.h"
46
#include "prefsmanager.h"
47
#include "propertiespalette.h"
12809 pierre 48
#include "sccolorengine.h"
12841 jghali 49
#include "scmimedata.h"
12775 jghali 50
#include "scribus.h"
51
#include "scribusdoc.h"
52
#include "scribusview.h"
53
#include "scribusXml.h"
54
#include "selection.h"
55
#include "undomanager.h"
56
#include "units.h"
57
#include "util.h"
58
#include "util_icon.h"
59
#include "util_math.h"
60
 
61
 
62
CanvasMode_Edit::CanvasMode_Edit(ScribusView* view) : CanvasMode(view), m_ScMW(view->m_ScMW)
63
{
64
        Mxp = Myp = -1;
65
        Dxp = Dyp = -1;
66
        oldCp = Cp = -1;
67
        frameResizeHandle = -1;
68
        resizeGesture = NULL;
12809 pierre 69
        m_blinker = new QTimer(view);  
12775 jghali 70
        connect(m_blinker, SIGNAL(timeout()), this, SLOT(blinkTextCursor()));
71
}
72
 
73
inline bool CanvasMode_Edit::GetItem(PageItem** pi)
74
{
75
        *pi = m_doc->m_Selection->itemAt(0);
76
        return (*pi) != NULL;
77
}
78
 
79
 
80
void CanvasMode_Edit::blinkTextCursor()
81
{
82
        PageItem* currItem;
83
        if (m_doc->appMode == modeEdit && GetItem(&currItem))
84
        {
85
                QRectF brect = currItem->getBoundingRect();
86
//              qDebug() << "update cursor" << brect;
87
                m_canvas->update(QRectF(m_canvas->canvasToLocal(brect.topLeft()), QSizeF(brect.width(),brect.height())*m_canvas->scale()).toRect());
88
        }
89
}
90
 
91
void CanvasMode_Edit::drawControls(QPainter* p)
92
{
13124 fschmid 93
        commonDrawControls(p);
12775 jghali 94
        PageItem* currItem;
95
        if (GetItem(&currItem))
96
        {
97
                PageItem_TextFrame* textframe = currItem->asTextFrame();
98
                if (textframe)
99
                        drawTextCursor(p, textframe);
100
        }
101
}
102
 
103
 
13079 pierre 104
void CanvasMode_Edit::drawTextCursor ( QPainter *p, PageItem_TextFrame* textframe )
12775 jghali 105
{
13119 pierre 106
        if(textframe->lastInFrame() < 0)
107
                return;
13079 pierre 108
        if ( m_blinkTime.elapsed() > qApp->cursorFlashTime() / 2 )
12775 jghali 109
        {
13079 pierre 110
                m_cursorVisible = !m_cursorVisible;
111
                m_blinkTime.restart();
12775 jghali 112
        }
13079 pierre 113
        if ( m_cursorVisible )
12775 jghali 114
        {
13089 pierre 115
                // Debug
116
//              QString dbgString;
117
//              int lif(qMax(textframe->CPos , textframe->lastInFrame()));
118
//              for(int ti(textframe->firstInFrame());ti < lif; ++ti)
119
//              {
120
//                      if(ti == textframe->CPos )
121
//                      {
122
//                              dbgString += "["+QString::number(textframe->CPos)+"]";
123
//                      }
124
//                      dbgString += textframe->itemText.text(ti);
125
//              }
126
//              dbgString +="]"+QString::number(textframe->lastInFrame())+"[";
127
//              qDebug()<<"==============================================================";
128
//              qDebug()<<textframe->CPos<<textframe->lastInFrame();
129
//              qDebug()<<dbgString;
130
//              qDebug()<<"==============================================================";
131
                // end debug
13079 pierre 132
                double dx, dy, dy1;
133
                QPen cPen ( Qt::black, 0.9 , Qt::SolidLine, Qt::FlatCap, Qt::MiterJoin );
134
 
135
                // normalize Current Position
136
                textframe->CPos = qMax ( 0,qMin ( textframe->CPos, textframe->itemText.length() ) );
137
                int textCursorPos ( textframe->CPos );
138
 
139
                if ( textframe->lastInFrame() >= signed ( textframe->itemText.nrOfItems() )
140
                        || textframe->itemText.length() == 0 )
141
                {
13106 pierre 142
                        dx = textframe->textToFrameDistLeft();
143
                        dy = textframe->textToFrameDistTop();
13107 pierre 144
                        dy1 = textframe->textToFrameDistTop() + (textframe->itemText.defaultStyle().charStyle().fontSize() / 10.0);
13079 pierre 145
 
146
                        cPen.setColor ( ScColorEngine::getRGBColor ( m_doc->PageColors[textframe->itemText.defaultStyle().charStyle().fillColor() ], m_doc ) );
147
                }
148
                else if ( textCursorPos > textframe->lastInFrame() )
149
                {
150
                        // Happens often when typing directly into frame.
151
                        // And the cursor curses nothing, vertigo.
152
                        textCursorPos = textframe->lastInFrame();
13089 pierre 153
                        if(textframe->itemText.text(textCursorPos) == SpecialChars::PARSEP)
154
                        {
155
                                // The cursor must be moved to the beginning of the next line
156
                                FRect bbox = textframe->itemText.boundingBox ( textCursorPos );
157
                                double lineSpacing(textframe->itemText.paragraphStyle(textCursorPos).lineSpacing());
13106 pierre 158
 
159
                                // take care if cursor is not in first column
160
                                int curCol(1);
161
                                double ccPos(textframe->itemText.boundingBox ( textCursorPos ).x());
162
                                double leftOffset(textframe->textToFrameDistLeft());
163
                                for(int ci(1); ci <= textframe->columns(); ++ci)
164
                                {
165
                                        double cLeft(((ci-1) * textframe->columnWidth()) + ((ci -1) * textframe->columnGap()) + leftOffset);
166
                                        double cRight((ci * textframe->columnWidth()) + ((ci -1) * textframe->columnGap()) + leftOffset);
167
                                        if((cLeft <= ccPos) && (ccPos <= cRight))
168
                                        {
169
                                                curCol = ci;
170
                                                break;
171
                                        }
172
                                }
173
                                dx = (textframe->columnWidth() * (curCol - 1)) + (textframe->columnGap() * (curCol - 1))  + leftOffset;
13089 pierre 174
                                dy = bbox.y();
175
 
176
                                if ( bbox.height() <= 2 )
177
                                        dy1 = bbox.y() + textframe->itemText.charStyle ( textCursorPos ).fontSize() / 30.0;
178
                                else
179
                                        dy1 = bbox.y() + bbox.height();
180
 
181
                                dy  += lineSpacing;
182
                                dy1 += lineSpacing;
183
                        }
13098 pierre 184
                        else if((textframe->itemText.text(textCursorPos) == SpecialChars::COLBREAK))
185
                        {
186
                                // A bit tricky :)
187
                                // We want to position the cursor at the beginning of the next column, if any.
188
                                // At first we need to know in which column the cursor is.
189
                                int curCol(1);
190
                                double ccPos(textframe->itemText.boundingBox ( textCursorPos ).x());
13106 pierre 191
                                double leftOffset(textframe->textToFrameDistLeft());
13098 pierre 192
                                for(int ci(1); ci <= textframe->columns(); ++ci)
193
                                {
13106 pierre 194
                                        double cLeft(((ci-1) * textframe->columnWidth()) + ((ci -1) * textframe->columnGap()) + leftOffset);
195
                                        double cRight((ci * textframe->columnWidth()) + ((ci -1) * textframe->columnGap()) + leftOffset);
13098 pierre 196
                                        if((cLeft <= ccPos) && (ccPos <= cRight))
197
                                        {
198
                                                curCol = ci;
199
                                                break;
200
                                        }
201
                                }
202
                                if(textframe->columns() > curCol)
203
                                {
13106 pierre 204
                                        dx = (textframe->columnWidth() * curCol) + (textframe->columnGap() * curCol)  + leftOffset;
205
                                        dy = textframe->textToFrameDistTop();
13107 pierre 206
                                        dy1 = textframe->textToFrameDistTop() + textframe->itemText.boundingBox ( textCursorPos ).height();
13098 pierre 207
                                }
208
                                else // there is no column after the current column
209
                                {
210
                                        FRect bbox = textframe->itemText.boundingBox ( textCursorPos );
211
                                        dx = bbox.x();
212
                                        dy = bbox.y();
213
                                        dx += textframe->itemText.item ( textCursorPos )->glyph.wide();
214
                                        if ( bbox.height() <= 2 )
215
                                                dy1 = bbox.y() + textframe->itemText.charStyle ( textCursorPos ).fontSize() / 30.0;
216
                                        else
217
                                                dy1 = bbox.y() + bbox.height();
218
                                }
219
                        }
13079 pierre 220
                        else
13089 pierre 221
                        {
222
                                FRect bbox = textframe->itemText.boundingBox ( textCursorPos );
223
                                dx = bbox.x();
224
                                dy = bbox.y();
225
                                dx += textframe->itemText.item ( textCursorPos )->glyph.wide();
226
                                if ( bbox.height() <= 2 )
227
                                        dy1 = bbox.y() + textframe->itemText.charStyle ( textCursorPos ).fontSize() / 30.0;
228
                                else
229
                                        dy1 = bbox.y() + bbox.height();
230
 
231
                        }
13079 pierre 232
                        cPen.setColor ( ScColorEngine::getRGBColor ( m_doc->PageColors[textframe->itemText.charStyle ( textCursorPos ).fillColor() ], m_doc ) );
233
                }
12775 jghali 234
                else
13079 pierre 235
                {
236
                        FRect bbox = textframe->itemText.boundingBox ( textCursorPos );
237
                        dx = bbox.x();
238
                        dy = bbox.y();
239
                        if ( bbox.height() <= 2 )
240
                                dy1 = bbox.y() + textframe->itemText.charStyle ( textCursorPos ).fontSize() / 30.0;
241
                        else
242
                                dy1 = bbox.y() + bbox.height();
12775 jghali 243
 
13079 pierre 244
                        cPen.setColor ( ScColorEngine::getRGBColor ( m_doc->PageColors[textframe->itemText.charStyle ( textCursorPos ).fillColor() ], m_doc ) );
245
                }
246
                //handle Right to Left writing
247
                if ( textframe->reversed() )
248
                {
249
                        dx=textframe->width()-dx;
250
                }
251
 
252
                p->save();
253
                p->translate ( textframe->xPos(), textframe->yPos() );
254
                p->rotate ( textframe->rotation() );
255
 
256
 
257
                p->setPen ( cPen );
258
                p->setRenderHint ( QPainter::Antialiasing, true );
13061 pierre 259
                // avoid displaying the cursor on the frameborder
13079 pierre 260
                dx = qMax ( ( cPen.widthF() / 2.0 ), dx );
13061 pierre 261
 
13079 pierre 262
                dy =  qMin ( qMax ( dy,0.0 ) , textframe->height() );
263
                dy1 = qMin ( qMax ( dy1,0.0 ), textframe->height() );
13061 pierre 264
 
13079 pierre 265
                p->drawLine ( QLineF ( dx,dy,dx,dy1 ) );
13061 pierre 266
 
13079 pierre 267
                p->restore();
12775 jghali 268
        }
269
}
270
 
271
void CanvasMode_Edit::enterEvent(QEvent *)
272
{
273
        if (!m_canvas->m_viewMode.m_MouseButtonPressed)
274
        {
275
                setModeCursor();
276
        }
277
}
278
 
279
void CanvasMode_Edit::leaveEvent(QEvent *e)
280
{
281
        if (!m_canvas->m_viewMode.m_MouseButtonPressed)
282
                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
283
}
284
 
285
void CanvasMode_Edit::activate(bool fromGesture)
286
{
287
//      qDebug() << "CanvasMode_Edit::activate" << fromGesture;
288
        m_canvas->m_viewMode.m_MouseButtonPressed = false;
289
        m_canvas->resetRenderMode();
290
        m_doc->DragP = false;
291
        m_doc->leaveDrag = false;
292
        m_canvas->m_viewMode.operItemMoving = false;
293
        m_canvas->m_viewMode.operItemResizing = false;
294
        m_view->MidButt = false;
295
        Mxp = Myp = -1;
296
        Dxp = Dyp = -1;
297
        oldCp = Cp = -1;
298
        frameResizeHandle = -1;
299
        setModeCursor();
300
        if (m_doc->appMode == modeEdit)
301
        {
302
                m_blinker->start(500);
303
                m_blinkTime.start();
304
                m_cursorVisible = true;
305
        }
306
        if (fromGesture)
307
        {
308
                m_canvas->m_viewMode.operItemResizeInEditMode = false;
309
                m_view->update();
310
        }
13106 pierre 311
        PageItem * it(0);
312
        if(GetItem(&it))
313
        {
13115 pierre 314
                m_canvas->setupEditHRuler(it, true);
13106 pierre 315
        }
12775 jghali 316
}
317
 
318
void CanvasMode_Edit::deactivate(bool forGesture)
319
{
320
//      qDebug() << "CanvasMode_Edit::deactivate" << forGesture;
321
        m_view->redrawMarker->hide();
322
        if (!forGesture)
323
                m_blinker->stop();
324
}
325
 
326
void CanvasMode_Edit::mouseDoubleClickEvent(QMouseEvent *m)
327
{
328
        m->accept();
329
        m_canvas->m_viewMode.m_MouseButtonPressed = false;
330
        m_canvas->resetRenderMode();
13285 fschmid 331
//      m_view->stopDragTimer();
12775 jghali 332
        PageItem *currItem = 0;
13054 pierre 333
        if (GetItem(&currItem) && (m_doc->appMode == modeEdit) && currItem->asTextFrame())
12775 jghali 334
        {
13054 pierre 335
                //CB if annotation, open the annotation dialog
336
                if (currItem->isAnnotation())
337
                {
338
                        m_view->requestMode(submodeAnnotProps);
339
                }
340
                //otherwise, select between the whitespace
341
                else
342
                {       //Double click in a frame to select a word
343
                        oldCp = currItem->CPos;
344
                        currItem->CPos = currItem->itemText.selectWord(currItem->CPos);
345
                }
346
        }
347
        else
348
        {
12775 jghali 349
                mousePressEvent(m);
350
                return;
351
        }
352
}
353
 
354
 
355
void CanvasMode_Edit::mouseMoveEvent(QMouseEvent *m)
356
{
357
//      const double mouseX = m->globalX();
358
//      const double mouseY = m->globalY();
359
        const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
360
 
361
        m_lastPosWasOverGuide = false;
362
        double newX, newY;
363
        double nx, ny;
364
        PageItem *currItem;
365
        QPoint np, np2, mop;
366
        FPoint npf, npf2;
367
        QRect tx;
368
        bool erf = false;
369
        m->accept();
13132 pierre 370
        if (commonMouseMove(m))
13128 jghali 371
                return;
12775 jghali 372
        if (GetItem(&currItem))
373
        {
374
                newX = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
375
                newY = qRound(mousePointDoc.y()); //m_view->translateToDoc(m->x(), m->y()).y());
376
                if (m_doc->DragP)
377
                        return;
378
                if (m_canvas->m_viewMode.m_MouseButtonPressed && (m_doc->appMode == modeEdit) && (!m_canvas->m_viewMode.operItemResizeInEditMode))
379
                {
380
                        if (currItem->asImageFrame())
381
                        {
382
                                QMatrix ro;
383
                                ro.rotate(-currItem->rotation());
384
                                QPointF rota = ro.map(QPointF(newX-Mxp,newY-Myp));
385
                                currItem->moveImageInFrame(rota.x()/currItem->imageXScale(), rota.y()/currItem->imageYScale());
386
                //              m_view->updateContents(currItem->getRedrawBounding(m_canvas->scale()));
13289 jghali 387
                                currItem->update();
12775 jghali 388
                                Mxp = newX;
389
                                Myp = newY;
390
                                m_canvas->displayXYHUD(m->globalPos(), currItem->imageXOffset() * currItem->imageXScale(), currItem->imageYOffset() * currItem->imageYScale());
391
                        }
392
                        if (currItem->asTextFrame())
393
                        {
13617 pierre 394
                                int refStartSel(currItem->asTextFrame()->itemText.startOfSelection());
395
                                int refEndSel(currItem->asTextFrame()->itemText.endOfSelection());
12775 jghali 396
                                currItem->itemText.deselectAll();
397
                                currItem->HasSel = false;
13297 pierre 398
                                m_view->slotSetCurs(m->globalPos().x(), m->globalPos().y());
12775 jghali 399
                                //Make sure we dont go here if the old cursor position was not set
400
                                if (oldCp!=-1 && currItem->itemText.length() > 0)
401
                                {
402
                                        if (currItem->CPos < oldCp)
403
                                        {
404
                                                currItem->itemText.select(currItem->CPos, oldCp - currItem->CPos);
405
                                                currItem->HasSel = true;
406
                                        }
407
                                        if (currItem->CPos > oldCp)
408
                                        {
409
                                                currItem->itemText.select(oldCp, currItem->CPos - oldCp);
410
                                                currItem->HasSel = true;
411
                                        }
412
                                }
13617 pierre 413
 
12775 jghali 414
                                if(currItem->HasSel)
13132 pierre 415
                                {
12775 jghali 416
                                        m_ScMW->EnableTxEdit();
13132 pierre 417
                                        m_canvas->m_viewMode.operTextSelecting = true;
13617 pierre 418
                                        if((refStartSel != currItem->asTextFrame()->itemText.startOfSelection())
419
                                                || (refEndSel != currItem->asTextFrame()->itemText.endOfSelection()))
420
                                        {
421
                                                QRectF br(currItem->getBoundingRect());
422
                                                m_canvas->update(QRectF(m_canvas->canvasToLocal(br.topLeft()), br.size() * m_canvas->scale()).toRect());
423
                                        }
13132 pierre 424
                                }
12775 jghali 425
                                else
426
                                        m_ScMW->DisableTxEdit();
13617 pierre 427
 
12775 jghali 428
                        }
429
                }
430
                //Operations run here:
431
                //Item resize, esp after creating a new one
432
                if (m_view->moveTimerElapsed() && m_canvas->m_viewMode.m_MouseButtonPressed && (m->buttons() & Qt::LeftButton) &&
433
                        ((m_doc->appMode == modeEdit) && m_canvas->m_viewMode.operItemResizeInEditMode) && (!currItem->locked()))
434
                {
13285 fschmid 435
//                      m_view->stopDragTimer();
12775 jghali 436
                        if (m_canvas->m_viewMode.operItemResizing)
437
                        {
438
//                              newX = static_cast<int>(m->x()/sc);
439
//                              newY = static_cast<int>(m->y()/sc);
440
                                m_canvas->m_viewMode.operItemMoving = false;
441
                                if (m_doc->m_Selection->isMultipleSelection())
442
                                {
12858 pierre 443
//                                      qDebug()<<"Resizing multiple selection"<<frameResizeHandle;
12775 jghali 444
//                                      newX = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
445
//                                      newY = qRound(mousePointDoc.y()); //m_view->translateToDoc(m->x(), m->y()).y());
446
                                        double gx, gy, gh, gw;
447
                                        m_doc->m_Selection->getVisualGroupRect(&gx, &gy, &gw, &gh);
448
                                        const double sc=1;
449
                                        int ox1 = qRound(gx*sc);
450
                                        int oy1 = qRound(gy*sc);
451
                                        int ox2 = qRound((gx+gw)*sc);
452
                                        int oy2 = qRound((gy+gh)*sc);
453
                                        FPoint np2 = FPoint(newX, newY);
454
                                        np2 = m_doc->ApplyGridF(mousePointDoc);
455
                                        double nx = np2.x();
456
                                        double ny = np2.y();
457
                                        m_doc->ApplyGuides(&nx, &ny);
458
                                        np2 = FPoint(qRound(nx*sc), qRound(ny*sc));
459
                                        QMatrix pm;
460
                                        switch (frameResizeHandle)
461
                                        {
462
                                        case 1:
463
                                                if (m->modifiers() & Qt::ControlModifier)
464
                                                        np2 = FPoint(qRound(newX), qRound(gy+(gh * ((newX-gx) / gw))));
465
                                                else
466
                                                        np2 = FPoint(qRound(newX), qRound(newY));
467
                                                np2 = m_doc->ApplyGridF(np2);
468
                                                nx = np2.x();
469
                                                ny = np2.y();
470
                                                m_doc->ApplyGuides(&nx, &ny);
471
                                                np2 = FPoint(qRound(nx*sc), qRound(ny*sc));
472
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(qRound(gx*sc), qRound(gy*sc)), QPoint(qRound(np2.x()), qRound(np2.y())))));
473
                                                break;
474
                                        case 2:
475
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(qRound(np2.x()), qRound(np2.y())), QPoint(ox2,oy2))));
476
                                                break;
477
                                        case 3:
478
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(qRound(np2.x()), qRound(np2.y())), QPoint(ox1, oy2))));
479
                                                break;
480
                                        case 4:
481
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(qRound(np2.x()), qRound(np2.y())), QPoint(ox2, oy1))));
482
                                                break;
483
                                        case 5:
484
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(ox1, oy1), QPoint(ox2, qRound(np2.y())))));
485
                                                break;
486
                                        case 6:
487
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(qRound(np2.x()), oy2), QPoint(ox1,oy1))));
488
                                                break;
489
                                        case 7:
490
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(qRound(np2.x()), oy1), QPoint(ox2, oy2))));
491
                                                break;
492
                                        case 8:
493
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(ox1, qRound(qRound(np2.y()))), QPoint(ox2, oy2))));
494
                                                break;
495
                                        }
496
                                        Mxp = qRound(np2.x());
497
                                        Myp = qRound(np2.y());
498
                                }
499
                                else
500
                                {
12858 pierre 501
//                                      qDebug()<<"frameResizeHandle"<<frameResizeHandle;
12775 jghali 502
                                        for (int a = 0; a < m_doc->m_Selection->count(); ++a)
503
                                        {
504
                                                currItem = m_doc->m_Selection->itemAt(0);
505
                                                double nh = currItem->height();
506
                                                if ((frameResizeHandle == 1) || (frameResizeHandle == 2))
507
                                                {
508
                                                        QMatrix mp;
509
                                                        switch (frameResizeHandle)
510
                                                        {
511
                                                        case 1:
512
//                                                              mp.translate(-m_doc->minCanvasCoordinate.x() * m_canvas->scale(),-m_doc->minCanvasCoordinate.y() * m_canvas->scale());
513
                                                                m_canvas->Transform(currItem, mp);
514
                                                                //Shift proportional square resize
515
                                                                if ((m->modifiers() & Qt::ShiftModifier) && (!(m->modifiers() & Qt::ControlModifier)))
516
                                                                {
517
                                                                        QMatrix ma;
518
                                                                        ma.translate(currItem->xPos(), currItem->yPos());
519
                                                                        ma.rotate(currItem->rotation());
520
                                                                        ma = ma.inverted();
521
                                                                        nh = ma.m11() * newX + ma.m21() * newY + ma.dx();
522
                                                                        mop = QPoint(m->x(), m->y());
523
                                                                }
524
                                                                else
525
                                                                {
526
                                                                        //Control proportional resize
527
                                                                        if ((m->modifiers() & Qt::ControlModifier) && (!(m->modifiers() & Qt::ShiftModifier)))
528
                                                                        {
529
                                                                                QMatrix ma;
530
                                                                                ma.translate(currItem->xPos(), currItem->yPos());
531
                                                                                ma.rotate(currItem->rotation());
532
                                                                                ma = ma.inverted();
533
                                                                                double nX = ma.m11() * newX + ma.m21() * newY + ma.dx();
534
                                                                                nh = nX / currItem->OldB2 * currItem->OldH2;
535
                                                                                mop = QPoint(m->x(), m->y());
536
                                                                        }
537
                                                                        else
538
                                                                                mop = QPoint(m->x(), m->y());
539
                                                                }
540
                                                                np = mop * mp.inverted();
541
                                                                nx = np.x();
542
                                                                ny = np.y();
543
                                                                if (!currItem->asLine())
544
                                                                {
545
                                                                        if ((m_doc->useRaster) && (m_doc->OnPage(currItem) != -1))
546
                                                                        {
547
                                                                                nx += currItem->xPos();
548
                                                                                ny += currItem->yPos();
549
                                                                                npf = m_doc->ApplyGridF(FPoint(nx, ny));
550
                                                                                nx = npf.x() - currItem->xPos();
551
                                                                                ny = npf.y() - currItem->yPos();
552
                                                                        }
553
                                                                        if (m_doc->SnapGuides)
554
                                                                        {
555
                                                                                nx += currItem->xPos();
556
                                                                                ny += currItem->yPos();
557
                                                                                m_doc->ApplyGuides(&nx, &ny);
558
                                                                                nx -= currItem->xPos();
559
                                                                                ny -= currItem->yPos();
560
                                                                        }
561
                                                                        if ((m->modifiers() & Qt::ControlModifier) || ((m->modifiers() & Qt::ShiftModifier)))
562
                                                                                erf = m_doc->SizeItem(nx, nh, currItem->ItemNr);
563
                                                                        else
564
                                                                                erf = m_doc->SizeItem(nx, ny, currItem->ItemNr);
565
                                                                        QMatrix mp;
566
                                                                        mp.translate(currItem->xPos(),// - m_doc->minCanvasCoordinate.x(), 
567
                                                                                                 currItem->yPos());// - m_doc->minCanvasCoordinate.y());
568
                                                                        mp.rotate(currItem->rotation());
569
                                                                        np2 = QPoint(qRound(nx), qRound(ny));
570
                                                                        QMatrix pm;
571
                                                                        m_canvas->Transform(currItem, pm);
572
                                                                        m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(0, 0), np2)));
573
                                                                }
574
                                                                else
575
                                                                {
576
                                                                        double rba = currItem->rotation();
577
                                                                        currItem->setRotation(0.0);
578
                                                                        QMatrix mp;
579
                                                                        m_canvas->Transform(currItem, mp);
580
//                                                                      mp.translate(-m_doc->minCanvasCoordinate.x(), -m_doc->minCanvasCoordinate.y());
581
                                                                        np = QPoint(m->x(), m->y()) * mp.inverted();
582
                                                                        double sizeItemX=np.x(), sizeItemY=np.y();
583
                                                                        //Constrain rotation angle, when the mouse is moving the non-origin point of a line
584
                                                                        if (m->modifiers() & Qt::ControlModifier)
585
                                                                        {
586
                                                                                double newRot=xy2Deg(np.x(), np.y());
587
                                                                                rba=constrainAngle(newRot, m_doc->toolSettings.constrain);
588
                                                                                double hlen=sqrt(pow(newX - currItem->xPos(),2)+pow(newY - currItem->yPos(),2));
589
                                                                                sizeItemX = hlen * cos(rba/(180.0/M_PI));
590
                                                                                sizeItemY = hlen * sin(rba/(180.0/M_PI));
591
                                                                        }
592
                                                                        currItem->setRotation(rba);
593
                                                                        np = m_doc->ApplyGrid(np);
594
                                                                        erf = m_doc->SizeItem(sizeItemX, sizeItemY, currItem->ItemNr);
595
                                                                        QMatrix pm;
596
//                                                                      pm.translate(-m_doc->minCanvasCoordinate.x() * m_canvas->scale(),-m_doc->minCanvasCoordinate.y() * m_canvas->scale());
597
                                                                        m_canvas->Transform(currItem, pm);
598
                                                                        m_canvas->newRedrawPolygon() << pm.map(QPoint(0, 0)) << pm.map(QPoint(qRound(currItem->width()), qRound(currItem->height())));
599
                                                                        m_view->updateContents(QRect(pm.map(QPoint(0, 0)), pm.map(QPoint(qRound(currItem->width()), qRound(currItem->height())))).normalized().adjusted(-10, -10, 20, 20));
600
                                                                }
601
                                                                break;
602
                                                        case 2:
603
                                                                if (currItem->asLine())
604
                                                                {
605
                                                                        double sav = m_doc->SnapGuides;
606
                                                                        npf2 = FPoint(newX-Mxp, newY-Myp);
607
                                                                        //Constrain rotation on left point move, disabled for now in movesizeitem
608
                                                                        erf = m_doc->MoveSizeItem(npf2, FPoint(0, 0), currItem->ItemNr, false, (m->modifiers() & Qt::ControlModifier));
609
                                                                        m_doc->SnapGuides = sav;
610
                                                                        if (sav)
611
                                                                                currItem->Sizing = true;
612
                                                                        QMatrix pm;
613
//                                                                      pm.translate(-m_doc->minCanvasCoordinate.x() * m_canvas->scale(),-m_doc->minCanvasCoordinate.y() * m_canvas->scale());
614
                                                                        m_canvas->Transform(currItem, pm);
615
                                                                        m_canvas->newRedrawPolygon() << pm.map(QPoint(0, 0)) << pm.map(QPoint(qRound(currItem->width()), qRound(currItem->height())));
616
                                                                        m_view->updateContents(QRect(pm.map(QPoint(0, 0)), pm.map(QPoint(qRound(currItem->width()), qRound(currItem->height())))).normalized().adjusted(-10, -10, 20, 20));
617
                                                                }
618
                                                                else
619
                                                                {
620
                                                                        newX = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
621
                                                                        newY = qRound(mousePointDoc.y()); //m_view->translateToDoc(m->x(), m->y()).y());
622
//                                                                      np2 = QPoint(newX, newY);
623
                                                                        FPoint newP = m_doc->ApplyGridF(FPoint(newX, newY));
624
                                                                        double nx = newP.x();
625
                                                                        double ny = newP.y();
626
                                                                        m_doc->ApplyGuides(&nx, &ny);
627
                                                                        QMatrix mp;
628
//                                                                      mp.translate(currItem->xPos() - m_doc->minCanvasCoordinate.x(), currItem->yPos() - m_doc->minCanvasCoordinate.y());
629
                                                                        mp.rotate(currItem->rotation());
630
                                                                        np2 = QPoint(qRound(nx), qRound(ny)) * mp.inverted();
631
                                                                        QMatrix pm;
632
                                                                        m_canvas->Transform(currItem, pm);
633
                                                                        m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(np2, QPoint(qRound(currItem->width()), qRound(currItem->height())))));
634
                                                                }
635
                                                                break;
636
                                                        }
637
                                                }
638
                                                else
639
                                                {
640
//                                                      np2 = QPoint(newX, newY);
641
                                                        FPoint newP = m_doc->ApplyGridF(FPoint(newX, newY));
642
                                                        double nx = newP.x();
643
                                                        double ny = newP.y();
644
                                                        m_doc->ApplyGuides(&nx, &ny);
645
                                                        QMatrix mp;
646
//                                                      mp.translate(currItem->xPos() - m_doc->minCanvasCoordinate.x(), currItem->yPos() - m_doc->minCanvasCoordinate.y());
647
                                                        mp.rotate(currItem->rotation());
648
                                                        np2 = QPoint(qRound(nx), qRound(ny)) * mp.inverted();
649
                                                        QMatrix pm;
650
                                                        m_canvas->Transform(currItem, pm);
651
                                                        switch (frameResizeHandle)
652
                                                        {
653
                                                        case 0:
654
                                                                break;
655
                                                        case 3:
656
                                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(np2, QPoint(0, qRound(currItem->height())))));
657
                                                                break;
658
                                                        case 4:
659
                                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(np2, QPoint(qRound(currItem->width()), 0))));
660
                                                                break;
661
                                                        case 5:
662
                                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(0, 0), QPoint(qRound(currItem->width()), np2.y()))));
663
                                                                break;
664
                                                        case 6:
665
                                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(0, 0), QPoint(np2.x(), qRound(currItem->height())))));
666
                                                                break;
667
                                                        case 7:
668
                                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(np2.x(), 0), QPoint(qRound(currItem->width()), qRound(currItem->height())))));
669
                                                                break;
670
                                                        case 8:
671
                                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(0, np2.y()), QPoint(qRound(currItem->width()), qRound(currItem->height())))));
672
                                                                break;
673
                                                        }
674
                                                }
675
                                        }
676
                                }
677
                                if ((erf) || (frameResizeHandle > 1))
678
                                {
679
                                        Mxp = newX;
680
                                        Myp = newY;
681
                                }
682
                        }
683
                        else
684
                        {
685
                                //Dragging an item (plus more?)
686
                                QRectF newPlace;
687
                                newX = mousePointDoc.x(); //static_cast<int>(m->x()/sc);
688
                                newY = mousePointDoc.y(); //static_cast<int>(m->y()/sc);
689
                                m_canvas->m_viewMode.operItemMoving = true;
690
                                erf = false;
691
                                int dX=qRound(newX-Mxp), dY=qRound(newY-Myp);
692
                                if (!m_doc->m_Selection->isMultipleSelection())
693
                                {
694
                                        erf=true;
695
                                        currItem = m_doc->m_Selection->itemAt(0);
696
                                        //Control Alt drag image in frame without being in edit mode
697
                                        if ((currItem->asImageFrame()) && (m->modifiers() & Qt::ControlModifier) && (m->modifiers() & Qt::AltModifier))
698
                                        {
699
                                                currItem->moveImageInFrame(dX/currItem->imageXScale(),dY/currItem->imageYScale());
700
                                                m_view->updateContents(currItem->getRedrawBounding(m_canvas->scale()));
701
 
702
                                        }
703
                                        else
704
                                        {
705
                                                //Dragging orthogonally - Ctrl Drag
706
                                                if ((m->modifiers() & Qt::ControlModifier) && !(m->modifiers() & Qt::ShiftModifier) && !(m->modifiers() & Qt::AltModifier))
707
                                                {
708
                                                        if (abs(dX) > abs(dY))
709
                                                                dY=0;
710
                                                        else
711
                                                        if (abs(dY) > abs(dX))
712
                                                                dX=0;
713
                                                        erf=false;
714
                                                        dX+=qRound(dragConstrainInitPtX-currItem->xPos());
715
                                                        dY+=qRound(dragConstrainInitPtY-currItem->yPos());
716
                                                }
717
                                                if (!(currItem->isTableItem && currItem->isSingleSel))
718
                                                {
719
                                                        if (!m_view->groupTransactionStarted())
720
                                                        {
721
                                                                m_view->startGroupTransaction(Um::Move, "", Um::IMove);
722
                                                        }
723
                                                        double gx, gy, gh, gw;
724
                                                        m_doc->moveGroup(dX, dY, false);
725
                                                        m_doc->m_Selection->setGroupRect();
726
                                                        m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
727
                                                        if (m_doc->SnapGuides)
728
                                                        {
729
                                                                double nx = gx;
730
                                                                double ny = gy;
731
                                                                m_doc->ApplyGuides(&nx, &ny);
732
                                                                m_doc->moveGroup(nx-gx, ny-gy, false);
733
                                                                m_doc->m_Selection->setGroupRect();
734
                                                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
735
                                                                nx = gx+gw;
736
                                                                ny = gy+gh;
737
                                                                m_doc->ApplyGuides(&nx, &ny);
738
                                                                m_doc->moveGroup(nx-(gx+gw), ny-(gy+gh), false);
739
                                                        }
740
                                                        if (m_doc->useRaster)
741
                                                        {
742
                                                                m_doc->m_Selection->setGroupRect();
743
                                                                double gx, gy, gh, gw, gxo, gyo;
744
                                                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
745
                                                                gxo = gx;
746
                                                                gyo = gy;
747
                                                                FPoint npx = m_doc->ApplyGridF(FPoint(gx, gy));
748
                                                                FPoint npw = m_doc->ApplyGridF(FPoint(gx+gw, gy+gh));
749
                                                                if ((fabs(gx-npx.x())) > (fabs((gx+gw)-npw.x())))
750
                                                                        gx = npw.x() - gw;
751
                                                                else
752
                                                                        gx = npx.x();
753
                                                                if ((fabs(gy-npx.y())) > (fabs((gy+gh)-npw.y())))
754
                                                                        gy = npw.y() - gh;
755
                                                                else
756
                                                                        gy = npx.y();
757
                                                                if ((fabs(gx - gxo) < (m_doc->guidesSettings.guideRad / 2.0) / m_canvas->scale()) && (fabs(gy - gyo) < (m_doc->guidesSettings.guideRad / 2.0) / m_canvas->scale()))
758
                                                                        m_doc->moveGroup(gx-gxo, gy-gyo, false);
759
                                                        }
760
                                                }
761
                                        }
762
                                }
763
                                else
764
                                {
765
                                        if (!m_view->groupTransactionStarted())
766
                                        {
767
                                                m_view->startGroupTransaction(Um::Move, "", Um::IMove);
768
                                        }
769
                                        double gx, gy, gh, gw;
770
                                        m_doc->m_Selection->setGroupRect();
771
                                        m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
772
                                        int dX=qRound(newX-Mxp), dY=qRound(newY-Myp);
773
                                        erf = true;
774
                                        if (m->modifiers() & Qt::ControlModifier)
775
                                        {
776
                                                if (abs(dX)>abs(dY))
777
                                                        dY=0;
778
                                                else
779
                                                if (abs(dY)>abs(dX))
780
                                                        dX=0;
781
                                                erf=false;
782
                                                dX+=dragConstrainInitPtX-qRound(gx);
783
                                                dY+=dragConstrainInitPtY-qRound(gy);
784
                                        }
785
                                        m_doc->moveGroup(dX, dY, false);
786
                                        m_doc->m_Selection->setGroupRect();
787
                                        m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
788
                                        if (m_doc->SnapGuides)
789
                                        {
790
                                                double nx = gx;
791
                                                double ny = gy;
792
                                                m_doc->ApplyGuides(&nx, &ny);
793
                                                m_doc->moveGroup(nx-gx, ny-gy, false);
794
                                                m_doc->m_Selection->setGroupRect();
795
                                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
796
                                                nx = gx+gw;
797
                                                ny = gy+gh;
798
                                                m_doc->ApplyGuides(&nx, &ny);
799
                                                m_doc->moveGroup(nx-(gx+gw), ny-(gy+gh), false);
800
                                        }
801
                                        m_doc->m_Selection->setGroupRect();
802
                                        if (m_doc->useRaster)
803
                                        {
804
                                                m_doc->m_Selection->setGroupRect();
805
                                                double gx, gy, gh, gw, gxo, gyo;
806
                                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
807
                                                gxo = gx;
808
                                                gyo = gy;
809
                                                FPoint npx = m_doc->ApplyGridF(FPoint(gx, gy));
810
                                                FPoint npw = m_doc->ApplyGridF(FPoint(gx+gw, gy+gh));
811
                                                if ((fabs(gx-npx.x())) > (fabs((gx+gw)-npw.x())))
812
                                                        gx = npw.x() - gw;
813
                                                else
814
                                                        gx = npx.x();
815
                                                if ((fabs(gy-npx.y())) > (fabs((gy+gh)-npw.y())))
816
                                                        gy = npw.y() - gh;
817
                                                else
818
                                                        gy = npx.y();
819
                                                if ((fabs(gx - gxo) < (m_doc->guidesSettings.guideRad / 2.0) / m_canvas->scale()) && (fabs(gy - gyo) < (m_doc->guidesSettings.guideRad / 2.0) / m_canvas->scale()))
820
                                                        m_doc->moveGroup(gx-gxo, gy-gyo, false);
821
                                                m_doc->m_Selection->setGroupRect();
822
                                        }
823
                                }
824
                                if (erf)
825
                                {
826
                                        Mxp = newX;
827
                                        Myp = newY;
828
                                }
829
 
830
                                {
831
                                        double gx, gy, gh, gw;
832
                                        m_doc->m_Selection->getVisualGroupRect(&gx, &gy, &gw, &gh);
833
                                        m_doc->adjustCanvas(FPoint(gx,gy), FPoint(gx+gw, gy+gh));
834
                                        QPoint selectionCenter = m_canvas->canvasToLocal(QPointF(gx+gw/2, gy+gh/2));
835
                                        QPoint localMousePos = m_canvas->canvasToLocal(mousePointDoc);
836
                                        int localwidth = static_cast<int>(gw * m_canvas->scale());
837
                                        int localheight = static_cast<int>(gh * m_canvas->scale());
838
                                        if (localwidth > 200)
839
                                        {
840
                                                localwidth = 0;
841
                                                selectionCenter.setX(localMousePos.x());
842
                                        }
843
                                        if (localheight > 200)
844
                                        {
845
                                                localheight = 0;
846
                                                selectionCenter.setY(localMousePos.y());
847
                                        }
848
                                        m_view->ensureVisible(selectionCenter.x(), selectionCenter.y(), localwidth/2 + 20, localheight/2 + 20);
849
                                        m_canvas->repaint();
850
                                        m_canvas->displayXYHUD(m->globalPos());
851
                                }
852
                        }
853
                }
854
                if (!m_canvas->m_viewMode.m_MouseButtonPressed)
855
                {
856
                        if (m_doc->m_Selection->isMultipleSelection())
857
                        {
858
                                setModeCursor();
859
                                return;
860
                        }
861
                        for (int a = 0; a < m_doc->m_Selection->count(); ++a)
862
                        {
863
                                currItem = m_doc->m_Selection->itemAt(a);
864
                                if (currItem->locked())
865
                                        break;
13297 pierre 866
                                int hitTest = m_canvas->frameHitTest(QPointF(mousePointDoc.x(),mousePointDoc.y()), currItem);
867
                                if(hitTest >= 0)
12775 jghali 868
                                {
13297 pierre 869
                                        if((hitTest == Canvas::INSIDE))
12775 jghali 870
                                        {
871
                                                if (currItem->asTextFrame())
872
                                                        qApp->changeOverrideCursor(QCursor(Qt::IBeamCursor));
873
                                                if (currItem->asImageFrame())
874
                                                        qApp->changeOverrideCursor(QCursor(loadIcon("HandC.xpm")));
875
                                        }
13297 pierre 876
                                        else if (!currItem->sizeLocked())
877
                                        {
878
                                                setResizeCursor(hitTest, currItem->rotation());
879
                                        }
12775 jghali 880
                                }
881
                                else
882
                                {
12799 pierre 883
//                                      setModeCursor();
884
                                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
12775 jghali 885
                                }
886
                        }
887
                }
888
        }
889
        else
890
        {
891
                if ((m_canvas->m_viewMode.m_MouseButtonPressed) && (m->buttons() & Qt::LeftButton))
892
                {
893
                        newX = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
894
                        newY = qRound(mousePointDoc.y()); //m_view->translateToDoc(m->x(), m->y()).y());
895
                        SeRx = newX;
896
                        SeRy = newY;
897
                        /*
898
                        m_view->redrawMarker->setGeometry(QRect(Mxp, Myp, m->globalPos().x() - Mxp, m->globalPos().y() - Myp).normalized());
899
                        */
900
                        QPoint startP = m_canvas->canvasToGlobal(QPointF(Mxp, Myp));
901
                        m_view->redrawMarker->setGeometry(QRect(startP, m->globalPos()).normalized());
902
                        if (!m_view->redrawMarker->isVisible())
903
                                m_view->redrawMarker->show();
904
                        m_view->HaveSelRect = true;
905
                        return;
906
                }
907
        }
908
}
909
 
910
void CanvasMode_Edit::mousePressEvent(QMouseEvent *m)
911
{
912
//      const double mouseX = m->globalX();
913
//      const double mouseY = m->globalY();
914
        const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
915
 
916
        bool inText;
917
        double Rxp = 0;
918
        double Ryp = 0;
12796 pierre 919
//      Not used said gcc
920
//      double Rxpd = 0;
921
//      double Rypd = 0;
12775 jghali 922
        PageItem *currItem;
923
        m_canvas->PaintSizeRect(QRect());
924
        FPoint npf, npf2;
925
        QRect tx;
926
        QMatrix pm;
927
        m_canvas->m_viewMode.m_MouseButtonPressed = true;
928
        m_canvas->m_viewMode.operItemMoving = false;
929
        m_view->HaveSelRect = false;
930
        m_doc->DragP = false;
931
        m_doc->leaveDrag = false;
932
//      oldClip = 0;
933
        m->accept();
934
        m_view->registerMousePress(m->globalPos());
935
        Mxp = mousePointDoc.x(); //qRound(m->x()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.x());
936
        Myp = mousePointDoc.y(); //qRound(m->y()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.y());
13297 pierre 937
//      QRect mpo(m->x()-m_doc->guidesSettings.grabRad, m->y()-m_doc->guidesSettings.grabRad, m_doc->guidesSettings.grabRad*2, m_doc->guidesSettings.grabRad*2);
12775 jghali 938
//      mpo.moveBy(qRound(m_doc->minCanvasCoordinate.x() * m_canvas->scale()), qRound(m_doc->minCanvasCoordinate.y() * m_canvas->scale()));
939
        Ryp = Myp;
940
        Rxp = Mxp;
941
        SeRx = Mxp;
942
        SeRy = Myp;
943
        if (m->button() == Qt::MidButton)
944
        {
945
                m_view->MidButt = true;
13124 fschmid 946
                if (m->modifiers() & Qt::ControlModifier)
947
                        m_view->DrawNew();
12775 jghali 948
                return;
949
        }
950
 
951
        frameResizeHandle = 0;
952
        m_canvas->m_viewMode.operItemResizeInEditMode = false;
953
        int oldP=0;
954
        if (GetItem(&currItem))
955
        {
956
//              m_view->slotDoCurs(false);
957
                if (!currItem->locked() && !currItem->asLine())
958
                {
959
                        if (!resizeGesture)
960
                                resizeGesture = new ResizeGesture(this);
961
 
962
                        resizeGesture->mousePressEvent(m);
963
                        if (resizeGesture->frameHandle() > 0)
964
                        {
965
                                m_canvas->m_viewMode.operItemResizeInEditMode = true;
966
                                m_view->startGesture(resizeGesture);
967
                                return;
968
                        }
969
                        else if (resizeGesture->frameHandle() < 0)
970
                        {
971
                                m_view->Deselect(true);
972
                                if (SeleItem(m))
973
                                {
974
                                        currItem = m_doc->m_Selection->itemAt(0);
975
                                        if ((currItem->asTextFrame()) || (currItem->asImageFrame()))
13106 pierre 976
                                        {
12775 jghali 977
                                                m_view->requestMode(modeEdit);
13106 pierre 978
                                        }
12775 jghali 979
                                        else
980
                                        {
981
                                                m_view->requestMode(submodePaintingDone);
982
                                                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
983
                                        }
984
                                }
985
                                else
986
                                {
987
                                        m_view->requestMode(submodePaintingDone);
988
                                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
989
                                }
990
                                m_view->requestMode(modeNormal);
991
                                return;
992
                        }
993
                }
994
                oldP = currItem->CPos;
995
                //CB Where we set the cursor for a click in text frame
996
                if (currItem->asTextFrame())
997
                {
13297 pierre 998
                        inText = m_view->slotSetCurs(m->globalPos().x(), m->globalPos().y());
12775 jghali 999
                        //CB If we clicked outside a text frame to go out of edit mode and deselect the frame
1000
                        if (!inText)
1001
                        {
1002
                                currItem->invalidateLayout();
1003
                                m_view->Deselect(true);
1004
                                //m_view->slotDoCurs(true);
1005
                                m_view->requestMode(modeNormal);
1006
                                return;
1007
                        }
13617 pierre 1008
                        else
1009
                                currItem->asTextFrame()->deselectAll();
1010
 
13227 fschmid 1011
                        if (m->button() != Qt::RightButton)
12775 jghali 1012
                        {
13227 fschmid 1013
                                //<<CB Add in shift select to text frames
1014
                                if (m->modifiers() & Qt::ShiftModifier && currItem->itemText.lengthOfSelection() > 0)
12775 jghali 1015
                                {
13227 fschmid 1016
                                        if (currItem->CPos < (currItem->itemText.startOfSelection() + currItem->itemText.endOfSelection()) / 2)
1017
                                                oldP = currItem->itemText.startOfSelection();
1018
                                        else
1019
                                                oldP = currItem->itemText.endOfSelection();
1020
                                        currItem->asTextFrame()->itemText.extendSelection(oldP, currItem->CPos);
1021
                                        oldCp = currItem->CPos;
12775 jghali 1022
                                }
13227 fschmid 1023
                                else //>>CB
12775 jghali 1024
                                {
13227 fschmid 1025
                                        oldCp = currItem->CPos;
1026
                                        currItem->itemText.deselectAll();
1027
                                        currItem->HasSel = false;
12775 jghali 1028
                                }
13227 fschmid 1029
                                currItem->emitAllToGUI();
1030
                                if (m->button() == Qt::MidButton)
1031
                                {
1032
                                        m_canvas->m_viewMode.m_MouseButtonPressed = false;
1033
                                        m_view->MidButt = false;
1034
                                        QString cc;
1035
                                        cc = QApplication::clipboard()->text(QClipboard::Selection);
1036
                                        if (cc.isNull())
1037
                                                cc = QApplication::clipboard()->text(QClipboard::Clipboard);
1038
                                        if (!cc.isNull())
1039
                                        {
1040
                                                // K.I.S.S.:
1041
                                                currItem->itemText.insertChars(0, cc, true);
1042
                                                if (m_doc->docHyphenator->AutoCheck)
1043
                                                        m_doc->docHyphenator->slotHyphenate(currItem);
1044
                                                m_ScMW->BookMarkTxT(currItem);
1045
                                                //                                                      m_ScMW->outlinePalette->BuildTree();
1046
                                        }
1047
                                        else
1048
                                        {
1049
                                                if (ScMimeData::clipboardHasScribusText())
1050
                                                        m_ScMW->slotEditPaste();
1051
                                        }
1052
                                        currItem->update();
1053
                                }
12775 jghali 1054
                        }
1055
                }
1056
                else if (!currItem->asImageFrame() ||
1057
                                 m_canvas->frameHitTest(QPointF(mousePointDoc.x(),mousePointDoc.y()), currItem) < 0)
1058
                {
1059
                        m_view->Deselect(true);
1060
                        if (SeleItem(m))
1061
                        {
1062
                                currItem = m_doc->m_Selection->itemAt(0);
1063
                                if ((currItem->asTextFrame()) || (currItem->asImageFrame()))
13106 pierre 1064
                                {
12775 jghali 1065
                                        m_view->requestMode(modeEdit);
13106 pierre 1066
                                }
12775 jghali 1067
                                else
1068
                                {
1069
                                        m_view->requestMode(submodePaintingDone);
1070
                                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
1071
                                }
1072
                        }
1073
                        else
1074
                        {
1075
                                m_view->requestMode(submodePaintingDone);
1076
                                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
1077
                        }
1078
                }
1079
        }
1080
}
1081
 
1082
 
1083
 
1084
void CanvasMode_Edit::mouseReleaseEvent(QMouseEvent *m)
1085
{
13034 pierre 1086
#ifdef GESTURE_FRAME_PREVIEW
1087
        clearPixmapCache();
1088
#endif // GESTURE_FRAME_PREVIEW
12775 jghali 1089
        const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
1090
        PageItem *currItem;
1091
        m_canvas->m_viewMode.m_MouseButtonPressed = false;
1092
        m_canvas->resetRenderMode();
1093
        m->accept();
13285 fschmid 1094
//      m_view->stopDragTimer();
12775 jghali 1095
        if ((GetItem(&currItem)) && (m->button() == Qt::RightButton) && (!m_doc->DragP))
1096
        {
1097
                createContextMenu(currItem, mousePointDoc.x(), mousePointDoc.y());
1098
                return;
1099
        }
1100
        if (m_view->moveTimerElapsed() && (GetItem(&currItem)))
1101
        {
13285 fschmid 1102
//              m_view->stopDragTimer();
12775 jghali 1103
                m_canvas->setRenderModeUseBuffer(false);
1104
                if (!m_doc->m_Selection->isMultipleSelection())
1105
                {
1106
                        m_doc->setRedrawBounding(currItem);
1107
                        currItem->OwnPage = m_doc->OnPage(currItem);
1108
                        m_canvas->m_viewMode.operItemResizing = false;
1109
                        if (currItem->asLine())
1110
                                m_view->updateContents();
1111
                }
1112
                if (m_canvas->m_viewMode.operItemMoving)
1113
                {
1114
                        m_view->updatesOn(false);
1115
                        if (m_doc->m_Selection->isMultipleSelection())
1116
                        {
1117
                                if (!m_view->groupTransactionStarted())
1118
                                {
1119
                                        m_view->startGroupTransaction(Um::Move, "", Um::IMove);
1120
                                }
1121
                                m_doc->m_Selection->setGroupRect();
1122
                                double gx, gy, gh, gw;
1123
                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
1124
                                double nx = gx;
1125
                                double ny = gy;
1126
                                if (!m_doc->ApplyGuides(&nx, &ny))
1127
                                {
1128
                                        FPoint npx = m_doc->ApplyGridF(FPoint(gx, gy));
1129
                                        FPoint npw = m_doc->ApplyGridF(FPoint(gx+gw, gy+gh));
1130
                                        if ((fabs(gx-npx.x())) > (fabs((gx+gw)-npw.x())))
1131
                                                nx = npw.x() - gw;
1132
                                        else
1133
                                                nx = npx.x();
1134
                                        if ((fabs(gy-npx.y())) > (fabs((gy+gh)-npw.y())))
1135
                                                ny = npw.y() - gh;
1136
                                        else
1137
                                                ny = npx.y();
1138
                                }
1139
                                m_doc->moveGroup(nx-gx, ny-gy, false);
1140
                                m_doc->m_Selection->setGroupRect();
1141
                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
1142
                                nx = gx+gw;
1143
                                ny = gy+gh;
1144
                                if (m_doc->ApplyGuides(&nx, &ny))
1145
                                        m_doc->moveGroup(nx-(gx+gw), ny-(gy+gh), false);
1146
                                m_doc->m_Selection->setGroupRect();
1147
                        }
1148
                        else
1149
                        {
1150
                                currItem = m_doc->m_Selection->itemAt(0);
1151
                                if (m_doc->useRaster)
1152
                                {
1153
                                        double nx = currItem->xPos();
1154
                                        double ny = currItem->yPos();
1155
                                        if (!m_doc->ApplyGuides(&nx, &ny))
1156
                                        {
1157
                                                m_doc->m_Selection->setGroupRect();
1158
                                                double gx, gy, gh, gw;
1159
                                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
1160
                                                FPoint npx = m_doc->ApplyGridF(FPoint(gx, gy));
1161
                                                FPoint npw = m_doc->ApplyGridF(FPoint(gx+gw, gy+gh));
1162
                                                if ((fabs(gx-npx.x())) > (fabs((gx+gw)-npw.x())))
1163
                                                        nx = npw.x() - gw;
1164
                                                else
1165
                                                        nx = npx.x();
1166
                                                if ((fabs(gy-npx.y())) > (fabs((gy+gh)-npw.y())))
1167
                                                        ny = npw.y() - gh;
1168
                                                else
1169
                                                        ny = npx.y();
1170
                                        }
1171
                                        m_doc->MoveItem(nx-currItem->xPos(), ny-currItem->yPos(), currItem);
1172
                                }
1173
                                else
1174
                                        m_doc->MoveItem(0, 0, currItem, false);
1175
                        }
1176
                        m_canvas->m_viewMode.operItemMoving = false;
1177
                        if (m_doc->m_Selection->isMultipleSelection())
1178
                        {
1179
                                double gx, gy, gh, gw;
1180
                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
1181
                                FPoint maxSize(gx+gw+m_doc->scratch.Right, gy+gh+m_doc->scratch.Bottom);
1182
                                FPoint minSize(gx-m_doc->scratch.Left, gy-m_doc->scratch.Top);
1183
                                m_doc->adjustCanvas(minSize, maxSize);
1184
                        }
1185
                        m_doc->setRedrawBounding(currItem);
1186
                        currItem->OwnPage = m_doc->OnPage(currItem);
1187
                        if (currItem->OwnPage != -1)
1188
                        {
1189
                                m_doc->setCurrentPage(m_doc->Pages->at(currItem->OwnPage));
1190
                                m_view->setMenTxt(currItem->OwnPage);
1191
                        }
1192
                        //CB done with emitAllToGUI
1193
                        //emit HaveSel(currItem->itemType());
1194
                        //EmitValues(currItem);
1195
                        //CB need this for? a moved item will send its new data with the new xpos/ypos emits
1196
                        //CB TODO And what if we have dragged to a new page. Items X&Y are not updated anyway now
1197
                        //currItem->emitAllToGUI();
1198
                        m_view->updatesOn(true);
1199
                        m_view->updateContents();
1200
                }
1201
        }
1202
        //CB Drag selection performed here
1203
        if ((m_doc->m_Selection->count() == 0) && (m_view->HaveSelRect) && (!m_view->MidButt))
1204
        {
1205
                QRectF Sele = QRectF(Dxp, Dyp, SeRx-Dxp, SeRy-Dyp).normalized();
1206
                if (!m_doc->masterPageMode())
1207
                {
1208
                        uint docPagesCount=m_doc->Pages->count();
1209
                        uint docCurrPageNo=m_doc->currentPageNumber();
1210
                        for (uint i = 0; i < docPagesCount; ++i)
1211
                        {
1212
                                if (QRectF(m_doc->Pages->at(i)->xOffset(), m_doc->Pages->at(i)->yOffset(), m_doc->Pages->at(i)->width(), m_doc->Pages->at(i)->height()).intersects(Sele))
1213
                                {
1214
                                        if (docCurrPageNo != i)
1215
                                        {
1216
                                                m_doc->setCurrentPage(m_doc->Pages->at(i));
1217
                                                m_view->setMenTxt(i);
1218
                                        }
1219
                                        break;
1220
                                }
1221
                        }
1222
                        m_view->setRulerPos(m_view->contentsX(), m_view->contentsY());
1223
                }
1224
                int docItemCount=m_doc->Items->count();
1225
                if (docItemCount != 0)
1226
                {
1227
                        m_doc->m_Selection->delaySignalsOn();
1228
                        for (int a = 0; a < docItemCount; ++a)
1229
                        {
1230
                                PageItem* docItem = m_doc->Items->at(a);
1231
                                QMatrix p;
1232
                                m_canvas->Transform(docItem, p);
1233
                                QRegion apr = QRegion(docItem->Clip * p);
1234
                                QRect apr2(docItem->getRedrawBounding(1.0));
1235
                                if ((m_doc->masterPageMode()) && (docItem->OnMasterPage != m_doc->currentPage()->pageName()))
1236
                                        continue;
1237
                                if (((Sele.contains(apr.boundingRect())) || (Sele.contains(apr2))) && (docItem->LayerNr == m_doc->activeLayer()) && (!m_doc->layerLocked(docItem->LayerNr)))
1238
                                {
1239
                                        bool redrawSelection=false;
1240
                                        m_view->SelectItemNr(a, redrawSelection);
1241
                                }
1242
                        }
1243
                        m_doc->m_Selection->delaySignalsOff();
1244
                        if (m_doc->m_Selection->count() > 1)
1245
                        {
1246
                                m_doc->m_Selection->setGroupRect();
1247
                                double x, y, w, h;
1248
                                m_doc->m_Selection->getGroupRect(&x, &y, &w, &h);
1249
                                m_view->getGroupRectScreen(&x, &y, &w, &h);
1250
                        }
1251
                }
1252
                m_view->HaveSelRect = false;
1253
                m_view->redrawMarker->hide();
1254
                m_view->updateContents();
1255
        }
1256
        if (GetItem(&currItem))
1257
        {
1258
                if (m_doc->m_Selection->count() > 1)
1259
                {
1260
                        m_doc->m_Selection->setGroupRect();
1261
                        double x, y, w, h;
1262
                        m_doc->m_Selection->getGroupRect(&x, &y, &w, &h);
1263
                        m_canvas->m_viewMode.operItemMoving = false;
1264
                        m_canvas->m_viewMode.operItemResizing = false;
1265
                        m_view->updateContents(QRect(static_cast<int>(x-5), static_cast<int>(y-5), static_cast<int>(w+10), static_cast<int>(h+10)));
1266
                }
1267
                /*else
1268
                        currItem->emitAllToGUI();*/
1269
        }
1270
        m_canvas->setRenderModeUseBuffer(false);
1271
        m_doc->DragP = false;
1272
        m_doc->leaveDrag = false;
1273
        m_canvas->m_viewMode.operItemMoving = false;
1274
        m_canvas->m_viewMode.operItemResizing = false;
1275
        m_view->MidButt = false;
1276
        if (m_view->groupTransactionStarted())
1277
        {
1278
                for (int i = 0; i < m_doc->m_Selection->count(); ++i)
1279
                        m_doc->m_Selection->itemAt(i)->checkChanges(true);
1280
                m_view->endGroupTransaction();
1281
        }
1282
        for (int i = 0; i < m_doc->m_Selection->count(); ++i)
1283
                m_doc->m_Selection->itemAt(i)->checkChanges(true);
1284
        //Commit drag created items to undo manager.
1285
        if (m_doc->m_Selection->itemAt(0)!=NULL)
1286
        {
1287
                m_doc->itemAddCommit(m_doc->m_Selection->itemAt(0)->ItemNr);
1288
        }
1289
        //Make sure the Zoom spinbox and page selector dont have focus if we click on the canvas
1290
        m_view->zoomSpinBox->clearFocus();
1291
        m_view->pageSelector->clearFocus();
1292
        if (m_doc->m_Selection->itemAt(0) != 0) // is there the old clip stored for the undo action
1293
        {
1294
                currItem = m_doc->m_Selection->itemAt(0);
1295
                m_doc->nodeEdit.finishTransaction(currItem);
1296
        }
1297
}
1298
 
1299
//CB-->Doc/Fix
1300
bool CanvasMode_Edit::SeleItem(QMouseEvent *m)
1301
{
1302
        const unsigned SELECT_IN_GROUP = Qt::AltModifier;
1303
        const unsigned SELECT_MULTIPLE = Qt::ShiftModifier;
1304
        const unsigned SELECT_BENEATH = Qt::ControlModifier;
1305
        QMatrix p;
1306
        QRectF tx, mpo;
1307
        PageItem *currItem;
1308
        m_canvas->m_viewMode.m_MouseButtonPressed = true;
1309
        FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
1310
        Mxp = mousePointDoc.x(); //m->x()/m_canvas->scale());
1311
        Myp = mousePointDoc.y(); //m->y()/m_canvas->scale());
1312
        double grabRadius = m_doc->guidesSettings.grabRad / m_canvas->scale();
1313
        int MxpS = static_cast<int>(mousePointDoc.x()); //m->x()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.x());
1314
        int MypS = static_cast<int>(mousePointDoc.y()); //m->y()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.y());
1315
        mpo = QRectF(Mxp-grabRadius, Myp-grabRadius, grabRadius*2, grabRadius*2);
1316
//      mpo.translate(m_doc->minCanvasCoordinate.x() * m_canvas->scale(), m_doc->minCanvasCoordinate.y() * m_canvas->scale());
1317
        m_doc->nodeEdit.deselect();
1318
//      int a;
1319
        if (!m_doc->masterPageMode())
1320
        {
1321
                int pgNum = -1;
1322
                int docPageCount = static_cast<int>(m_doc->Pages->count() - 1);
1323
                MarginStruct pageBleeds;
1324
                bool drawBleed = false;
1325
                if (m_doc->bleeds.hasNonZeroValue() && m_doc->guidesSettings.showBleed)
1326
                        drawBleed = true;
1327
                for (int a = docPageCount; a > -1; a--)
1328
                {
1329
                        if (drawBleed)
1330
                                m_doc->getBleeds(a, pageBleeds);
1331
                        int x = static_cast<int>(m_doc->Pages->at(a)->xOffset() - pageBleeds.Left);
1332
                        int y = static_cast<int>(m_doc->Pages->at(a)->yOffset() - pageBleeds.Top);
1333
                        int w = static_cast<int>(m_doc->Pages->at(a)->width() + pageBleeds.Left + pageBleeds.Right);
1334
                        int h = static_cast<int>(m_doc->Pages->at(a)->height() + pageBleeds.Bottom + pageBleeds.Top);
1335
                        if (QRect(x, y, w, h).contains(MxpS, MypS))
1336
                        {
1337
                                pgNum = static_cast<int>(a);
1338
                                if (drawBleed)  // check again if its really on the correct page
1339
                                {
1340
                                        for (int a2 = docPageCount; a2 > -1; a2--)
1341
                                        {
1342
                                                int xn = static_cast<int>(m_doc->Pages->at(a2)->xOffset());
1343
                                                int yn = static_cast<int>(m_doc->Pages->at(a2)->yOffset());
1344
                                                int wn = static_cast<int>(m_doc->Pages->at(a2)->width());
1345
                                                int hn = static_cast<int>(m_doc->Pages->at(a2)->height());
1346
                                                if (QRect(xn, yn, wn, hn).contains(MxpS, MypS))
1347
                                                {
1348
                                                        pgNum = static_cast<int>(a2);
1349
                                                        break;
1350
                                                }
1351
                                        }
1352
                                }
1353
                                break;
1354
                        }
1355
                }
1356
                if (pgNum >= 0)
1357
                {
1358
                        if (m_doc->currentPageNumber() != pgNum)
1359
                        {
1360
                                m_doc->setCurrentPage(m_doc->Pages->at(unsigned(pgNum)));
1361
                                m_view->setMenTxt(unsigned(pgNum));
1362
                                m_view->DrawNew();
1363
                        }
1364
                }
1365
                m_view->setRulerPos(m_view->contentsX(), m_view->contentsY());
1366
        }
1367
 
1368
        currItem = NULL;
1369
        if ((m->modifiers() & SELECT_BENEATH) != 0)
1370
        {
1371
                for (int i=0; i < m_doc->m_Selection->count(); ++i)
1372
                {
1373
                        if (m_canvas->frameHitTest(QPointF(mousePointDoc.x(),mousePointDoc.y()), m_doc->m_Selection->itemAt(i)) >= 0)
1374
                        {
1375
                                currItem = m_doc->m_Selection->itemAt(i);
1376
//                              qDebug() << "select item: found BENEATH" << currItem << "groups" << currItem->Groups.count();
1377
                                if (currItem->Groups.count() > 0)
1378
                                {
1379
                                        m_doc->m_Selection->delaySignalsOn();
1380
                                        for (int ga=0; ga<m_doc->Items->count(); ++ga)
1381
                                        {
1382
                                                PageItem* item = m_doc->Items->at(ga);
1383
                                                if (item->Groups.count() != 0)
1384
                                                {
1385
                                                        if (item->Groups.top() == currItem->Groups.top())
1386
                                                        {
1387
                                                                if (m_doc->m_Selection->findItem(item) >= 0)
1388
                                                                {
1389
                                                                        m_doc->m_Selection->removeItem(item);
1390
                                                                }
1391
                                                        }
1392
                                                }
1393
                                        }
1394
                                        m_doc->m_Selection->delaySignalsOff();
1395
                                }
1396
                                else
1397
                                {
1398
                                        m_doc->m_Selection->removeItem(currItem);
1399
                                }
1400
                                break;
1401
                        }
1402
//                      else
1403
//                              qDebug() << "select item: not BENEATH" << QPointF(mousePointDoc.x(),mousePointDoc.y()) 
1404
//                                      << m_doc->m_Selection->itemAt(i)->getTransform() 
1405
//                                      << m_doc->m_Selection->itemAt(i)->getBoundingRect();
1406
                }
1407
        }
1408
        else if ( (m->modifiers() & SELECT_MULTIPLE) == Qt::NoModifier)
1409
        {
1410
                m_view->Deselect(false);
1411
        }
1412
 
1413
//      qDebug() << "select item: beneath" << (m->modifiers() & SELECT_BENEATH) << currItem 
1414
//              << "multi" << (m->modifiers() & SELECT_MULTIPLE)
1415
//              << "current sel" << m_doc->m_Selection->count();
1416
        currItem = m_canvas->itemUnderCursor(m->globalPos(), currItem, (m->modifiers() & SELECT_IN_GROUP));
1417
//      qDebug() << "item under cursor: " << currItem;
1418
        if (currItem)
1419
        {
1420
                m_doc->m_Selection->delaySignalsOn();
1421
                if (m_doc->m_Selection->containsItem(currItem))
1422
                {
1423
                        m_doc->m_Selection->removeItem(currItem);
1424
                }
1425
                else
1426
                {
1427
                        //CB: If we have a selection but the user clicks with control on another item that is not below the current
1428
                        //then clear and select the new item
1429
                        if ((m->modifiers() == SELECT_BENEATH) && m_canvas->frameHitTest(QPointF(mousePointDoc.x(),mousePointDoc.y()), currItem) >= 0)
1430
                                m_doc->m_Selection->clear();
1431
                        //CB: #7186: This was prependItem, does not seem to need to be anymore with current select code
1432
                        m_doc->m_Selection->addItem(currItem);
1433
                        if ( (m->modifiers() & SELECT_IN_GROUP) && (!currItem->isGroupControl))
1434
                        {
1435
                                currItem->isSingleSel = true;
1436
                        }
1437
                        else if (currItem->Groups.count() > 0)
1438
                        {
1439
                                for (int ga=0; ga<m_doc->Items->count(); ++ga)
1440
                                {
1441
                                        PageItem* item = m_doc->Items->at(ga);
1442
                                        if (item->Groups.count() != 0)
1443
                                        {
1444
                                                if (item->Groups.top() == currItem->Groups.top())
1445
                                                {
1446
                                                        if (item->ItemNr != currItem->ItemNr)
1447
                                                        {
1448
                                                                if (m_doc->m_Selection->findItem(item) == -1)
1449
                                                                {
1450
                                                                        m_doc->m_Selection->addItem(item, true);
1451
                                                                }
1452
                                                        }
1453
                                                        item->isSingleSel = false;
1454
                                                }
1455
                                        }
1456
                                }
1457
                        }
1458
                }
1459
 
13132 pierre 1460
//              currItem->update();
1461
                m_canvas->update();
12775 jghali 1462
                m_doc->m_Selection->delaySignalsOff();
1463
                if (m_doc->m_Selection->count() > 1)
1464
                {
13132 pierre 1465
//                      for (int aa = 0; aa < m_doc->m_Selection->count(); ++aa)
1466
//                      {
1467
//                              PageItem *bb = m_doc->m_Selection->itemAt(aa);
1468
//                              bb->update();
1469
//                      }
12775 jghali 1470
                        m_doc->m_Selection->setGroupRect();
1471
                        double x, y, w, h;
1472
                        m_doc->m_Selection->getGroupRect(&x, &y, &w, &h);
1473
                        //                                      emit ItemPos(x, y);
1474
                        //                                      emit ItemGeom(w, h);
1475
                        m_view->getGroupRectScreen(&x, &y, &w, &h);
1476
                        //                                      m_view->updateContents(QRect(static_cast<int>(x-5), static_cast<int>(y-5), static_cast<int>(w+10), static_cast<int>(h+10)));
1477
                        //                                      emit HaveSel(currItem->itemType());
1478
                }
1479
                if (m_doc->m_Selection->count() == 1)
1480
                {
1481
                        frameResizeHandle = m_canvas->frameHitTest(QPointF(mousePointDoc.x(),mousePointDoc.y()), currItem);
1482
                        if ((frameResizeHandle == Canvas::INSIDE) && (!currItem->locked()))
1483
                                qApp->changeOverrideCursor(QCursor(Qt::SizeAllCursor));
1484
                }
1485
                else
1486
                {
1487
                        qApp->changeOverrideCursor(QCursor(Qt::SizeAllCursor));
1488
                        m_canvas->m_viewMode.operItemResizing = false;
1489
                }
1490
                return true;
1491
        }
1492
 
1493
        //m_doc->m_Selection->setIsGUISelection(true);
1494
        m_doc->m_Selection->connectItemToGUI();
1495
        if ( !(m->modifiers() & SELECT_MULTIPLE))
1496
                m_view->Deselect(true);
1497
        return false;
1498
}
1499
 
12799 pierre 1500
// void CanvasMode_Edit::setResizeCursor(int how, double rot)
1501
// {
1502
//      switch (how)
1503
//      {
1504
//              case 1:
1505
//              case 2:
1506
//                      qApp->changeOverrideCursor(ScResizeCursor(135 + rot));
1507
//                      break;
1508
//              case 3:
1509
//              case 4:
1510
//                      qApp->changeOverrideCursor(ScResizeCursor(45 + rot));
1511
//                      break;
1512
//              case 5:
1513
//              case 8:
1514
//                      qApp->changeOverrideCursor(ScResizeCursor(0 + rot));
1515
//                      break;
1516
//              case 6:
1517
//              case 7:
1518
//                      qApp->changeOverrideCursor(ScResizeCursor(90 + rot));
1519
//                      break;
1520
//              default:
1521
//                      qApp->changeOverrideCursor(QCursor(Qt::SizeAllCursor));
1522
//                      break;
1523
//      }
1524
// }
12775 jghali 1525
 
1526
void CanvasMode_Edit::createContextMenu(PageItem* currItem, double mx, double my)
1527
{
1528
        ContextMenu* cmen=NULL;
1529
        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
1530
        m_view->setObjectUndoMode();
1531
        Mxp = mx;
1532
        Myp = my;
1533
        if(currItem!=NULL)
1534
                cmen = new ContextMenu(*(m_doc->m_Selection), m_ScMW, m_doc);
1535
        else
1536
                cmen = new ContextMenu(m_ScMW, m_doc, mx, my);
1537
        if (cmen)
1538
                cmen->exec(QCursor::pos());
1539
        m_view->setGlobalUndoMode();
1540
        delete cmen;
1541
}