Subversion Repositories Scribus

Rev

Rev 13297 | 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
                        {
394
                                currItem->itemText.deselectAll();
395
                                currItem->HasSel = false;
13297 pierre 396
                                m_view->slotSetCurs(m->globalPos().x(), m->globalPos().y());
12775 jghali 397
                                //Make sure we dont go here if the old cursor position was not set
398
                                if (oldCp!=-1 && currItem->itemText.length() > 0)
399
                                {
400
                                        if (currItem->CPos < oldCp)
401
                                        {
402
                                                currItem->itemText.select(currItem->CPos, oldCp - currItem->CPos);
403
                                                currItem->HasSel = true;
404
                                        }
405
                                        if (currItem->CPos > oldCp)
406
                                        {
407
                                                currItem->itemText.select(oldCp, currItem->CPos - oldCp);
408
                                                currItem->HasSel = true;
409
                                        }
410
                                }
13132 pierre 411
//                              currItem->update();
12775 jghali 412
                                if(currItem->HasSel)
13132 pierre 413
                                {
12775 jghali 414
                                        m_ScMW->EnableTxEdit();
13132 pierre 415
                                        m_canvas->m_viewMode.operTextSelecting = true;
416
                                }
12775 jghali 417
                                else
418
                                        m_ScMW->DisableTxEdit();
13289 jghali 419
                                m_canvas->update();
12775 jghali 420
                        }
421
                }
422
                //Operations run here:
423
                //Item resize, esp after creating a new one
424
                if (m_view->moveTimerElapsed() && m_canvas->m_viewMode.m_MouseButtonPressed && (m->buttons() & Qt::LeftButton) &&
425
                        ((m_doc->appMode == modeEdit) && m_canvas->m_viewMode.operItemResizeInEditMode) && (!currItem->locked()))
426
                {
13285 fschmid 427
//                      m_view->stopDragTimer();
12775 jghali 428
                        if (m_canvas->m_viewMode.operItemResizing)
429
                        {
430
//                              newX = static_cast<int>(m->x()/sc);
431
//                              newY = static_cast<int>(m->y()/sc);
432
                                m_canvas->m_viewMode.operItemMoving = false;
433
                                if (m_doc->m_Selection->isMultipleSelection())
434
                                {
12858 pierre 435
//                                      qDebug()<<"Resizing multiple selection"<<frameResizeHandle;
12775 jghali 436
//                                      newX = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
437
//                                      newY = qRound(mousePointDoc.y()); //m_view->translateToDoc(m->x(), m->y()).y());
438
                                        double gx, gy, gh, gw;
439
                                        m_doc->m_Selection->getVisualGroupRect(&gx, &gy, &gw, &gh);
440
                                        const double sc=1;
441
                                        int ox1 = qRound(gx*sc);
442
                                        int oy1 = qRound(gy*sc);
443
                                        int ox2 = qRound((gx+gw)*sc);
444
                                        int oy2 = qRound((gy+gh)*sc);
445
                                        FPoint np2 = FPoint(newX, newY);
446
                                        np2 = m_doc->ApplyGridF(mousePointDoc);
447
                                        double nx = np2.x();
448
                                        double ny = np2.y();
449
                                        m_doc->ApplyGuides(&nx, &ny);
450
                                        np2 = FPoint(qRound(nx*sc), qRound(ny*sc));
451
                                        QMatrix pm;
452
                                        switch (frameResizeHandle)
453
                                        {
454
                                        case 1:
455
                                                if (m->modifiers() & Qt::ControlModifier)
456
                                                        np2 = FPoint(qRound(newX), qRound(gy+(gh * ((newX-gx) / gw))));
457
                                                else
458
                                                        np2 = FPoint(qRound(newX), qRound(newY));
459
                                                np2 = m_doc->ApplyGridF(np2);
460
                                                nx = np2.x();
461
                                                ny = np2.y();
462
                                                m_doc->ApplyGuides(&nx, &ny);
463
                                                np2 = FPoint(qRound(nx*sc), qRound(ny*sc));
464
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(qRound(gx*sc), qRound(gy*sc)), QPoint(qRound(np2.x()), qRound(np2.y())))));
465
                                                break;
466
                                        case 2:
467
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(qRound(np2.x()), qRound(np2.y())), QPoint(ox2,oy2))));
468
                                                break;
469
                                        case 3:
470
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(qRound(np2.x()), qRound(np2.y())), QPoint(ox1, oy2))));
471
                                                break;
472
                                        case 4:
473
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(qRound(np2.x()), qRound(np2.y())), QPoint(ox2, oy1))));
474
                                                break;
475
                                        case 5:
476
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(ox1, oy1), QPoint(ox2, qRound(np2.y())))));
477
                                                break;
478
                                        case 6:
479
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(qRound(np2.x()), oy2), QPoint(ox1,oy1))));
480
                                                break;
481
                                        case 7:
482
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(qRound(np2.x()), oy1), QPoint(ox2, oy2))));
483
                                                break;
484
                                        case 8:
485
                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(ox1, qRound(qRound(np2.y()))), QPoint(ox2, oy2))));
486
                                                break;
487
                                        }
488
                                        Mxp = qRound(np2.x());
489
                                        Myp = qRound(np2.y());
490
                                }
491
                                else
