Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : *
9 : * This file incorporates work covered by the following license notice:
10 : *
11 : * Licensed to the Apache Software Foundation (ASF) under one or more
12 : * contributor license agreements. See the NOTICE file distributed
13 : * with this work for additional information regarding copyright
14 : * ownership. The ASF licenses this file to you under the Apache
15 : * License, Version 2.0 (the "License"); you may not use this file
16 : * except in compliance with the License. You may obtain a copy of
17 : * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 : */
19 :
20 :
21 : #include <hintids.hxx>
22 : #include <svx/svdview.hxx>
23 : #include <svx/svdobj.hxx>
24 : #include <svl/ptitem.hxx>
25 : #include <editeng/sizeitem.hxx>
26 : #include <sfx2/request.hxx>
27 : #include <sfx2/bindings.hxx>
28 : #include <fmtclds.hxx>
29 : #include <frmfmt.hxx>
30 : #include "cmdid.h"
31 : #include "basesh.hxx"
32 : #include "view.hxx"
33 : #include "wrtsh.hxx"
34 : #include "drawbase.hxx"
35 : #include "edtwin.hxx"
36 : #include "caption.hxx"
37 : #include "swundo.hxx"
38 : #include <SwRewriter.hxx>
39 : #include "comcore.hrc"
40 :
41 : using namespace ::com::sun::star;
42 :
43 : extern sal_Bool bNoInterrupt; // in mainwn.cxx
44 :
45 : #define MINMOVE ((sal_uInt16)m_pSh->GetOut()->PixelToLogic(Size(m_pSh->GetDrawView()->GetMarkHdlSizePixel()/2,0)).Width())
46 :
47 :
48 : /*************************************************************************
49 : |*
50 : |* Konstruktor
51 : |*
52 : \************************************************************************/
53 :
54 :
55 0 : SwDrawBase::SwDrawBase(SwWrtShell* pSwWrtShell, SwEditWin* pWindow, SwView* pSwView) :
56 : m_pView(pSwView),
57 : m_pSh(pSwWrtShell),
58 : m_pWin(pWindow),
59 : m_nSlotId(USHRT_MAX),
60 : m_bCreateObj(sal_True),
61 0 : m_bInsForm(sal_False)
62 : {
63 0 : if ( !m_pSh->HasDrawView() )
64 0 : m_pSh->MakeDrawView();
65 0 : }
66 :
67 : /*************************************************************************
68 : |*
69 : |* Destruktor
70 : |*
71 : \************************************************************************/
72 :
73 0 : SwDrawBase::~SwDrawBase()
74 : {
75 0 : if (m_pView->GetWrtShellPtr()) // Im view-Dtor koennte die wrtsh bereits geloescht worden sein...
76 0 : m_pSh->GetDrawView()->SetEditMode(sal_True);
77 0 : }
78 :
79 : /*************************************************************************
80 : |*
81 : |* MouseButtonDown-event
82 : |*
83 : \************************************************************************/
84 :
85 :
86 0 : sal_Bool SwDrawBase::MouseButtonDown(const MouseEvent& rMEvt)
87 : {
88 0 : sal_Bool bReturn = sal_False;
89 :
90 0 : SdrView *pSdrView = m_pSh->GetDrawView();
91 :
92 : // #i33136#
93 0 : pSdrView->SetOrtho(doConstructOrthogonal() ? !rMEvt.IsShift() : rMEvt.IsShift());
94 0 : pSdrView->SetAngleSnapEnabled(rMEvt.IsShift());
95 :
96 0 : if (rMEvt.IsMod2())
97 : {
98 0 : pSdrView->SetCreate1stPointAsCenter(sal_True);
99 0 : pSdrView->SetResizeAtCenter(sal_True);
100 : }
101 : else
102 : {
103 0 : pSdrView->SetCreate1stPointAsCenter(sal_False);
104 0 : pSdrView->SetResizeAtCenter(sal_False);
105 : }
106 :
107 0 : SdrViewEvent aVEvt;
108 0 : SdrHitKind eHit = pSdrView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
109 :
110 : // Nur neues Objekt, wenn nicht im Basismode (bzw reinem Selektionsmode)
111 0 : if (rMEvt.IsLeft() && !m_pWin->IsDrawAction())
112 : {
113 0 : if (IsCreateObj() && (eHit == SDRHIT_UNMARKEDOBJECT || eHit == SDRHIT_NONE || m_pSh->IsDrawCreate()))
114 : {
115 0 : bNoInterrupt = sal_True;
116 0 : m_pWin->CaptureMouse();
117 :
118 0 : m_aStartPos = m_pWin->PixelToLogic(rMEvt.GetPosPixel());
119 :
120 0 : bReturn = m_pSh->BeginCreate( static_cast< sal_uInt16 >(m_pWin->GetSdrDrawMode()), m_aStartPos);
121 :
122 0 : SetDrawPointer();
123 :
124 0 : if ( bReturn )
125 0 : m_pWin->SetDrawAction(sal_True);
126 : }
127 0 : else if (!pSdrView->IsAction())
128 : {
129 : /**********************************************************************
130 : * BEZIER-EDITOR
131 : **********************************************************************/
132 0 : m_pWin->CaptureMouse();
133 0 : m_aStartPos = m_pWin->PixelToLogic(rMEvt.GetPosPixel());
134 0 : sal_uInt16 nEditMode = m_pWin->GetBezierMode();
135 :
136 0 : if (eHit == SDRHIT_HANDLE && aVEvt.pHdl->GetKind() == HDL_BWGT)
137 : {
138 : /******************************************************************
139 : * Handle draggen
140 : ******************************************************************/
141 0 : bNoInterrupt = sal_True;
142 0 : bReturn = pSdrView->BegDragObj(m_aStartPos, (OutputDevice*) NULL, aVEvt.pHdl);
143 0 : m_pWin->SetDrawAction(sal_True);
144 : }
145 0 : else if (eHit == SDRHIT_MARKEDOBJECT && nEditMode == SID_BEZIER_INSERT)
146 : {
147 : /******************************************************************
148 : * Klebepunkt einfuegen
149 : ******************************************************************/
150 0 : bNoInterrupt = sal_True;
151 0 : bReturn = pSdrView->BegInsObjPoint(m_aStartPos, rMEvt.IsMod1());
152 0 : m_pWin->SetDrawAction(sal_True);
153 : }
154 0 : else if (eHit == SDRHIT_MARKEDOBJECT && rMEvt.IsMod1())
155 : {
156 : /******************************************************************
157 : * Klebepunkt selektieren
158 : ******************************************************************/
159 0 : if (!rMEvt.IsShift())
160 0 : pSdrView->UnmarkAllPoints();
161 :
162 0 : bReturn = pSdrView->BegMarkPoints(m_aStartPos);
163 0 : m_pWin->SetDrawAction(sal_True);
164 : }
165 0 : else if (eHit == SDRHIT_MARKEDOBJECT && !rMEvt.IsShift() && !rMEvt.IsMod2())
166 : {
167 : /******************************************************************
168 : * Objekt verschieben
169 : ******************************************************************/
170 0 : return sal_False;
171 : }
172 0 : else if (eHit == SDRHIT_HANDLE)
173 : {
174 : /******************************************************************
175 : * Klebepunkt selektieren
176 : ******************************************************************/
177 0 : if (pSdrView->HasMarkablePoints() && (!pSdrView->IsPointMarked(*aVEvt.pHdl) || rMEvt.IsShift()))
178 : {
179 0 : SdrHdl* pHdl = NULL;
180 :
181 0 : if (!rMEvt.IsShift())
182 : {
183 0 : pSdrView->UnmarkAllPoints();
184 0 : pHdl = pSdrView->PickHandle(m_aStartPos);
185 : }
186 : else
187 : {
188 0 : if (pSdrView->IsPointMarked(*aVEvt.pHdl))
189 : {
190 0 : bReturn = pSdrView->UnmarkPoint(*aVEvt.pHdl);
191 0 : pHdl = NULL;
192 : }
193 : else
194 : {
195 0 : pHdl = pSdrView->PickHandle(m_aStartPos);
196 : }
197 : }
198 :
199 0 : if (pHdl)
200 : {
201 0 : bNoInterrupt = sal_True;
202 0 : pSdrView->MarkPoint(*pHdl);
203 : }
204 : }
205 : }
206 : else
207 : {
208 : /******************************************************************
209 : * Objekt selektieren oder draggen
210 : ******************************************************************/
211 0 : if (m_pSh->IsObjSelectable(m_aStartPos) && eHit == SDRHIT_UNMARKEDOBJECT)
212 : {
213 0 : if (pSdrView->HasMarkablePoints())
214 0 : pSdrView->UnmarkAllPoints();
215 :
216 0 : bNoInterrupt = sal_False;
217 : // Drag im edtwin verwenden
218 0 : return sal_False;
219 : }
220 :
221 0 : bNoInterrupt = sal_True;
222 :
223 0 : if (m_pSh->IsObjSelected())
224 : {
225 0 : if (!rMEvt.IsShift())
226 : {
227 0 : if (!pSdrView->HasMarkablePoints())
228 : {
229 0 : sal_Bool bUnlockView = !m_pSh->IsViewLocked();
230 0 : m_pSh->LockView( sal_True ); //lock visible section
231 0 : m_pSh->SelectObj(Point(LONG_MAX, LONG_MAX)); // deselect all
232 0 : if( bUnlockView )
233 0 : m_pSh->LockView( sal_False );
234 : }
235 : else
236 0 : pSdrView->UnmarkAllPoints();
237 : }
238 : }
239 0 : if (!m_pSh->IsSelFrmMode())
240 0 : m_pSh->EnterSelFrmMode(NULL);
241 :
242 0 : if( 0 != (bReturn = m_pSh->BeginMark(m_aStartPos)) )
243 0 : m_pWin->SetDrawAction(sal_True);
244 :
245 0 : SetDrawPointer();
246 : }
247 : }
248 : }
249 0 : return bReturn;
250 : }
251 :
252 : /*************************************************************************
253 : |*
254 : |* MouseMove-event
255 : |*
256 : \************************************************************************/
257 :
258 :
259 0 : sal_Bool SwDrawBase::MouseMove(const MouseEvent& rMEvt)
260 : {
261 0 : SdrView *pSdrView = m_pSh->GetDrawView();
262 0 : Point aPnt(m_pWin->PixelToLogic(rMEvt.GetPosPixel()));
263 0 : sal_Bool bRet = sal_False;
264 :
265 0 : if (IsCreateObj() && !m_pWin->IsDrawSelMode() && pSdrView->IsCreateObj())
266 : {
267 : // #i33136#
268 0 : pSdrView->SetOrtho(doConstructOrthogonal() ? !rMEvt.IsShift() : rMEvt.IsShift());
269 0 : pSdrView->SetAngleSnapEnabled(rMEvt.IsShift());
270 :
271 0 : m_pSh->MoveCreate(aPnt);
272 0 : bRet = sal_True;
273 : }
274 0 : else if (pSdrView->IsAction() || pSdrView->IsInsObjPoint() || pSdrView->IsMarkPoints())
275 : {
276 0 : m_pSh->MoveMark(aPnt);
277 0 : bRet = sal_True;
278 : }
279 :
280 0 : return (bRet);
281 : }
282 :
283 : /*************************************************************************
284 : |*
285 : |* MouseButtonUp-event
286 : |*
287 : \************************************************************************/
288 :
289 :
290 0 : sal_Bool SwDrawBase::MouseButtonUp(const MouseEvent& rMEvt)
291 : {
292 0 : sal_Bool bReturn = sal_False;
293 0 : sal_Bool bCheckShell = sal_False;
294 0 : sal_Bool bAutoCap = sal_False;
295 :
296 0 : Point aPnt(m_pWin->PixelToLogic(rMEvt.GetPosPixel()));
297 :
298 0 : if (IsCreateObj() && m_pSh->IsDrawCreate() && !m_pWin->IsDrawSelMode())
299 : {
300 0 : const SdrObjKind nDrawMode = m_pWin->GetSdrDrawMode();
301 : //objects with multiple point may end at the start position
302 : sal_Bool bMultiPoint = OBJ_PLIN == nDrawMode ||
303 : OBJ_PATHLINE == nDrawMode ||
304 0 : OBJ_FREELINE == nDrawMode;
305 0 : if(rMEvt.IsRight() || (aPnt == m_aStartPos && !bMultiPoint))
306 : {
307 0 : m_pSh->BreakCreate();
308 0 : m_pView->LeaveDrawCreate();
309 : }
310 : else
311 : {
312 0 : if (OBJ_NONE == nDrawMode)
313 : {
314 0 : SwRewriter aRewriter;
315 :
316 0 : aRewriter.AddRule(UndoArg1, SW_RES(STR_FRAME));
317 0 : m_pSh->StartUndo(UNDO_INSERT, &aRewriter);
318 : }
319 :
320 0 : m_pSh->EndCreate(SDRCREATE_FORCEEND);
321 0 : if (OBJ_NONE == nDrawMode) // Textrahmen eingefuegt
322 : {
323 : uno::Reference< frame::XDispatchRecorder > xRecorder =
324 0 : m_pSh->GetView().GetViewFrame()->GetBindings().GetRecorder();
325 0 : if ( xRecorder.is() )
326 : {
327 0 : SfxRequest aReq(m_pSh->GetView().GetViewFrame(),FN_INSERT_FRAME);
328 : aReq.AppendItem(SfxUInt16Item( FN_INSERT_FRAME,
329 0 : static_cast<sal_uInt16>(FLY_AT_PARA) ));
330 0 : aReq.AppendItem(SfxPointItem( FN_PARAM_1, m_pSh->GetAnchorObjDiff()));
331 0 : aReq.AppendItem(SvxSizeItem( FN_PARAM_2, m_pSh->GetObjSize()));
332 0 : aReq.Done();
333 : }
334 0 : bAutoCap = sal_True;
335 0 : if(m_pWin->GetFrmColCount() > 1)
336 : {
337 0 : SfxItemSet aSet(m_pView->GetPool(),RES_COL,RES_COL);
338 0 : SwFmtCol aCol((const SwFmtCol&)aSet.Get(RES_COL));
339 0 : aCol.Init(m_pWin->GetFrmColCount(), aCol.GetGutterWidth(), aCol.GetWishWidth());
340 0 : aSet.Put(aCol);
341 : // Vorlagen-AutoUpdate
342 0 : SwFrmFmt* pFmt = m_pSh->GetCurFrmFmt();
343 0 : if(pFmt && pFmt->IsAutoUpdateFmt())
344 0 : m_pSh->AutoUpdateFrame(pFmt, aSet);
345 : else
346 0 : m_pSh->SetFlyFrmAttr( aSet );
347 0 : }
348 : }
349 0 : if (m_pWin->GetSdrDrawMode() == OBJ_NONE)
350 : {
351 0 : m_pSh->EndUndo();
352 : }
353 : }
354 :
355 0 : bReturn = sal_True;
356 :
357 0 : EnterSelectMode(rMEvt);
358 : }
359 : else
360 : {
361 0 : SdrView *pSdrView = m_pSh->GetDrawView();
362 :
363 0 : if (!pSdrView->HasMarkablePoints())
364 : {
365 : /**********************************************************************
366 : * KEIN BEZIER_EDITOR
367 : **********************************************************************/
368 0 : if ((m_pSh->GetDrawView()->IsMarkObj() || m_pSh->GetDrawView()->IsMarkPoints())
369 0 : && rMEvt.IsLeft())
370 : {
371 0 : bReturn = m_pSh->EndMark();
372 :
373 0 : m_pWin->SetDrawAction(sal_False);
374 :
375 0 : if (aPnt == m_aStartPos && m_pSh->IsObjSelectable(aPnt))
376 : {
377 0 : m_pSh->SelectObj(aPnt, ( rMEvt.IsShift() &&
378 0 : m_pSh->IsSelFrmMode()) ? SW_ADD_SELECT : 0);
379 :
380 0 : if (!m_pSh->IsObjSelected())
381 : {
382 0 : m_pView->LeaveDrawCreate(); // In Selektionsmode wechseln
383 :
384 0 : m_pSh->GetView().GetViewFrame()->GetBindings().Invalidate(SID_INSERT_DRAW);
385 :
386 0 : if (m_pSh->IsSelFrmMode())
387 0 : m_pSh->LeaveSelFrmMode();
388 : }
389 0 : m_pView->NoRotate();
390 :
391 0 : bCheckShell = sal_True; // ggf BezierShell anwerfen
392 : }
393 0 : else if (!m_pSh->IsObjSelected() && !m_pWin->IsDrawAction())
394 : {
395 0 : if (m_pSh->IsObjSelectable(aPnt))
396 0 : m_pSh->SelectObj(aPnt, ( rMEvt.IsShift() &&
397 0 : m_pSh->IsSelFrmMode() ) ? SW_ADD_SELECT : 0 );
398 : else
399 : {
400 0 : m_pView->LeaveDrawCreate();
401 0 : if (m_pSh->IsSelFrmMode())
402 0 : m_pSh->LeaveSelFrmMode();
403 : }
404 0 : m_pView->NoRotate();
405 :
406 0 : bReturn = sal_True;
407 : }
408 : }
409 : }
410 : else
411 : {
412 : /**********************************************************************
413 : * BEZIER_EDITOR
414 : **********************************************************************/
415 0 : if ( pSdrView->IsAction() )
416 : {
417 0 : if ( pSdrView->IsInsObjPoint() )
418 0 : bReturn = pSdrView->EndInsObjPoint(SDRCREATE_FORCEEND);
419 0 : else if (pSdrView->IsMarkPoints() )
420 0 : bReturn = pSdrView->EndMarkPoints();
421 : else
422 : {
423 0 : pSdrView->EndAction();
424 0 : bReturn = sal_True;
425 : }
426 0 : m_pWin->SetDrawAction(sal_False);
427 :
428 0 : if (aPnt == m_aStartPos)
429 : {
430 0 : if (!m_pSh->IsObjSelectable(aPnt))
431 0 : m_pSh->SelectObj(Point(LONG_MAX, LONG_MAX));
432 0 : else if (!bReturn)
433 : {
434 0 : if (!rMEvt.IsShift())
435 0 : pSdrView->UnmarkAllPoints();
436 0 : m_pSh->SelectObj(aPnt, (rMEvt.IsShift() &&
437 0 : m_pSh->IsSelFrmMode()) ? SW_ADD_SELECT :0);
438 : }
439 :
440 0 : if (!m_pSh->IsObjSelected())
441 : {
442 0 : m_pView->LeaveDrawCreate(); // In Selektionsmode wechseln
443 :
444 0 : m_pSh->GetView().GetViewFrame()->GetBindings().Invalidate(SID_INSERT_DRAW);
445 :
446 0 : if (m_pSh->IsSelFrmMode())
447 0 : m_pSh->LeaveSelFrmMode();
448 : }
449 0 : m_pView->NoRotate();
450 :
451 0 : bCheckShell = sal_True; // ggf BezierShell anwerfen
452 : }
453 : }
454 :
455 0 : SetDrawPointer();
456 :
457 0 : if (!m_pSh->IsObjSelected() && !m_pWin->IsDrawAction())
458 : {
459 0 : m_pView->LeaveDrawCreate();
460 0 : if (m_pSh->IsSelFrmMode())
461 0 : m_pSh->LeaveSelFrmMode();
462 :
463 0 : m_pView->NoRotate();
464 0 : bReturn = sal_True;
465 : }
466 : }
467 : }
468 :
469 0 : if (bCheckShell)
470 0 : m_pView->AttrChangedNotify( m_pSh ); // ggf BezierShell anwerfen
471 :
472 : //!!!!!!!!!! Achtung Suizid !!!!!!!!!!! Sollte alles mal erneuert werden
473 0 : if ( bAutoCap )
474 0 : m_pView->AutoCaption(FRAME_CAP); //Kann derzeit nur FRAME sein, sonst auf
475 : //enums umstellen
476 0 : return (bReturn);
477 : }
478 :
479 : /*************************************************************************
480 : |*
481 : |* Function aktivieren
482 : |*
483 : \************************************************************************/
484 :
485 :
486 0 : void SwDrawBase::Activate(const sal_uInt16 nSlot)
487 : {
488 0 : SetSlotId(nSlot);
489 0 : SdrView *pSdrView = m_pSh->GetDrawView();
490 :
491 0 : pSdrView->SetCurrentObj( static_cast< sal_uInt16 >(m_pWin->GetSdrDrawMode()) );
492 0 : pSdrView->SetEditMode(sal_False);
493 :
494 0 : SetDrawPointer();
495 0 : m_pSh->NoEdit();
496 0 : }
497 :
498 : /*************************************************************************
499 : |*
500 : |* Function deaktivieren
501 : |*
502 : \************************************************************************/
503 :
504 :
505 0 : void SwDrawBase::Deactivate()
506 : {
507 0 : SdrView *pSdrView = m_pSh->GetDrawView();
508 0 : pSdrView->SetOrtho(sal_False);
509 0 : pSdrView->SetAngleSnapEnabled(sal_False);
510 :
511 0 : if (m_pWin->IsDrawAction() && m_pSh->IsDrawCreate())
512 0 : m_pSh->BreakCreate();
513 :
514 0 : m_pWin->SetDrawAction(sal_False);
515 :
516 0 : m_pWin->ReleaseMouse();
517 0 : bNoInterrupt = sal_False;
518 :
519 0 : if(m_pWin->GetApplyTemplate())
520 0 : m_pWin->SetApplyTemplate(SwApplyTemplate());
521 0 : m_pSh->GetView().GetViewFrame()->GetBindings().Invalidate(SID_INSERT_DRAW);
522 0 : }
523 :
524 : /*************************************************************************
525 : |*
526 : |* Tastaturereignisse bearbeiten
527 : |*
528 : |* Wird ein KeyEvent bearbeitet, so ist der Return-Wert sal_True, andernfalls
529 : |* sal_False.
530 : |*
531 : \************************************************************************/
532 :
533 :
534 0 : sal_Bool SwDrawBase::KeyInput(const KeyEvent& rKEvt)
535 : {
536 0 : sal_Bool bReturn = sal_False;
537 0 : sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
538 :
539 0 : switch (nCode)
540 : {
541 : case KEY_ESCAPE:
542 : {
543 0 : if (m_pWin->IsDrawAction())
544 : {
545 0 : BreakCreate();
546 0 : m_pView->LeaveDrawCreate();
547 : }
548 :
549 0 : bReturn = sal_True;
550 : }
551 0 : break;
552 :
553 : case KEY_DELETE:
554 : {
555 0 : m_pSh->DelSelectedObj();
556 0 : bReturn = sal_True;
557 : }
558 0 : break;
559 :
560 : case KEY_UP:
561 : case KEY_DOWN:
562 : case KEY_LEFT:
563 : case KEY_RIGHT:
564 : {
565 0 : SdrView *pSdrView = m_pSh->GetDrawView();
566 :
567 0 : if (!pSdrView->IsTextEdit())
568 : {
569 0 : long nX = 0;
570 0 : long nY = 0;
571 :
572 0 : if (nCode == KEY_UP)
573 : {
574 : // Scroll nach oben
575 0 : nX = 0;
576 0 : nY =-1;
577 : }
578 0 : else if (nCode == KEY_DOWN)
579 : {
580 : // Scroll nach unten
581 0 : nX = 0;
582 0 : nY = 1;
583 : }
584 0 : else if (nCode == KEY_LEFT)
585 : {
586 : // Scroll nach links
587 0 : nX =-1;
588 0 : nY = 0;
589 : }
590 0 : else if (nCode == KEY_RIGHT)
591 : {
592 : // Scroll nach rechts
593 0 : nX = 1;
594 0 : nY = 0;
595 : }
596 :
597 0 : if (pSdrView->AreObjectsMarked() && rKEvt.GetKeyCode().IsMod2())
598 : {
599 : // Objekte verschieben
600 0 : nX *= 100;
601 0 : nY *= 100;
602 0 : pSdrView->MoveAllMarked(Size(nX, nY));
603 : }
604 :
605 0 : bReturn = sal_True;
606 : }
607 : }
608 0 : break;
609 : }
610 :
611 0 : return (bReturn);
612 : }
613 :
614 :
615 : /*************************************************************************
616 : |*
617 : |* Tastaturereignisse bearbeiten
618 : |*
619 : |* Wird ein KeyEvent bearbeitet, so ist der Return-Wert sal_True, andernfalls
620 : |* sal_False.
621 : |*
622 : \************************************************************************/
623 :
624 :
625 0 : void SwDrawBase::BreakCreate()
626 : {
627 0 : m_pSh->BreakCreate();
628 0 : m_pWin->SetDrawAction(sal_False);
629 0 : m_pWin->ReleaseMouse();
630 :
631 0 : Deactivate();
632 0 : }
633 :
634 : /*************************************************************************
635 : |*
636 : |* Mauspointer umschalten
637 : |*
638 : \************************************************************************/
639 :
640 :
641 0 : void SwDrawBase::SetDrawPointer()
642 : {
643 0 : SdrView *pSdrView = m_pSh->GetDrawView();
644 0 : Point aPnt(m_pWin->OutputToScreenPixel(m_pWin->GetPointerPosPixel()));
645 0 : aPnt = m_pWin->PixelToLogic(m_pWin->ScreenToOutputPixel(aPnt));
646 0 : const Pointer aPointTyp = pSdrView->GetPreferedPointer(aPnt, m_pSh->GetOut());
647 0 : const Pointer aDrawPt(aPointTyp);
648 0 : m_pWin->SetPointer(aDrawPt);
649 0 : }
650 :
651 : /*************************************************************************
652 : |*
653 : |* Ggf in Selektionsmode wechseln
654 : |*
655 : \************************************************************************/
656 :
657 0 : void SwDrawBase::EnterSelectMode(const MouseEvent& rMEvt)
658 : {
659 0 : m_pWin->SetDrawAction(sal_False);
660 :
661 0 : if (!m_pSh->IsObjSelected() && !m_pWin->IsDrawAction())
662 : {
663 0 : Point aPnt(m_pWin->PixelToLogic(rMEvt.GetPosPixel()));
664 :
665 0 : if (m_pSh->IsObjSelectable(aPnt))
666 : {
667 0 : m_pSh->SelectObj(aPnt);
668 0 : if (rMEvt.GetModifier() == KEY_SHIFT || !m_pSh->IsObjSelected())
669 : {
670 0 : m_pView->LeaveDrawCreate(); // In Selektionsmode wechseln
671 :
672 0 : m_pSh->GetView().GetViewFrame()->GetBindings().Invalidate(SID_INSERT_DRAW);
673 : }
674 : }
675 : else
676 : {
677 0 : m_pView->LeaveDrawCreate();
678 0 : if (m_pSh->IsSelFrmMode())
679 0 : m_pSh->LeaveSelFrmMode();
680 : }
681 0 : m_pView->NoRotate();
682 : }
683 0 : }
684 :
685 0 : void SwDrawBase::CreateDefaultObject()
686 : {
687 0 : Point aStartPos = GetDefaultCenterPos();
688 0 : Point aEndPos(aStartPos);
689 0 : aStartPos.X() -= 8 * MM50;
690 0 : aStartPos.Y() -= 4 * MM50;
691 0 : aEndPos.X() += 8 * MM50;
692 0 : aEndPos.Y() += 4 * MM50;
693 0 : Rectangle aRect(aStartPos, aEndPos);
694 0 : m_pSh->CreateDefaultShape( static_cast< sal_uInt16 >(m_pWin->GetSdrDrawMode()), aRect, m_nSlotId);
695 0 : }
696 :
697 0 : Point SwDrawBase::GetDefaultCenterPos()
698 : {
699 0 : Size aDocSz(m_pSh->GetDocSize());
700 0 : const SwRect& rVisArea = m_pSh->VisArea();
701 0 : Point aStartPos = rVisArea.Center();
702 0 : if(rVisArea.Width() > aDocSz.Width())
703 0 : aStartPos.X() = aDocSz.Width() / 2 + rVisArea.Left();
704 0 : if(rVisArea.Height() > aDocSz.Height())
705 0 : aStartPos.Y() = aDocSz.Height() / 2 + rVisArea.Top();
706 0 : return aStartPos;
707 : }
708 :
709 : // #i33136#
710 0 : bool SwDrawBase::doConstructOrthogonal() const
711 : {
712 0 : return false;
713 : }
714 :
715 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