492
                                {
12858 pierre 493
//                                      qDebug()<<"frameResizeHandle"<<frameResizeHandle;
12775 jghali 494
                                        for (int a = 0; a < m_doc->m_Selection->count(); ++a)
495
                                        {
496
                                                currItem = m_doc->m_Selection->itemAt(0);
497
                                                double nh = currItem->height();
498
                                                if ((frameResizeHandle == 1) || (frameResizeHandle == 2))
499
                                                {
500
                                                        QMatrix mp;
501
                                                        switch (frameResizeHandle)
502
                                                        {
503
                                                        case 1:
504
//                                                              mp.translate(-m_doc->minCanvasCoordinate.x() * m_canvas->scale(),-m_doc->minCanvasCoordinate.y() * m_canvas->scale());
505
                                                                m_canvas->Transform(currItem, mp);
506
                                                                //Shift proportional square resize
507
                                                                if ((m->modifiers() & Qt::ShiftModifier) && (!(m->modifiers() & Qt::ControlModifier)))
508
                                                                {
509
                                                                        QMatrix ma;
510
                                                                        ma.translate(currItem->xPos(), currItem->yPos());
511
                                                                        ma.rotate(currItem->rotation());
512
                                                                        ma = ma.inverted();
513
                                                                        nh = ma.m11() * newX + ma.m21() * newY + ma.dx();
514
                                                                        mop = QPoint(m->x(), m->y());
515
                                                                }
516
                                                                else
517
                                                                {
518
                                                                        //Control proportional resize
519
                                                                        if ((m->modifiers() & Qt::ControlModifier) && (!(m->modifiers() & Qt::ShiftModifier)))
520
                                                                        {
521
                                                                                QMatrix ma;
522
                                                                                ma.translate(currItem->xPos(), currItem->yPos());
523
                                                                                ma.rotate(currItem->rotation());
524
                                                                                ma = ma.inverted();
525
                                                                                double nX = ma.m11() * newX + ma.m21() * newY + ma.dx();
526
                                                                                nh = nX / currItem->OldB2 * currItem->OldH2;
527
                                                                                mop = QPoint(m->x(), m->y());
528
                                                                        }
529
                                                                        else
530
                                                                                mop = QPoint(m->x(), m->y());
531
                                                                }
532
                                                                np = mop * mp.inverted();
533
                                                                nx = np.x();
534
                                                                ny = np.y();
535
                                                                if (!currItem->asLine())
536
                                                                {
537
                                                                        if ((m_doc->useRaster) && (m_doc->OnPage(currItem) != -1))
538
                                                                        {
539
                                                                                nx += currItem->xPos();
540
                                                                                ny += currItem->yPos();
541
                                                                                npf = m_doc->ApplyGridF(FPoint(nx, ny));
542
                                                                                nx = npf.x() - currItem->xPos();
543
                                                                                ny = npf.y() - currItem->yPos();
544
                                                                        }
545
                                                                        if (m_doc->SnapGuides)
546
                                                                        {
547
                                                                                nx += currItem->xPos();
548
                                                                                ny += currItem->yPos();
549
                                                                                m_doc->ApplyGuides(&nx, &ny);
550
                                                                                nx -= currItem->xPos();
551
                                                                                ny -= currItem->yPos();
552
                                                                        }
553
                                                                        if ((m->modifiers() & Qt::ControlModifier) || ((m->modifiers() & Qt::ShiftModifier)))
554
                                                                                erf = m_doc->SizeItem(nx, nh, currItem->ItemNr);
555
                                                                        else
556
                                                                                erf = m_doc->SizeItem(nx, ny, currItem->ItemNr);
557
                                                                        QMatrix mp;
558
                                                                        mp.translate(currItem->xPos(),// - m_doc->minCanvasCoordinate.x(), 
559
                                                                                                 currItem->yPos());// - m_doc->minCanvasCoordinate.y());
560
                                                                        mp.rotate(currItem->rotation());
561
                                                                        np2 = QPoint(qRound(nx), qRound(ny));
562
                                                                        QMatrix pm;
563
                                                                        m_canvas->Transform(currItem, pm);
564
                                                                        m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(0, 0), np2)));
565
                                                                }
566
                                                                else
567
                                                                {
568
                                                                        double rba = currItem->rotation();
569
                                                                        currItem->setRotation(0.0);
570
                                                                        QMatrix mp;
571
                                                                        m_canvas->Transform(currItem, mp);
572
//                                                                      mp.translate(-m_doc->minCanvasCoordinate.x(), -m_doc->minCanvasCoordinate.y());
573
                                                                        np = QPoint(m->x(), m->y()) * mp.inverted();
574
                                                                        double sizeItemX=np.x(), sizeItemY=np.y();
575
                                                                        //Constrain rotation angle, when the mouse is moving the non-origin point of a line
576
                                                                        if (m->modifiers() & Qt::ControlModifier)
577
                                                                        {
578
                                                                                double newRot=xy2Deg(np.x(), np.y());
579
                                                                                rba=constrainAngle(newRot, m_doc->toolSettings.constrain);
580
                                                                                double hlen=sqrt(pow(newX - currItem->xPos(),2)+pow(newY - currItem->yPos(),2));
581
                                                                                sizeItemX = hlen * cos(rba/(180.0/M_PI));
582
                                                                                sizeItemY = hlen * sin(rba/(180.0/M_PI));
583
                                                                        }
584
                                                                        currItem->setRotation(rba);
585
                                                                        np = m_doc->ApplyGrid(np);
586
                                                                        erf = m_doc->SizeItem(sizeItemX, sizeItemY, currItem->ItemNr);
587
                                                                        QMatrix pm;
588
//                                                                      pm.translate(-m_doc->minCanvasCoordinate.x() * m_canvas->scale(),-m_doc->minCanvasCoordinate.y() * m_canvas->scale());
589
                                                                        m_canvas->Transform(currItem, pm);
590
                                                                        m_canvas->newRedrawPolygon() << pm.map(QPoint(0, 0)) << pm.map(QPoint(qRound(currItem->width()), qRound(currItem->height())));
591
                                                                        m_view->updateContents(QRect(pm.map(QPoint(0, 0)), pm.map(QPoint(qRound(currItem->width()), qRound(currItem->height())))).normalized().adjusted(-10, -10, 20, 20));
592
                                                                }
593
                                                                break;
594
                                                        case 2:
595
                                                                if (currItem->asLine())
596
                                                                {
597
                                                                        double sav = m_doc->SnapGuides;
598
                                                                        npf2 = FPoint(newX-Mxp, newY-Myp);
599
                                                                        //Constrain rotation on left point move, disabled for now in movesizeitem
600
                                                                        erf = m_doc->MoveSizeItem(npf2, FPoint(0, 0), currItem->ItemNr, false, (m->modifiers() & Qt::ControlModifier));
601
                                                                        m_doc->SnapGuides = sav;
602
                                                                        if (sav)
603
                                                                                currItem->Sizing = true;
604
                                                                        QMatrix pm;
605
//                                                                      pm.translate(-m_doc->minCanvasCoordinate.x() * m_canvas->scale(),-m_doc->minCanvasCoordinate.y() * m_canvas->scale());
606
                                                                        m_canvas->Transform(currItem, pm);
607
                                                                        m_canvas->newRedrawPolygon() << pm.map(QPoint(0, 0)) << pm.map(QPoint(qRound(currItem->width()), qRound(currItem->height())));
608
                                                                        m_view->updateContents(QRect(pm.map(QPoint(0, 0)), pm.map(QPoint(qRound(currItem->width()), qRound(currItem->height())))).normalized().adjusted(-10, -10, 20, 20));
609
                                                                }
610
                                                                else
611
                                                                {
612
                                                                        newX = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
613
                                                                        newY = qRound(mousePointDoc.y()); //m_view->translateToDoc(m->x(), m->y()).y());
614
//                                                                      np2 = QPoint(newX, newY);
615
                                                                        FPoint newP = m_doc->ApplyGridF(FPoint(newX, newY));
616
                                                                        double nx = newP.x();
617
                                                                        double ny = newP.y();
618
                                                                        m_doc->ApplyGuides(&nx, &ny);
619
                                                                        QMatrix mp;
620
//                                                                      mp.translate(currItem->xPos() - m_doc->minCanvasCoordinate.x(), currItem->yPos() - m_doc->minCanvasCoordinate.y());
621
                                                                        mp.rotate(currItem->rotation());
622
                                                                        np2 = QPoint(qRound(nx), qRound(ny)) * mp.inverted();
623
                                                                        QMatrix pm;
624
                                                                        m_canvas->Transform(currItem, pm);
625
                                                                        m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(np2, QPoint(qRound(currItem->width()), qRound(currItem->height())))));
626
                                                                }
627
                                                                break;
628
                                                        }
629
                                                }
630
                                                else
631
                                                {
632
//                                                      np2 = QPoint(newX, newY);
633
                                                        FPoint newP = m_doc->ApplyGridF(FPoint(newX, newY));
634
                                                        double nx = newP.x();
635
                                                        double ny = newP.y();
636
                                                        m_doc->ApplyGuides(&nx, &ny);
637
                                                        QMatrix mp;
638
//                                                      mp.translate(currItem->xPos() - m_doc->minCanvasCoordinate.x(), currItem->yPos() - m_doc->minCanvasCoordinate.y());
639
                                                        mp.rotate(currItem->rotation());
640
                                                        np2 = QPoint(qRound(nx), qRound(ny)) * mp.inverted();
641
                                                        QMatrix pm;
642
                                                        m_canvas->Transform(currItem, pm);
643
                                                        switch (frameResizeHandle)
644
                                                        {
645
                                                        case 0:
646
                                                                break;
647
                                                        case 3:
648
                                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(np2, QPoint(0, qRound(currItem->height())))));
649
                                                                break;
650
                                                        case 4:
651
                                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(np2, QPoint(qRound(currItem->width()), 0))));
652
                                                                break;
653
                                                        case 5:
654
                                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(0, 0), QPoint(qRound(currItem->width()), np2.y()))));
655
                                                                break;
656
                                                        case 6:
657
                                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(0, 0), QPoint(np2.x(), qRound(currItem->height())))));
658
                                                                break;
659
                                                        case 7:
660
                                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(np2.x(), 0), QPoint(qRound(currItem->width()), qRound(currItem->height())))));
661
                                                                break;
662
                                                        case 8:
663
                                                                m_canvas->PaintSizeRect(pm.mapToPolygon(QRect(QPoint(0, np2.y()), QPoint(qRound(currItem->width()), qRound(currItem->height())))));
664
                                                                break;
665
                                                        }
666
                                                }
667
                                        }
668
                                }
669
                                if ((erf) || (frameResizeHandle > 1))
670
                                {
671
                                        Mxp = newX;
672
                                        Myp = newY;
673
                                }
674
                        }
675
                        else
676
                        {
677
                                //Dragging an item (plus more?)
678
                                QRectF newPlace;
679
                                newX = mousePointDoc.x(); //static_cast<int>(m->x()/sc);
680
                                newY = mousePointDoc.y(); //static_cast<int>(m->y()/sc);
681
                                m_canvas->m_viewMode.operItemMoving = true;
682
                                erf = false;
683
                                int dX=qRound(newX-Mxp), dY=qRound(newY-Myp);
684
                                if (!m_doc->m_Selection->isMultipleSelection())
685
                                {
686
                                        erf=true;
687
                                        currItem = m_doc->m_Selection->itemAt(0);
688
                                        //Control Alt drag image in frame without being in edit mode
689
                                        if ((currItem->asImageFrame()) && (m->modifiers() & Qt::ControlModifier) && (m->modifiers() & Qt::AltModifier))
690
                                        {
691
                                                currItem->moveImageInFrame(dX/currItem->imageXScale(),dY/currItem->imageYScale());
692
                                                m_view->updateContents(currItem->getRedrawBounding(m_canvas->scale()));
693
 
694
                                        }
695
                                        else
696
                                        {
697
                                                //Dragging orthogonally - Ctrl Drag
698
                                                if ((m->modifiers() & Qt::ControlModifier) && !(m->modifiers() & Qt::ShiftModifier) && !(m->modifiers() & Qt::AltModifier))
699
                                                {
700
                                                        if (abs(dX) > abs(dY))
701
                                                                dY=0;
702
                                                        else
703
                                                        if (abs(dY) > abs(dX))
704
                                                                dX=0;
705
                                                        erf=false;
706
                                                        dX+=qRound(dragConstrainInitPtX-currItem->xPos());
707
                                                        dY+=qRound(dragConstrainInitPtY-currItem->yPos());
708
                                                }
709
                                                if (!(currItem->isTableItem && currItem->isSingleSel))
710
                                                {
711
                                                        if (!m_view->groupTransactionStarted())
712
                                                        {
713
                                                                m_view->startGroupTransaction(Um::Move, "", Um::IMove);
714
                                                        }
715
                                                        double gx, gy, gh, gw;
716
                                                        m_doc->moveGroup(dX, dY, false);
717
                                                        m_doc->m_Selection->setGroupRect();
718
                                                        m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
719
                                                        if (m_doc->SnapGuides)
720
                                                        {
721
                                                                double nx = gx;
722
                                                                double ny = gy;
723
                                                                m_doc->ApplyGuides(&nx, &ny);
724
                                                                m_doc->moveGroup(nx-gx, ny-gy, false);
725
                                                                m_doc->m_Selection->setGroupRect();
726
                                                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
727
                                                                nx = gx+gw;
728
                                                                ny = gy+gh;
729
                                                                m_doc->ApplyGuides(&nx, &ny);
730
                                                                m_doc->moveGroup(nx-(gx+gw), ny-(gy+gh), false);
731
                                                        }
732
                                                        if (m_doc->useRaster)
733
                                                        {
734
                                                                m_doc->m_Selection->setGroupRect();
735
                                                                double gx, gy, gh, gw, gxo, gyo;
736
                                                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
737
                                                                gxo = gx;
738
                                                                gyo = gy;
739
                                                                FPoint npx = m_doc->ApplyGridF(FPoint(gx, gy));
740
                                                                FPoint npw = m_doc->ApplyGridF(FPoint(gx+gw, gy+gh));
741
                                                                if ((fabs(gx-npx.x())) > (fabs((gx+gw)-npw.x())))
742
                                                                        gx = npw.x() - gw;
743
                                                                else
744
                                                                        gx = npx.x();
745
                                                                if ((fabs(gy-npx.y())) > (fabs((gy+gh)-npw.y())))
746
                                                                        gy = npw.y() - gh;
747
                                                                else
748
                                                                        gy = npx.y();
749
                                                                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()))
750
                                                                        m_doc->moveGroup(gx-gxo, gy-gyo, false);
751
                                                        }
752
                                                }
753
                                        }
754
                                }
755
                                else
756
                                {
757
                                        if (!m_view->groupTransactionStarted())
758
                                        {
759
                                                m_view->startGroupTransaction(Um::Move, "", Um::IMove);
760
                                        }
761
                                        double gx, gy, gh, gw;
762
                                        m_doc->m_Selection->setGroupRect();
763
                                        m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
764
                                        int dX=qRound(newX-Mxp), dY=qRound(newY-Myp);
765
                                        erf = true;
766
                                        if (m->modifiers() & Qt::ControlModifier)
767
                                        {
768
                                                if (abs(dX)>abs(dY))
769
                                                        dY=0;
770
                                                else
771
                                                if (abs(dY)>abs(dX))
772
                                                        dX=0;
773
                                                erf=false;
774
                                                dX+=dragConstrainInitPtX-qRound(gx);
775
                                                dY+=dragConstrainInitPtY-qRound(gy);
776
                                        }
777
                                        m_doc->moveGroup(dX, dY, false);
778
                                        m_doc->m_Selection->setGroupRect();
779
                                        m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
780
                                        if (m_doc->SnapGuides)
781
                                        {
782
                                                double nx = gx;
783
                                                double ny = gy;
784
                                                m_doc->ApplyGuides(&nx, &ny);
785
                                                m_doc->moveGroup(nx-gx, ny-gy, false);
786
                                                m_doc->m_Selection->setGroupRect();
787
                                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
788
                                                nx = gx+gw;
789
                                                ny = gy+gh;
790
                                                m_doc->ApplyGuides(&nx, &ny);
791
                                                m_doc->moveGroup(nx-(gx+gw), ny-(gy+gh), false);
792
                                        }
793
                                        m_doc->m_Selection->setGroupRect();
794
                                        if (m_doc->useRaster)
795
                                        {
796
                                                m_doc->m_Selection->setGroupRect();
797
                                                double gx, gy, gh, gw, gxo, gyo;
798
                                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
799
                                                gxo = gx;
800
                                                gyo = gy;
801
                                                FPoint npx = m_doc->ApplyGridF(FPoint(gx, gy));
802
                                                FPoint npw = m_doc->ApplyGridF(FPoint(gx+gw, gy+gh));
803
                                                if ((fabs(gx-npx.x())) > (fabs((gx+gw)-npw.x())))
804
                                                        gx = npw.x() - gw;
805
                                                else
806
                                                        gx = npx.x();
807
                                                if ((fabs(gy-npx.y())) > (fabs((gy+gh)-npw.y())))
808
                                                        gy = npw.y() - gh;
809
                                                else
810
                                                        gy = npx.y();
811
                                                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()))
812
                                                        m_doc->moveGroup(gx-gxo, gy-gyo, false);
813
                                                m_doc->m_Selection->setGroupRect();
814
                                        }
815
                                }
816
                                if (erf)
817
                                {
818
                                        Mxp = newX;
819
                                        Myp = newY;
820
                                }
821
 
822
                                {
823
                                        double gx, gy, gh, gw;
824
                                        m_doc->m_Selection->getVisualGroupRect(&gx, &gy, &gw, &gh);
825
                                        m_doc->adjustCanvas(FPoint(gx,gy), FPoint(gx+gw, gy+gh));
826
                                        QPoint selectionCenter = m_canvas->canvasToLocal(QPointF(gx+gw/2, gy+gh/2));
827
                                        QPoint localMousePos = m_canvas->canvasToLocal(mousePointDoc);
828
                                        int localwidth = static_cast<int>(gw * m_canvas->scale());
829
                                        int localheight = static_cast<int>(gh * m_canvas->scale());
830
                                        if (localwidth > 200)
831
                                        {
832
                                                localwidth = 0;
833
                                                selectionCenter.setX(localMousePos.x());
834
                                        }
835
                                        if (localheight > 200)
836
                                        {
837
                                                localheight = 0;
838
                                                selectionCenter.setY(localMousePos.y());
839
                                        }
840
                                        m_view->ensureVisible(selectionCenter.x(), selectionCenter.y(), localwidth/2 + 20, localheight/2 + 20);
841
                                        m_canvas->repaint();
842
                                        m_canvas->displayXYHUD(m->globalPos());
843
                                }
844
                        }
845
                }
846
                if (!m_canvas->m_viewMode.m_MouseButtonPressed)
847
                {
848
                        if (m_doc->m_Selection->isMultipleSelection())
849
                        {
850
                                setModeCursor();
851
                                return;
852
                        }
853
                        for (int a = 0; a < m_doc->m_Selection->count(); ++a)
854
                        {
855
                                currItem = m_doc->m_Selection->itemAt(a);
856
                                if (currItem->locked())
857
                                        break;
13297 pierre 858
                                int hitTest = m_canvas->frameHitTest(QPointF(mousePointDoc.x(),mousePointDoc.y()), currItem);
859
                                if(hitTest >= 0)
12775 jghali 860
                                {
13297 pierre 861
                                        if((hitTest == Canvas::INSIDE))
12775 jghali 862
                                        {
863
                                                if (currItem->asTextFrame())
864
                                                        qApp->changeOverrideCursor(QCursor(Qt::IBeamCursor));
865
                                                if (currItem->asImageFrame())
866
                                                        qApp->changeOverrideCursor(QCursor(loadIcon("HandC.xpm")));
867
                                        }
13297 pierre 868
                                        else if (!currItem->sizeLocked())
869
                                        {
870
                                                setResizeCursor(hitTest, currItem->rotation());
871
                                        }
12775 jghali 872
                                }
873
                                else
874
                                {
12799 pierre 875
//                                      setModeCursor();
876
                                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
12775 jghali 877
                                }
878
                        }
879
                }
880
        }
881
        else
882
        {
883
                if ((m_canvas->m_viewMode.m_MouseButtonPressed) && (m->buttons() & Qt::LeftButton))
884
                {
885
                        newX = qRound(mousePointDoc.x()); //m_view->translateToDoc(m->x(), m->y()).x());
886
                        newY = qRound(mousePointDoc.y()); //m_view->translateToDoc(m->x(), m->y()).y());
887
                        SeRx = newX;
888
                        SeRy = newY;
889
                        /*
890
                        m_view->redrawMarker->setGeometry(QRect(Mxp, Myp, m->globalPos().x() - Mxp, m->globalPos().y() - Myp).normalized());
891
                        */
892
                        QPoint startP = m_canvas->canvasToGlobal(QPointF(Mxp, Myp));
893
                        m_view->redrawMarker->setGeometry(QRect(startP, m->globalPos()).normalized());
894
                        if (!m_view->redrawMarker->isVisible())
895
                                m_view->redrawMarker->show();
896
                        m_view->HaveSelRect = true;
897
                        return;
898
                }
899
        }
900
}
901
 
902
void CanvasMode_Edit::mousePressEvent(QMouseEvent *m)
903
{
904
//      const double mouseX = m->globalX();
905
//      const double mouseY = m->globalY();
906
        const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
907
 
908
        bool inText;
909
        double Rxp = 0;
910
        double Ryp = 0;
12796 pierre 911
//      Not used said gcc
912
//      double Rxpd = 0;
913
//      double Rypd = 0;
12775 jghali 914
        PageItem *currItem;
915
        m_canvas->PaintSizeRect(QRect());
916
        FPoint npf, npf2;
917
        QRect tx;
918
        QMatrix pm;
919
        m_canvas->m_viewMode.m_MouseButtonPressed = true;
920
        m_canvas->m_viewMode.operItemMoving = false;
921
        m_view->HaveSelRect = false;
922
        m_doc->DragP = false;
923
        m_doc->leaveDrag = false;
924
//      oldClip = 0;
925
        m->accept();
926
        m_view->registerMousePress(m->globalPos());
927
        Mxp = mousePointDoc.x(); //qRound(m->x()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.x());
928
        Myp = mousePointDoc.y(); //qRound(m->y()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.y());
13297 pierre 929
//      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 930
//      mpo.moveBy(qRound(m_doc->minCanvasCoordinate.x() * m_canvas->scale()), qRound(m_doc->minCanvasCoordinate.y() * m_canvas->scale()));
931
        Ryp = Myp;
932
        Rxp = Mxp;
933
        SeRx = Mxp;
934
        SeRy = Myp;
935
        if (m->button() == Qt::MidButton)
936
        {
937
                m_view->MidButt = true;
13124 fschmid 938
                if (m->modifiers() & Qt::ControlModifier)
939
                        m_view->DrawNew();
12775 jghali 940
                return;
941
        }
942
 
943
        frameResizeHandle = 0;
944
        m_canvas->m_viewMode.operItemResizeInEditMode = false;
945
        int oldP=0;
946
        if (GetItem(&currItem))
947
        {
948
//              m_view->slotDoCurs(false);
949
                if (!currItem->locked() && !currItem->asLine())
950
                {
951
                        if (!resizeGesture)
952
                                resizeGesture = new ResizeGesture(this);
953
 
954
                        resizeGesture->mousePressEvent(m);
955
                        if (resizeGesture->frameHandle() > 0)
956
                        {
957
                                m_canvas->m_viewMode.operItemResizeInEditMode = true;
958
                                m_view->startGesture(resizeGesture);
959
                                return;
960
                        }
961
                        else if (resizeGesture->frameHandle() < 0)
962
                        {
963
                                m_view->Deselect(true);
964
                                if (SeleItem(m))
965
                                {
966
                                        currItem = m_doc->m_Selection->itemAt(0);
967
                                        if ((currItem->asTextFrame()) || (currItem->asImageFrame()))
13106 pierre 968
                                        {
12775 jghali 969
                                                m_view->requestMode(modeEdit);
13106 pierre 970
                                        }
12775 jghali 971
                                        else
972
                                        {
973
                                                m_view->requestMode(submodePaintingDone);
974
                                                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
975
                                        }
976
                                }
977
                                else
978
                                {
979
                                        m_view->requestMode(submodePaintingDone);
980
                                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
981
                                }
982
                                m_view->requestMode(modeNormal);
983
                                return;
984
                        }
985
                }
986
                oldP = currItem->CPos;
987
                //CB Where we set the cursor for a click in text frame
988
                if (currItem->asTextFrame())
989
                {
13297 pierre 990
                        inText = m_view->slotSetCurs(m->globalPos().x(), m->globalPos().y());
12775 jghali 991
                        //CB If we clicked outside a text frame to go out of edit mode and deselect the frame
992
                        if (!inText)
993
                        {
994
                                currItem->invalidateLayout();
995
                                m_view->Deselect(true);
996
                                //m_view->slotDoCurs(true);
997
                                m_view->requestMode(modeNormal);
998
                                return;
999
                        }
13227 fschmid 1000
                        if (m->button() != Qt::RightButton)
12775 jghali 1001
                        {
13227 fschmid 1002
                                //<<CB Add in shift select to text frames
1003
                                if (m->modifiers() & Qt::ShiftModifier && currItem->itemText.lengthOfSelection() > 0)
12775 jghali 1004
                                {
13227 fschmid 1005
                                        if (currItem->CPos < (currItem->itemText.startOfSelection() + currItem->itemText.endOfSelection()) / 2)
1006
                                                oldP = currItem->itemText.startOfSelection();
1007
                                        else
1008
                                                oldP = currItem->itemText.endOfSelection();
1009
                                        currItem->asTextFrame()->itemText.extendSelection(oldP, currItem->CPos);
1010
                                        oldCp = currItem->CPos;
12775 jghali 1011
                                }
13227 fschmid 1012
                                else //>>CB
12775 jghali 1013
                                {
13227 fschmid 1014
                                        oldCp = currItem->CPos;
1015
                                        currItem->itemText.deselectAll();
1016
                                        currItem->HasSel = false;
12775 jghali 1017
                                }
13227 fschmid 1018
                                currItem->emitAllToGUI();
1019
                                if (m->button() == Qt::MidButton)
1020
                                {
1021
                                        m_canvas->m_viewMode.m_MouseButtonPressed = false;
1022
                                        m_view->MidButt = false;
1023
                                        QString cc;
1024
                                        cc = QApplication::clipboard()->text(QClipboard::Selection);
1025
                                        if (cc.isNull())
1026
                                                cc = QApplication::clipboard()->text(QClipboard::Clipboard);
1027
                                        if (!cc.isNull())
1028
                                        {
1029
                                                // K.I.S.S.:
1030
                                                currItem->itemText.insertChars(0, cc, true);
1031
                                                if (m_doc->docHyphenator->AutoCheck)
1032
                                                        m_doc->docHyphenator->slotHyphenate(currItem);
1033
                                                m_ScMW->BookMarkTxT(currItem);
1034
                                                //                                                      m_ScMW->outlinePalette->BuildTree();
1035
                                        }
1036
                                        else
1037
                                        {
1038
                                                if (ScMimeData::clipboardHasScribusText())
1039
                                                        m_ScMW->slotEditPaste();
1040
                                        }
1041
                                        currItem->update();
1042
                                }
12775 jghali 1043
                        }
1044
                }
1045
                else if (!currItem->asImageFrame() ||
1046
                                 m_canvas->frameHitTest(QPointF(mousePointDoc.x(),mousePointDoc.y()), currItem) < 0)
1047
                {
1048
                        m_view->Deselect(true);
1049
                        if (SeleItem(m))
1050
                        {
1051
                                currItem = m_doc->m_Selection->itemAt(0);
1052
                                if ((currItem->asTextFrame()) || (currItem->asImageFrame()))
13106 pierre 1053
                                {
12775 jghali 1054
                                        m_view->requestMode(modeEdit);
13106 pierre 1055
                                }
12775 jghali 1056
                                else
1057
                                {
1058
                                        m_view->requestMode(submodePaintingDone);
1059
                                        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
1060
                                }
1061
                        }
1062
                        else
1063
                        {
1064
                                m_view->requestMode(submodePaintingDone);
1065
                                qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
1066
                        }
1067
                }
1068
        }
1069
}
1070
 
1071
 
1072
 
1073
void CanvasMode_Edit::mouseReleaseEvent(QMouseEvent *m)
1074
{
13034 pierre 1075
#ifdef GESTURE_FRAME_PREVIEW
1076
        clearPixmapCache();
1077
#endif // GESTURE_FRAME_PREVIEW
12775 jghali 1078
        const FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
1079
        PageItem *currItem;
1080
        m_canvas->m_viewMode.m_MouseButtonPressed = false;
1081
        m_canvas->resetRenderMode();
1082
        m->accept();
13285 fschmid 1083
//      m_view->stopDragTimer();
12775 jghali 1084
        if ((GetItem(&currItem)) && (m->button() == Qt::RightButton) && (!m_doc->DragP))
1085
        {
1086
                createContextMenu(currItem, mousePointDoc.x(), mousePointDoc.y());
1087
                return;
1088
        }
1089
        if (m_view->moveTimerElapsed() && (GetItem(&currItem)))
1090
        {
13285 fschmid 1091
//              m_view->stopDragTimer();
12775 jghali 1092
                m_canvas->setRenderModeUseBuffer(false);
1093
                if (!m_doc->m_Selection->isMultipleSelection())
1094
                {
1095
                        m_doc->setRedrawBounding(currItem);
1096
                        currItem->OwnPage = m_doc->OnPage(currItem);
1097
                        m_canvas->m_viewMode.operItemResizing = false;
1098
                        if (currItem->asLine())
1099
                                m_view->updateContents();
1100
                }
1101
                if (m_canvas->m_viewMode.operItemMoving)
1102
                {
1103
                        m_view->updatesOn(false);
1104
                        if (m_doc->m_Selection->isMultipleSelection())
1105
                        {
1106
                                if (!m_view->groupTransactionStarted())
1107
                                {
1108
                                        m_view->startGroupTransaction(Um::Move, "", Um::IMove);
1109
                                }
1110
                                m_doc->m_Selection->setGroupRect();
1111
                                double gx, gy, gh, gw;
1112
                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
1113
                                double nx = gx;
1114
                                double ny = gy;
1115
                                if (!m_doc->ApplyGuides(&nx, &ny))
1116
                                {
1117
                                        FPoint npx = m_doc->ApplyGridF(FPoint(gx, gy));
1118
                                        FPoint npw = m_doc->ApplyGridF(FPoint(gx+gw, gy+gh));
1119
                                        if ((fabs(gx-npx.x())) > (fabs((gx+gw)-npw.x())))
1120
                                                nx = npw.x() - gw;
1121
                                        else
1122
                                                nx = npx.x();
1123
                                        if ((fabs(gy-npx.y())) > (fabs((gy+gh)-npw.y())))
1124
                                                ny = npw.y() - gh;
1125
                                        else
1126
                                                ny = npx.y();
1127
                                }
1128
                                m_doc->moveGroup(nx-gx, ny-gy, false);
1129
                                m_doc->m_Selection->setGroupRect();
1130
                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
1131
                                nx = gx+gw;
1132
                                ny = gy+gh;
1133
                                if (m_doc->ApplyGuides(&nx, &ny))
1134
                                        m_doc->moveGroup(nx-(gx+gw), ny-(gy+gh), false);
1135
                                m_doc->m_Selection->setGroupRect();
1136
                        }
1137
                        else
1138
                        {
1139
                                currItem = m_doc->m_Selection->itemAt(0);
1140
                                if (m_doc->useRaster)
1141
                                {
1142
                                        double nx = currItem->xPos();
1143
                                        double ny = currItem->yPos();
1144
                                        if (!m_doc->ApplyGuides(&nx, &ny))
1145
                                        {
1146
                                                m_doc->m_Selection->setGroupRect();
1147
                                                double gx, gy, gh, gw;
1148
                                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
1149
                                                FPoint npx = m_doc->ApplyGridF(FPoint(gx, gy));
1150
                                                FPoint npw = m_doc->ApplyGridF(FPoint(gx+gw, gy+gh));
1151
                                                if ((fabs(gx-npx.x())) > (fabs((gx+gw)-npw.x())))
1152
                                                        nx = npw.x() - gw;
1153
                                                else
1154
                                                        nx = npx.x();
1155
                                                if ((fabs(gy-npx.y())) > (fabs((gy+gh)-npw.y())))
1156
                                                        ny = npw.y() - gh;
1157
                                                else
1158
                                                        ny = npx.y();
1159
                                        }
1160
                                        m_doc->MoveItem(nx-currItem->xPos(), ny-currItem->yPos(), currItem);
1161
                                }
1162
                                else
1163
                                        m_doc->MoveItem(0, 0, currItem, false);
1164
                        }
1165
                        m_canvas->m_viewMode.operItemMoving = false;
1166
                        if (m_doc->m_Selection->isMultipleSelection())
1167
                        {
1168
                                double gx, gy, gh, gw;
1169
                                m_doc->m_Selection->getGroupRect(&gx, &gy, &gw, &gh);
1170
                                FPoint maxSize(gx+gw+m_doc->scratch.Right, gy+gh+m_doc->scratch.Bottom);
1171
                                FPoint minSize(gx-m_doc->scratch.Left, gy-m_doc->scratch.Top);
1172
                                m_doc->adjustCanvas(minSize, maxSize);
1173
                        }
1174
                        m_doc->setRedrawBounding(currItem);
1175
                        currItem->OwnPage = m_doc->OnPage(currItem);
1176
                        if (currItem->OwnPage != -1)
1177
                        {
1178
                                m_doc->setCurrentPage(m_doc->Pages->at(currItem->OwnPage));
1179
                                m_view->setMenTxt(currItem->OwnPage);
1180
                        }
1181
                        //CB done with emitAllToGUI
1182
                        //emit HaveSel(currItem->itemType());
1183
                        //EmitValues(currItem);
1184
                        //CB need this for? a moved item will send its new data with the new xpos/ypos emits
1185
                        //CB TODO And what if we have dragged to a new page. Items X&Y are not updated anyway now
1186
                        //currItem->emitAllToGUI();
1187
                        m_view->updatesOn(true);
1188
                        m_view->updateContents();
1189
                }
1190
        }
1191
        //CB Drag selection performed here
1192
        if ((m_doc->m_Selection->count() == 0) && (m_view->HaveSelRect) && (!m_view->MidButt))
1193
        {
1194
                QRectF Sele = QRectF(Dxp, Dyp, SeRx-Dxp, SeRy-Dyp).normalized();
1195
                if (!m_doc->masterPageMode())
1196
                {
1197
                        uint docPagesCount=m_doc->Pages->count();
1198
                        uint docCurrPageNo=m_doc->currentPageNumber();
1199
                        for (uint i = 0; i < docPagesCount; ++i)
1200
                        {
1201
                                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))
1202
                                {
1203
                                        if (docCurrPageNo != i)
1204
                                        {
1205
                                                m_doc->setCurrentPage(m_doc->Pages->at(i));
1206
                                                m_view->setMenTxt(i);
1207
                                        }
1208
                                        break;
1209
                                }
1210
                        }
1211
                        m_view->setRulerPos(m_view->contentsX(), m_view->contentsY());
1212
                }
1213
                int docItemCount=m_doc->Items->count();
1214
                if (docItemCount != 0)
1215
                {
1216
                        m_doc->m_Selection->delaySignalsOn();
1217
                        for (int a = 0; a < docItemCount; ++a)
1218
                        {
1219
                                PageItem* docItem = m_doc->Items->at(a);
1220
                                QMatrix p;
1221
                                m_canvas->Transform(docItem, p);
1222
                                QRegion apr = QRegion(docItem->Clip * p);
1223
                                QRect apr2(docItem->getRedrawBounding(1.0));
1224
                                if ((m_doc->masterPageMode()) && (docItem->OnMasterPage != m_doc->currentPage()->pageName()))
1225
                                        continue;
1226
                                if (((Sele.contains(apr.boundingRect())) || (Sele.contains(apr2))) && (docItem->LayerNr == m_doc->activeLayer()) && (!m_doc->layerLocked(docItem->LayerNr)))
1227
                                {
1228
                                        bool redrawSelection=false;
1229
                                        m_view->SelectItemNr(a, redrawSelection);
1230
                                }
1231
                        }
1232
                        m_doc->m_Selection->delaySignalsOff();
1233
                        if (m_doc->m_Selection->count() > 1)
1234
                        {
1235
                                m_doc->m_Selection->setGroupRect();
1236
                                double x, y, w, h;
1237
                                m_doc->m_Selection->getGroupRect(&x, &y, &w, &h);
1238
                                m_view->getGroupRectScreen(&x, &y, &w, &h);
1239
                        }
1240
                }
1241
                m_view->HaveSelRect = false;
1242
                m_view->redrawMarker->hide();
1243
                m_view->updateContents();
1244
        }
1245
        if (GetItem(&currItem))
1246
        {
1247
                if (m_doc->m_Selection->count() > 1)
1248
                {
1249
                        m_doc->m_Selection->setGroupRect();
1250
                        double x, y, w, h;
1251
                        m_doc->m_Selection->getGroupRect(&x, &y, &w, &h);
1252
                        m_canvas->m_viewMode.operItemMoving = false;
1253
                        m_canvas->m_viewMode.operItemResizing = false;
1254
                        m_view->updateContents(QRect(static_cast<int>(x-5), static_cast<int>(y-5), static_cast<int>(w+10), static_cast<int>(h+10)));
1255
                }
1256
                /*else
1257
                        currItem->emitAllToGUI();*/
1258
        }
1259
        m_canvas->setRenderModeUseBuffer(false);
1260
        m_doc->DragP = false;
1261
        m_doc->leaveDrag = false;
1262
        m_canvas->m_viewMode.operItemMoving = false;
1263
        m_canvas->m_viewMode.operItemResizing = false;
1264
        m_view->MidButt = false;
1265
        if (m_view->groupTransactionStarted())
1266
        {
1267
                for (int i = 0; i < m_doc->m_Selection->count(); ++i)
1268
                        m_doc->m_Selection->itemAt(i)->checkChanges(true);
1269
                m_view->endGroupTransaction();
1270
        }
1271
        for (int i = 0; i < m_doc->m_Selection->count(); ++i)
1272
                m_doc->m_Selection->itemAt(i)->checkChanges(true);
1273
        //Commit drag created items to undo manager.
1274
        if (m_doc->m_Selection->itemAt(0)!=NULL)
1275
        {
1276
                m_doc->itemAddCommit(m_doc->m_Selection->itemAt(0)->ItemNr);
1277
        }
1278
        //Make sure the Zoom spinbox and page selector dont have focus if we click on the canvas
1279
        m_view->zoomSpinBox->clearFocus();
1280
        m_view->pageSelector->clearFocus();
1281
        if (m_doc->m_Selection->itemAt(0) != 0) // is there the old clip stored for the undo action
1282
        {
1283
                currItem = m_doc->m_Selection->itemAt(0);
1284
                m_doc->nodeEdit.finishTransaction(currItem);
1285
        }
1286
}
1287
 
1288
//CB-->Doc/Fix
1289
bool CanvasMode_Edit::SeleItem(QMouseEvent *m)
1290
{
1291
        const unsigned SELECT_IN_GROUP = Qt::AltModifier;
1292
        const unsigned SELECT_MULTIPLE = Qt::ShiftModifier;
1293
        const unsigned SELECT_BENEATH = Qt::ControlModifier;
1294
        QMatrix p;
1295
        QRectF tx, mpo;
1296
        PageItem *currItem;
1297
        m_canvas->m_viewMode.m_MouseButtonPressed = true;
1298
        FPoint mousePointDoc = m_canvas->globalToCanvas(m->globalPos());
1299
        Mxp = mousePointDoc.x(); //m->x()/m_canvas->scale());
1300
        Myp = mousePointDoc.y(); //m->y()/m_canvas->scale());
1301
        double grabRadius = m_doc->guidesSettings.grabRad / m_canvas->scale();
1302
        int MxpS = static_cast<int>(mousePointDoc.x()); //m->x()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.x());
1303
        int MypS = static_cast<int>(mousePointDoc.y()); //m->y()/m_canvas->scale() + 0*m_doc->minCanvasCoordinate.y());
1304
        mpo = QRectF(Mxp-grabRadius, Myp-grabRadius, grabRadius*2, grabRadius*2);
1305
//      mpo.translate(m_doc->minCanvasCoordinate.x() * m_canvas->scale(), m_doc->minCanvasCoordinate.y() * m_canvas->scale());
1306
        m_doc->nodeEdit.deselect();
1307
//      int a;
1308
        if (!m_doc->masterPageMode())
1309
        {
1310
                int pgNum = -1;
1311
                int docPageCount = static_cast<int>(m_doc->Pages->count() - 1);
1312
                MarginStruct pageBleeds;
1313
                bool drawBleed = false;
1314
                if (m_doc->bleeds.hasNonZeroValue() && m_doc->guidesSettings.showBleed)
1315
                        drawBleed = true;
1316
                for (int a = docPageCount; a > -1; a--)
1317
                {
1318
                        if (drawBleed)
1319
                                m_doc->getBleeds(a, pageBleeds);
1320
                        int x = static_cast<int>(m_doc->Pages->at(a)->xOffset() - pageBleeds.Left);
1321
                        int y = static_cast<int>(m_doc->Pages->at(a)->yOffset() - pageBleeds.Top);
1322
                        int w = static_cast<int>(m_doc->Pages->at(a)->width() + pageBleeds.Left + pageBleeds.Right);
1323
                        int h = static_cast<int>(m_doc->Pages->at(a)->height() + pageBleeds.Bottom + pageBleeds.Top);
1324
                        if (QRect(x, y, w, h).contains(MxpS, MypS))
1325
                        {
1326
                                pgNum = static_cast<int>(a);
1327
                                if (drawBleed)  // check again if its really on the correct page
1328
                                {
1329
                                        for (int a2 = docPageCount; a2 > -1; a2--)
1330
                                        {
1331
                                                int xn = static_cast<int>(m_doc->Pages->at(a2)->xOffset());
1332
                                                int yn = static_cast<int>(m_doc->Pages->at(a2)->yOffset());
1333
                                                int wn = static_cast<int>(m_doc->Pages->at(a2)->width());
1334
                                                int hn = static_cast<int>(m_doc->Pages->at(a2)->height());
1335
                                                if (QRect(xn, yn, wn, hn).contains(MxpS, MypS))
1336
                                                {
1337
                                                        pgNum = static_cast<int>(a2);
1338
                                                        break;
1339
                                                }
1340
                                        }
1341
                                }
1342
                                break;
1343
                        }
1344
                }
1345
                if (pgNum >= 0)
1346
                {
1347
                        if (m_doc->currentPageNumber() != pgNum)
1348
                        {
1349
                                m_doc->setCurrentPage(m_doc->Pages->at(unsigned(pgNum)));
1350
                                m_view->setMenTxt(unsigned(pgNum));
1351
                                m_view->DrawNew();
1352
                        }
1353
                }
1354
                m_view->setRulerPos(m_view->contentsX(), m_view->contentsY());
1355
        }
1356
 
1357
        currItem = NULL;
1358
        if ((m->modifiers() & SELECT_BENEATH) != 0)
1359
        {
1360
                for (int i=0; i < m_doc->m_Selection->count(); ++i)
1361
                {
1362
                        if (m_canvas->frameHitTest(QPointF(mousePointDoc.x(),mousePointDoc.y()), m_doc->m_Selection->itemAt(i)) >= 0)
1363
                        {
1364
                                currItem = m_doc->m_Selection->itemAt(i);
1365
//                              qDebug() << "select item: found BENEATH" << currItem << "groups" << currItem->Groups.count();
1366
                                if (currItem->Groups.count() > 0)
1367
                                {
1368
                                        m_doc->m_Selection->delaySignalsOn();
1369
                                        for (int ga=0; ga<m_doc->Items->count(); ++ga)
1370
                                        {
1371
                                                PageItem* item = m_doc->Items->at(ga);
1372
                                                if (item->Groups.count() != 0)
1373
                                                {
1374
                                                        if (item->Groups.top() == currItem->Groups.top())
1375
                                                        {
1376
                                                                if (m_doc->m_Selection->findItem(item) >= 0)
1377
                                                                {
1378
                                                                        m_doc->m_Selection->removeItem(item);
1379
                                                                }
1380
                                                        }
1381
                                                }
1382
                                        }
1383
                                        m_doc->m_Selection->delaySignalsOff();
1384
                                }
1385
                                else
1386
                                {
1387
                                        m_doc->m_Selection->removeItem(currItem);
1388
                                }
1389
                                break;
1390
                        }
1391
//                      else
1392
//                              qDebug() << "select item: not BENEATH" << QPointF(mousePointDoc.x(),mousePointDoc.y()) 
1393
//                                      << m_doc->m_Selection->itemAt(i)->getTransform() 
1394
//                                      << m_doc->m_Selection->itemAt(i)->getBoundingRect();
1395
                }
1396
        }
1397
        else if ( (m->modifiers() & SELECT_MULTIPLE) == Qt::NoModifier)
1398
        {
1399
                m_view->Deselect(false);
1400
        }
1401
 
1402
//      qDebug() << "select item: beneath" << (m->modifiers() & SELECT_BENEATH) << currItem 
1403
//              << "multi" << (m->modifiers() & SELECT_MULTIPLE)
1404
//              << "current sel" << m_doc->m_Selection->count();
1405
        currItem = m_canvas->itemUnderCursor(m->globalPos(), currItem, (m->modifiers() & SELECT_IN_GROUP));
1406
//      qDebug() << "item under cursor: " << currItem;
1407
        if (currItem)
1408
        {
1409
                m_doc->m_Selection->delaySignalsOn();
1410
                if (m_doc->m_Selection->containsItem(currItem))
1411
                {
1412
                        m_doc->m_Selection->removeItem(currItem);
1413
                }
1414
                else
1415
                {
1416
                        //CB: If we have a selection but the user clicks with control on another item that is not below the current
1417
                        //then clear and select the new item
1418
                        if ((m->modifiers() == SELECT_BENEATH) && m_canvas->frameHitTest(QPointF(mousePointDoc.x(),mousePointDoc.y()), currItem) >= 0)
1419
                                m_doc->m_Selection->clear();
1420
                        //CB: #7186: This was prependItem, does not seem to need to be anymore with current select code
1421
                        m_doc->m_Selection->addItem(currItem);
1422
                        if ( (m->modifiers() & SELECT_IN_GROUP) && (!currItem->isGroupControl))
1423
                        {
1424
                                currItem->isSingleSel = true;
1425
                        }
1426
                        else if (currItem->Groups.count() > 0)
1427
                        {
1428
                                for (int ga=0; ga<m_doc->Items->count(); ++ga)
1429
                                {
1430
                                        PageItem* item = m_doc->Items->at(ga);
1431
                                        if (item->Groups.count() != 0)
1432
                                        {
1433
                                                if (item->Groups.top() == currItem->Groups.top())
1434
                                                {
1435
                                                        if (item->ItemNr != currItem->ItemNr)
1436
                                                        {
1437
                                                                if (m_doc->m_Selection->findItem(item) == -1)
1438
                                                                {
1439
                                                                        m_doc->m_Selection->addItem(item, true);
1440
                                                                }
1441
                                                        }
1442
                                                        item->isSingleSel = false;
1443
                                                }
1444
                                        }
1445
                                }
1446
                        }
1447
                }
1448
 
13132 pierre 1449
//              currItem->update();
1450
                m_canvas->update();
12775 jghali 1451
                m_doc->m_Selection->delaySignalsOff();
1452
                if (m_doc->m_Selection->count() > 1)
1453
                {
13132 pierre 1454
//                      for (int aa = 0; aa < m_doc->m_Selection->count(); ++aa)
1455
//                      {
1456
//                              PageItem *bb = m_doc->m_Selection->itemAt(aa);
1457
//                              bb->update();
1458
//                      }
12775 jghali 1459
                        m_doc->m_Selection->setGroupRect();
1460
                        double x, y, w, h;
1461
                        m_doc->m_Selection->getGroupRect(&x, &y, &w, &h);
1462
                        //                                      emit ItemPos(x, y);
1463
                        //                                      emit ItemGeom(w, h);
1464
                        m_view->getGroupRectScreen(&x, &y, &w, &h);
1465
                        //                                      m_view->updateContents(QRect(static_cast<int>(x-5), static_cast<int>(y-5), static_cast<int>(w+10), static_cast<int>(h+10)));
1466
                        //                                      emit HaveSel(currItem->itemType());
1467
                }
1468
                if (m_doc->m_Selection->count() == 1)
1469
                {
1470
                        frameResizeHandle = m_canvas->frameHitTest(QPointF(mousePointDoc.x(),mousePointDoc.y()), currItem);
1471
                        if ((frameResizeHandle == Canvas::INSIDE) && (!currItem->locked()))
1472
                                qApp->changeOverrideCursor(QCursor(Qt::SizeAllCursor));
1473
                }
1474
                else
1475
                {
1476
                        qApp->changeOverrideCursor(QCursor(Qt::SizeAllCursor));
1477
                        m_canvas->m_viewMode.operItemResizing = false;
1478
                }
1479
                return true;
1480
        }
1481
 
1482
        //m_doc->m_Selection->setIsGUISelection(true);
1483
        m_doc->m_Selection->connectItemToGUI();
1484
        if ( !(m->modifiers() & SELECT_MULTIPLE))
1485
                m_view->Deselect(true);
1486
        return false;
1487
}
1488
 
12799 pierre 1489
// void CanvasMode_Edit::setResizeCursor(int how, double rot)
1490
// {
1491
//      switch (how)
1492
//      {
1493
//              case 1:
1494
//              case 2:
1495
//                      qApp->changeOverrideCursor(ScResizeCursor(135 + rot));
1496
//                      break;
1497
//              case 3:
1498
//              case 4:
1499
//                      qApp->changeOverrideCursor(ScResizeCursor(45 + rot));
1500
//                      break;
1501
//              case 5:
1502
//              case 8:
1503
//                      qApp->changeOverrideCursor(ScResizeCursor(0 + rot));
1504
//                      break;
1505
//              case 6:
1506
//              case 7:
1507
//                      qApp->changeOverrideCursor(ScResizeCursor(90 + rot));
1508
//                      break;
1509
//              default:
1510
//                      qApp->changeOverrideCursor(QCursor(Qt::SizeAllCursor));
1511
//                      break;
1512
//      }
1513
// }
12775 jghali 1514
 
1515
void CanvasMode_Edit::createContextMenu(PageItem* currItem, double mx, double my)
1516
{
1517
        ContextMenu* cmen=NULL;
1518
        qApp->changeOverrideCursor(QCursor(Qt::ArrowCursor));
1519
        m_view->setObjectUndoMode();
1520
        Mxp = mx;
1521
        Myp = my;
1522
        if(currItem!=NULL)
1523
                cmen = new ContextMenu(*(m_doc->m_Selection), m_ScMW, m_doc);
1524
        else
1525
                cmen = new ContextMenu(m_ScMW, m_doc, mx, my);
1526
        if (cmen)
1527
                cmen->exec(QCursor::pos());
1528
        m_view->setGlobalUndoMode();
1529
        delete cmen;
1530
}