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 : #include "futext.hxx"
21 : #include <editeng/eeitem.hxx>
22 : #include <editeng/editerr.hxx>
23 : #include <svx/dlgutil.hxx>
24 : #include <svx/svxerr.hxx>
25 : #include <tools/urlobj.hxx>
26 : #include <vcl/help.hxx>
27 : #include <editeng/editstat.hxx>
28 : #include <svl/aeitem.hxx>
29 : #include <svl/intitem.hxx>
30 : #include <svx/svdotext.hxx>
31 : #include <svx/svdogrp.hxx>
32 : #include <editeng/flditem.hxx>
33 : #include <svl/style.hxx>
34 : #include <svx/svdpagv.hxx>
35 : #include <sfx2/viewfrm.hxx>
36 : #include <sfx2/dispatch.hxx>
37 : #include <sfx2/bindings.hxx>
38 : #include <sfx2/request.hxx>
39 : #include <editeng/editeng.hxx>
40 : #include <svx/svdoutl.hxx>
41 : #include <svx/svxids.hrc>
42 : #include <sfx2/docfile.hxx>
43 : #include <comphelper/processfactory.hxx>
44 : #include <editeng/outlobj.hxx>
45 : #include <svtools/langtab.hxx>
46 :
47 : #include <editeng/frmdiritem.hxx>
48 :
49 : #include <svx/svdetc.hxx>
50 : #include <editeng/editview.hxx>
51 :
52 : #include "sdresid.hxx"
53 : #include "app.hrc"
54 : #include "res_bmp.hrc"
55 : #include "ViewShell.hxx"
56 : #include "ViewShellBase.hxx"
57 : #include "View.hxx"
58 : #include "Outliner.hxx"
59 : #include "Window.hxx"
60 : #include "drawdoc.hxx"
61 : #include "sdpage.hxx"
62 : #include "sdmod.hxx"
63 : #include "FrameView.hxx"
64 : #include "ToolBarManager.hxx"
65 : #include "DrawDocShell.hxx"
66 : #include "glob.hrc"
67 : #include "pres.hxx"
68 : #include "optsitem.hxx"
69 :
70 : using ::rtl::OUString;
71 : using namespace ::com::sun::star;
72 : using namespace ::com::sun::star::uno;
73 : using namespace ::com::sun::star::lang;
74 : using namespace ::com::sun::star::linguistic2;
75 :
76 : namespace sd {
77 :
78 : static sal_uInt16 SidArray[] = {
79 : SID_STYLE_FAMILY2, // 5542
80 : SID_STYLE_FAMILY5, // 5545
81 : SID_REDO, // 5700
82 : SID_UNDO, // 5701
83 : SID_CUT, // 5710
84 : SID_COPY, // 5711
85 : SID_ATTR_TABSTOP, // 10002
86 : SID_ATTR_CHAR_FONT, // 10007
87 : SID_ATTR_CHAR_POSTURE, // 10008
88 : SID_ATTR_CHAR_WEIGHT, // 10009
89 : SID_ATTR_CHAR_UNDERLINE, // 10014
90 : SID_ATTR_CHAR_FONTHEIGHT, // 10015
91 : SID_ATTR_CHAR_COLOR, // 10017
92 : SID_ATTR_PARA_ADJUST_LEFT, // 10028
93 : SID_ATTR_PARA_ADJUST_RIGHT, // 10029
94 : SID_ATTR_PARA_ADJUST_CENTER, // 10030
95 : SID_ATTR_PARA_ADJUST_BLOCK, // 10031
96 : SID_ATTR_PARA_LINESPACE_10, // 10034
97 : SID_ATTR_PARA_LINESPACE_15, // 10035
98 : SID_ATTR_PARA_LINESPACE_20, // 10036
99 : SID_ATTR_PARA_LRSPACE, // 10043
100 : SID_OUTLINE_UP, // 10150
101 : SID_OUTLINE_DOWN, // 10151
102 : SID_OUTLINE_LEFT, // 10152
103 : SID_OUTLINE_RIGHT, // 10153
104 : SID_FORMTEXT_STYLE, // 10257
105 : SID_SET_SUPER_SCRIPT, // 10294
106 : SID_SET_SUB_SCRIPT, // 10295
107 : SID_HYPERLINK_GETLINK, // 10361
108 : SID_CHARMAP, // 10503
109 : SID_TEXTDIRECTION_LEFT_TO_RIGHT, // 10907
110 : SID_TEXTDIRECTION_TOP_TO_BOTTOM, // 10908
111 : SID_ATTR_PARA_LEFT_TO_RIGHT, // 10950
112 : SID_ATTR_PARA_RIGHT_TO_LEFT, // 10951
113 : FN_NUM_BULLET_ON, // 20138
114 : SID_PARASPACE_INCREASE, // 27346
115 : SID_PARASPACE_DECREASE, // 27347
116 : 0 };
117 :
118 0 : TYPEINIT1( FuText, FuConstruct );
119 :
120 :
121 : static sal_Bool bTestText = 0;
122 :
123 : /*************************************************************************
124 : |*
125 : |* Basisklasse fuer Textfunktionen
126 : |*
127 : \************************************************************************/
128 :
129 0 : FuText::FuText( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq )
130 : : FuConstruct(pViewSh, pWin, pView, pDoc, rReq)
131 : , bFirstObjCreated(sal_False)
132 : , bJustEndedEdit(false)
133 0 : , rRequest (rReq)
134 : {
135 0 : }
136 :
137 0 : FunctionReference FuText::Create( ViewShell* pViewSh, ::sd::Window* pWin, ::sd::View* pView, SdDrawDocument* pDoc, SfxRequest& rReq )
138 : {
139 0 : FunctionReference xFunc( new FuText( pViewSh, pWin, pView, pDoc, rReq ) );
140 0 : return xFunc;
141 : }
142 :
143 : /*************************************************************************
144 : |*
145 : |* Destruktor
146 : |*
147 : \************************************************************************/
148 :
149 0 : void FuText::disposing()
150 : {
151 0 : if(mpView)
152 : {
153 0 : if(mpView->SdrEndTextEdit(sal_False) == SDRENDTEXTEDIT_DELETED)
154 0 : mxTextObj.reset( 0 );
155 :
156 : // die RequestHandler der benutzten Outliner zuruecksetzen auf den
157 : // Handler am Dokument
158 0 : ::Outliner* pOutliner = mpView->GetTextEditOutliner();
159 :
160 0 : if (pOutliner)
161 0 : pOutliner->SetStyleSheetPool(static_cast<SfxStyleSheetPool*>(mpDoc->GetStyleSheetPool()));
162 : }
163 0 : }
164 :
165 : /*************************************************************************
166 : |*
167 : |* Execute functionality of this class:
168 : |*
169 : |* #71422: Start the functionality of this class in this method
170 : |* and not in the ctor.
171 : |* If you construct an object of this class and you put the
172 : |* address of this object to pFuActual you've got a problem,
173 : |* because some methods inside DoExecute use the pFuActual-Pointer.
174 : |* If the code inside DoExecute is executed inside the ctor,
175 : |* the value of pFuActual is not right. And the value will not
176 : |* be right until the ctor finished !!!
177 : |*
178 : \************************************************************************/
179 0 : void FuText::DoExecute( SfxRequest& )
180 : {
181 0 : mpViewShell->GetViewShellBase().GetToolBarManager()->SetToolBarShell(
182 : ToolBarManager::TBG_FUNCTION,
183 0 : RID_DRAW_TEXT_TOOLBOX);
184 :
185 0 : mpView->SetCurrentObj(OBJ_TEXT);
186 0 : mpView->SetEditMode(SDREDITMODE_EDIT);
187 :
188 0 : MouseEvent aMEvt(mpWindow->GetPointerPosPixel());
189 :
190 0 : if (nSlotId == SID_TEXTEDIT)
191 : {
192 : // Try to select an object
193 0 : SdrPageView* pPV = mpView->GetSdrPageView();
194 0 : SdrViewEvent aVEvt;
195 0 : mpView->PickAnything(aMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
196 0 : mpView->MarkObj(aVEvt.pRootObj, pPV);
197 :
198 0 : mxTextObj.reset( dynamic_cast< SdrTextObj* >( aVEvt.pObj ) );
199 : }
200 0 : else if (mpView->AreObjectsMarked())
201 : {
202 0 : const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
203 :
204 0 : if (rMarkList.GetMarkCount() == 1)
205 : {
206 0 : SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
207 0 : mxTextObj.reset( dynamic_cast< SdrTextObj* >( pObj ) );
208 : }
209 : }
210 :
211 : // check for table
212 0 : if (mpView->AreObjectsMarked())
213 : {
214 0 : const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
215 :
216 0 : if (rMarkList.GetMarkCount() == 1)
217 : {
218 0 : SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
219 0 : if( pObj && (pObj->GetObjInventor() == SdrInventor ) && (pObj->GetObjIdentifier() == OBJ_TABLE) )
220 : {
221 0 : mpViewShell->GetViewShellBase().GetToolBarManager()->AddToolBarShell( ToolBarManager::TBG_FUNCTION, RID_DRAW_TABLE_TOOLBOX );
222 : }
223 : }
224 : }
225 :
226 0 : sal_Bool bQuickDrag = sal_True;
227 :
228 0 : const SfxItemSet* pArgs = rRequest.GetArgs();
229 :
230 0 : if (pArgs
231 :
232 : // test for type before using
233 : && SID_TEXTEDIT == nSlotId
234 0 : && SFX_ITEM_SET == pArgs->GetItemState(SID_TEXTEDIT)
235 :
236 0 : && (sal_uInt16)((SfxUInt16Item&)pArgs->Get(SID_TEXTEDIT)).GetValue() == 2)
237 : {
238 : // Selection by doubleclick -> don't allow QuickDrag
239 0 : bQuickDrag = sal_False;
240 : }
241 :
242 0 : SetInEditMode(aMEvt, bQuickDrag);
243 0 : }
244 :
245 : /*************************************************************************
246 : |*
247 : |* MouseButtonDown-event
248 : |*
249 : \************************************************************************/
250 :
251 0 : sal_Bool FuText::MouseButtonDown(const MouseEvent& rMEvt)
252 : {
253 0 : bMBDown = sal_True;
254 :
255 0 : sal_Bool bReturn = FuDraw::MouseButtonDown(rMEvt);
256 :
257 0 : mpView->SetMarkHdlWhenTextEdit(sal_True);
258 0 : SdrViewEvent aVEvt;
259 0 : SdrHitKind eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
260 :
261 0 : if (eHit == SDRHIT_TEXTEDIT)
262 : {
263 : // Text getroffen -> Event von SdrView auswerten lassen
264 0 : if (mpView->MouseButtonDown(rMEvt, mpWindow))
265 0 : return (sal_True);
266 : }
267 :
268 0 : if (rMEvt.GetClicks() == 1)
269 : {
270 0 : if (mpView->IsTextEdit() && eHit != SDRHIT_MARKEDOBJECT && eHit != SDRHIT_HANDLE)
271 : {
272 : // Texteingabe beenden
273 0 : if(mpView->SdrEndTextEdit() == SDRENDTEXTEDIT_DELETED)
274 : {
275 : // Bugfix von MBA: bei Doppelclick auf der Wiese im Modus Text wird
276 : // beim zweiten Click eHit = SDRHIT_TEXTEDITOBJ erhalten, weil ja der
277 : // zweite Click auf das im ersten Click angelegte TextObject geht.
278 : // Dieses wird aber in SdrEndTextEdit entfernt, weil es leer ist. Es
279 : // befindet sich aber noch in der Mark-Liste und der Aufruf MarkObj
280 : // weiter unten greift dann auf das tote Object zu.
281 : // Als einfacher Fix wird nach SdrEndTextEdit noch einmal eHit ermittelt,
282 : // was dann SDRHIT_NONE liefert.
283 0 : mxTextObj.reset( NULL );
284 0 : eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
285 : }
286 :
287 0 : mpView->SetCurrentObj(OBJ_TEXT);
288 0 : mpView->SetEditMode(SDREDITMODE_EDIT);
289 : }
290 :
291 0 : if (rMEvt.IsLeft() || rMEvt.IsRight())
292 : {
293 0 : mpWindow->CaptureMouse();
294 : SdrObject* pObj;
295 0 : SdrPageView* pPV = mpView->GetSdrPageView();
296 :
297 0 : if (eHit == SDRHIT_TEXTEDIT)
298 : {
299 0 : SetInEditMode(rMEvt, sal_False);
300 : }
301 : else
302 : {
303 0 : sal_Bool bMacro = sal_False;
304 :
305 0 : if (bMacro && mpView->PickObj(aMDPos,mpView->getHitTolLog(),pObj,pPV,SDRSEARCH_PICKMACRO))
306 : {
307 : // Makro
308 0 : sal_uInt16 nHitLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(HITPIX,0)).Width() );
309 0 : mpView->BegMacroObj(aMDPos,nHitLog,pObj,pPV,mpWindow);
310 : }
311 : else
312 : {
313 0 : if (eHit != SDRHIT_HANDLE)
314 : {
315 : // Selektion aufheben
316 0 : if (!rMEvt.IsShift() && eHit == SDRHIT_TEXTEDITOBJ)
317 : {
318 0 : mpView->UnmarkAll();
319 0 : mpView->SetDragMode(SDRDRAG_MOVE);
320 : }
321 : }
322 :
323 0 : if ( aVEvt.eEvent == SDREVENT_EXECUTEURL ||
324 : eHit == SDRHIT_HANDLE ||
325 : eHit == SDRHIT_MARKEDOBJECT ||
326 : eHit == SDRHIT_TEXTEDITOBJ ||
327 : ( eHit == SDRHIT_UNMARKEDOBJECT && bFirstObjCreated &&
328 0 : !bPermanent ) )
329 : {
330 : /**********************************************************
331 : * Handle, markiertes oder unmarkiertes Objekt getroffen
332 : **********************************************************/
333 0 : if (eHit == SDRHIT_TEXTEDITOBJ)
334 : {
335 : /******************************************************
336 : * Text eines unmarkierten Objekts getroffen:
337 : * Objekt wird selektiert und in EditMode versetzt
338 : ******************************************************/
339 0 : mpView->MarkObj(aVEvt.pRootObj, pPV);
340 :
341 0 : if (aVEvt.pObj && aVEvt.pObj->ISA(SdrTextObj))
342 : {
343 0 : mxTextObj.reset( static_cast<SdrTextObj*>(aVEvt.pObj) );
344 : }
345 :
346 0 : SetInEditMode(rMEvt, sal_True);
347 : }
348 0 : else if (aVEvt.eEvent == SDREVENT_EXECUTEURL && !rMEvt.IsMod2())
349 : {
350 : /******************************************************
351 : * URL ausfuehren
352 : ******************************************************/
353 0 : mpWindow->ReleaseMouse();
354 0 : SfxStringItem aStrItem(SID_FILE_NAME, aVEvt.pURLField->GetURL());
355 0 : SfxStringItem aReferer(SID_REFERER, mpDocSh->GetMedium()->GetName());
356 0 : SfxBoolItem aBrowseItem( SID_BROWSE, sal_True );
357 0 : SfxViewFrame* pFrame = mpViewShell->GetViewFrame();
358 0 : mpWindow->ReleaseMouse();
359 :
360 0 : if (rMEvt.IsMod1())
361 : {
362 : // Im neuen Frame oeffnen
363 : pFrame->GetDispatcher()->Execute(SID_OPENDOC, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
364 0 : &aStrItem, &aBrowseItem, &aReferer, 0L);
365 : }
366 : else
367 : {
368 : // Im aktuellen Frame oeffnen
369 0 : SfxFrameItem aFrameItem(SID_DOCFRAME, pFrame);
370 : pFrame->GetDispatcher()->Execute(SID_OPENDOC, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD,
371 0 : &aStrItem, &aFrameItem, &aBrowseItem, &aReferer, 0L);
372 0 : }
373 : }
374 : else
375 : {
376 : /******************************************************
377 : * Objekt oder Handle draggen
378 : ******************************************************/
379 :
380 : // #i78748#
381 : // do the EndTextEdit first, it will delete the handles and force a
382 : // recreation. This will make aVEvt.pHdl to point to a deleted handle,
383 : // thus it is necessary to reset it and to get it again.
384 :
385 : // #i112855#
386 : // cl: I'm not sure why we checked here also for mxTextObj->GetOutlinerParaObjet
387 : // this caused SdrEndTextEdit() to be called also when not in text editing and
388 : // this does not make sense and caused troubles. (see issue 112855)
389 :
390 0 : if( mpView->IsTextEdit() )
391 : {
392 0 : mpView->SdrEndTextEdit();
393 0 : bJustEndedEdit = true;
394 :
395 0 : if(aVEvt.pHdl)
396 : {
397 : // force new handle identification, the pointer will be dead here
398 : // since SdrEndTextEdit has resetted (deleted) the handles.
399 0 : aVEvt.pHdl = 0;
400 0 : mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
401 : }
402 : }
403 :
404 0 : if (!aVEvt.pHdl)
405 : {
406 0 : if( eHit == SDRHIT_UNMARKEDOBJECT )
407 : {
408 0 : if ( !rMEvt.IsShift() )
409 0 : mpView->UnmarkAll();
410 :
411 0 : mpView->MarkObj(aVEvt.pRootObj, pPV);
412 : }
413 :
414 : // Drag object
415 0 : bFirstMouseMove = sal_True;
416 0 : aDragTimer.Start();
417 : }
418 :
419 :
420 0 : if ( ! rMEvt.IsRight())
421 : {
422 : // we need to pick again since SdrEndTextEdit can rebuild the handles list
423 0 : eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
424 0 : if( (eHit == SDRHIT_HANDLE) || (eHit == SDRHIT_MARKEDOBJECT) )
425 : {
426 0 : sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
427 0 : mpView->BegDragObj(aMDPos, (OutputDevice*) NULL, aVEvt.pHdl, nDrgLog);
428 : }
429 : }
430 0 : bReturn = true;
431 0 : }
432 : }
433 0 : else if ( nSlotId != SID_TEXTEDIT &&
434 0 : (bPermanent || !bFirstObjCreated) )
435 : {
436 : /**********************************************************
437 : * Objekt erzeugen
438 : **********************************************************/
439 0 : mpView->SetCurrentObj(OBJ_TEXT);
440 0 : mpView->SetEditMode(SDREDITMODE_CREATE);
441 0 : sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
442 0 : mpView->BegCreateObj(aMDPos, (OutputDevice*) NULL, nDrgLog);
443 : }
444 : else
445 : {
446 : /**********************************************************
447 : * Selektieren
448 : **********************************************************/
449 0 : if( !rMEvt.IsShift() )
450 0 : mpView->UnmarkAll();
451 :
452 0 : mpView->BegMarkObj( aMDPos );
453 : }
454 : }
455 : }
456 : }
457 : }
458 0 : else if ( rMEvt.GetClicks() == 2 && !mpView->IsTextEdit() )
459 : {
460 0 : MouseEvent aMEvt( mpWindow->GetPointerPosPixel() );
461 0 : SetInEditMode( aMEvt, sal_False );
462 : }
463 :
464 0 : if (!bIsInDragMode)
465 : {
466 0 : ForcePointer(&rMEvt);
467 0 : mpViewShell->GetViewFrame()->GetBindings().Invalidate(SidArray);
468 : }
469 :
470 0 : return (bReturn);
471 : }
472 :
473 : /*************************************************************************
474 : |*
475 : |* MouseMove-event
476 : |*
477 : \************************************************************************/
478 :
479 0 : sal_Bool FuText::MouseMove(const MouseEvent& rMEvt)
480 : {
481 0 : sal_Bool bReturn = FuDraw::MouseMove(rMEvt);
482 :
483 0 : if (aDragTimer.IsActive() )
484 : {
485 0 : if( bFirstMouseMove )
486 0 : bFirstMouseMove = sal_False;
487 : else
488 0 : aDragTimer.Stop();
489 : }
490 :
491 0 : if (!bReturn && mpView->IsAction() && !mpDocSh->IsReadOnly())
492 : {
493 0 : Point aPix(rMEvt.GetPosPixel());
494 0 : Point aPnt(mpWindow->PixelToLogic(aPix));
495 :
496 0 : ForceScroll(aPix);
497 0 : mpView->MovAction(aPnt);
498 : }
499 :
500 0 : ForcePointer(&rMEvt);
501 :
502 0 : return (bReturn);
503 : }
504 :
505 : /*************************************************************************
506 : |*
507 : |* MouseButtonUp-event
508 : |*
509 : \************************************************************************/
510 :
511 0 : void FuText::ImpSetAttributesForNewTextObject(SdrTextObj* pTxtObj)
512 : {
513 0 : if(mpDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS)
514 : {
515 0 : if( nSlotId == SID_ATTR_CHAR )
516 : {
517 : // Impress-Textobjekt wird erzeugt (faellt auf Zeilenhoehe zusammen)
518 : // Damit das Objekt beim anschliessenden Erzeugen gleich die richtige
519 : // Hoehe bekommt (sonst wird zuviel gepainted)
520 0 : SfxItemSet aSet(mpViewShell->GetPool());
521 0 : aSet.Put(SdrTextMinFrameHeightItem(0));
522 0 : aSet.Put(SdrTextAutoGrowWidthItem(sal_False));
523 0 : aSet.Put(SdrTextAutoGrowHeightItem(sal_True));
524 0 : pTxtObj->SetMergedItemSet(aSet);
525 0 : pTxtObj->AdjustTextFrameWidthAndHeight();
526 0 : aSet.Put(SdrTextMaxFrameHeightItem(pTxtObj->GetLogicRect().GetSize().Height()));
527 0 : pTxtObj->SetMergedItemSet(aSet);
528 : }
529 0 : else if( nSlotId == SID_ATTR_CHAR_VERTICAL )
530 : {
531 0 : SfxItemSet aSet(mpViewShell->GetPool());
532 0 : aSet.Put(SdrTextMinFrameWidthItem(0));
533 0 : aSet.Put(SdrTextAutoGrowWidthItem(sal_True));
534 0 : aSet.Put(SdrTextAutoGrowHeightItem(sal_False));
535 :
536 : // Needs to be set since default is SDRTEXTHORZADJUST_BLOCK
537 0 : aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT));
538 0 : pTxtObj->SetMergedItemSet(aSet);
539 0 : pTxtObj->AdjustTextFrameWidthAndHeight();
540 0 : aSet.Put(SdrTextMaxFrameWidthItem(pTxtObj->GetLogicRect().GetSize().Width()));
541 0 : pTxtObj->SetMergedItemSet(aSet);
542 : }
543 : }
544 : else
545 : {
546 0 : if( nSlotId == SID_ATTR_CHAR_VERTICAL )
547 : {
548 : // draw text object, needs to be initialized when vertical text is used
549 0 : SfxItemSet aSet(mpViewShell->GetPool());
550 :
551 0 : aSet.Put(SdrTextAutoGrowWidthItem(sal_True));
552 0 : aSet.Put(SdrTextAutoGrowHeightItem(sal_False));
553 :
554 : // Set defaults for vertical klick-n'drag text object, pool defaults are:
555 : // SdrTextVertAdjustItem: SDRTEXTVERTADJUST_TOP
556 : // SdrTextHorzAdjustItem: SDRTEXTHORZADJUST_BLOCK
557 : // Analog to that:
558 0 : aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BLOCK));
559 0 : aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT));
560 :
561 0 : pTxtObj->SetMergedItemSet(aSet);
562 : }
563 : }
564 0 : }
565 :
566 0 : void FuText::ImpSetAttributesFitToSize(SdrTextObj* pTxtObj)
567 : {
568 : // FitToSize (An Rahmen anpassen)
569 0 : SfxItemSet aSet(mpViewShell->GetPool(), SDRATTR_TEXT_AUTOGROWHEIGHT, SDRATTR_TEXT_AUTOGROWWIDTH);
570 0 : SdrFitToSizeType eFTS = SDRTEXTFIT_PROPORTIONAL;
571 0 : aSet.Put(SdrTextFitToSizeTypeItem(eFTS));
572 0 : aSet.Put(SdrTextAutoGrowHeightItem(sal_False));
573 0 : aSet.Put(SdrTextAutoGrowWidthItem(sal_False));
574 0 : pTxtObj->SetMergedItemSet(aSet);
575 0 : pTxtObj->AdjustTextFrameWidthAndHeight();
576 0 : }
577 :
578 0 : void FuText::ImpSetAttributesFitToSizeVertical(SdrTextObj* pTxtObj)
579 : {
580 0 : SfxItemSet aSet(mpViewShell->GetPool(),
581 0 : SDRATTR_TEXT_AUTOGROWHEIGHT, SDRATTR_TEXT_AUTOGROWWIDTH);
582 0 : SdrFitToSizeType eFTS = SDRTEXTFIT_PROPORTIONAL;
583 0 : aSet.Put(SdrTextFitToSizeTypeItem(eFTS));
584 0 : aSet.Put(SdrTextAutoGrowHeightItem(sal_False));
585 0 : aSet.Put(SdrTextAutoGrowWidthItem(sal_False));
586 0 : pTxtObj->SetMergedItemSet(aSet);
587 0 : pTxtObj->AdjustTextFrameWidthAndHeight();
588 0 : }
589 :
590 0 : void FuText::ImpSetAttributesFitCommon(SdrTextObj* pTxtObj)
591 : {
592 : // Normal Textobject
593 0 : if (mpDoc->GetDocumentType() == DOCUMENT_TYPE_IMPRESS)
594 : {
595 0 : if( nSlotId == SID_ATTR_CHAR )
596 : {
597 : // Impress-Textobject (faellt auf Zeilenhoehe zusammen)
598 0 : SfxItemSet aSet(mpViewShell->GetPool());
599 0 : aSet.Put(SdrTextMinFrameHeightItem(0));
600 0 : aSet.Put(SdrTextMaxFrameHeightItem(0));
601 0 : aSet.Put(SdrTextAutoGrowHeightItem(sal_True));
602 0 : aSet.Put(SdrTextAutoGrowWidthItem(sal_False));
603 0 : pTxtObj->SetMergedItemSet(aSet);
604 : }
605 0 : else if( nSlotId == SID_ATTR_CHAR_VERTICAL )
606 : {
607 0 : SfxItemSet aSet(mpViewShell->GetPool());
608 0 : aSet.Put(SdrTextMinFrameWidthItem(0));
609 0 : aSet.Put(SdrTextMaxFrameWidthItem(0));
610 0 : aSet.Put(SdrTextAutoGrowWidthItem(sal_True));
611 0 : aSet.Put(SdrTextAutoGrowHeightItem(sal_False));
612 0 : pTxtObj->SetMergedItemSet(aSet);
613 : }
614 :
615 0 : pTxtObj->AdjustTextFrameWidthAndHeight();
616 : }
617 0 : }
618 :
619 0 : sal_Bool FuText::MouseButtonUp(const MouseEvent& rMEvt)
620 : {
621 0 : sal_Bool bReturn = sal_False;
622 : SdrObject* pObj;
623 : SdrPageView* pPV;
624 0 : if (aDragTimer.IsActive())
625 : {
626 0 : aDragTimer.Stop();
627 0 : bIsInDragMode = sal_False;
628 : }
629 :
630 0 : mpViewShell->GetViewFrame()->GetBindings().Invalidate( SidArray );
631 :
632 0 : Point aPnt( mpWindow->PixelToLogic( rMEvt.GetPosPixel() ) );
633 :
634 0 : if( (mpView && mpView->MouseButtonUp(rMEvt, mpWindow)) || rMEvt.GetClicks() == 2 )
635 0 : return (sal_True); // Event von der SdrView ausgewertet
636 :
637 0 : sal_Bool bEmptyTextObj = sal_False;
638 :
639 0 : if (mxTextObj.is())
640 : {
641 0 : const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
642 :
643 0 : if (rMarkList.GetMarkCount() == 1
644 0 : && ( rMarkList.GetMark(0)->GetMarkedSdrObj() == mxTextObj.get()) )
645 : {
646 0 : if( mxTextObj.is() && !GetTextObj()->GetOutlinerParaObject() )
647 0 : bEmptyTextObj = sal_True;
648 : else
649 0 : bFirstObjCreated = sal_True;
650 : }
651 : else
652 : {
653 0 : mxTextObj.reset( 0 );
654 : }
655 : }
656 :
657 0 : if( mpView && mpView->IsDragObj())
658 : {
659 : /**********************************************************************
660 : * Objekt wurde verschoben
661 : **********************************************************************/
662 0 : FrameView* pFrameView = mpViewShell->GetFrameView();
663 0 : sal_Bool bDragWithCopy = (rMEvt.IsMod1() && pFrameView->IsDragWithCopy());
664 :
665 0 : if (bDragWithCopy)
666 : {
667 0 : bDragWithCopy = !mpView->IsPresObjSelected(sal_False, sal_True);
668 : }
669 :
670 0 : mpView->SetDragWithCopy(bDragWithCopy);
671 0 : mpView->EndDragObj( mpView->IsDragWithCopy() );
672 0 : mpView->ForceMarkedToAnotherPage();
673 0 : mpView->SetCurrentObj(OBJ_TEXT);
674 :
675 0 : sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
676 :
677 0 : if ( mpView->IsRotateAllowed() && mpViewShell->GetFrameView()->IsClickChangeRotation() && (rMEvt.GetClicks() != 2) && !bJustEndedEdit &&
678 0 : !rMEvt.IsShift() && !rMEvt.IsMod1() && !rMEvt.IsMod2() && !rMEvt.IsRight() &&
679 0 : Abs(aPnt.X() - aMDPos.X()) < nDrgLog &&
680 0 : Abs(aPnt.Y() - aMDPos.Y()) < nDrgLog)
681 : {
682 : /*************************************************************
683 : * If a user wants to click on an object in front of a masked
684 : * one, he releases the mouse button immediately
685 : **************************************************************/
686 0 : if (mpView->PickObj(aMDPos, mpView->getHitTolLog(), pObj, pPV, SDRSEARCH_ALSOONMASTER | SDRSEARCH_BEFOREMARK))
687 : {
688 0 : mpView->UnmarkAllObj();
689 0 : mpView->MarkObj(pObj,pPV,false,false);
690 0 : return (bReturn);
691 : }
692 : // toggle to rotation mode
693 0 : mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_OBJECT_ROTATE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD );
694 : }
695 :
696 0 : if( bJustEndedEdit )
697 0 : bJustEndedEdit = false;
698 : }
699 0 : else if( mpView && mpView->IsCreateObj() && rMEvt.IsLeft())
700 : {
701 : /**********************************************************************
702 : * Objekt wurde erzeugt
703 : **********************************************************************/
704 0 : mxTextObj.reset( dynamic_cast< SdrTextObj* >( mpView->GetCreateObj() ) );
705 :
706 0 : if( mxTextObj.is() )
707 : {
708 : //AW outliner needs to be set to vertical when there is no
709 : // outliner object up to now; also it needs to be set back to not
710 : // vertical when there was a vertical one used last time.
711 0 : OutlinerParaObject* pOPO = GetTextObj()->GetOutlinerParaObject();
712 0 : SdrOutliner& rOutl = mxTextObj->GetModel()->GetDrawOutliner(GetTextObj());
713 0 : sal_Bool bVertical((pOPO && pOPO->IsVertical())
714 : || nSlotId == SID_ATTR_CHAR_VERTICAL
715 0 : || nSlotId == SID_TEXT_FITTOSIZE_VERTICAL);
716 0 : rOutl.SetVertical(bVertical);
717 :
718 : // Before ImpSetAttributesForNewTextObject the vertical writing mode
719 : // needs to be set at the object. This is done here at the OutlinerParaObject
720 : // directly to not mirror the layout text items involved. These items will be set
721 : // from ImpSetAttributesForNewTextObject and below.
722 0 : OutlinerParaObject* pPara = GetTextObj()->GetOutlinerParaObject();
723 :
724 0 : if(!pPara)
725 : {
726 0 : GetTextObj()->ForceOutlinerParaObject();
727 0 : pPara = GetTextObj()->GetOutlinerParaObject();
728 : }
729 :
730 0 : if(pPara && (bool)bVertical != pPara->IsVertical())
731 : {
732 : // set ParaObject orientation accordingly
733 0 : pPara->SetVertical(bVertical);
734 : }
735 :
736 0 : ImpSetAttributesForNewTextObject(GetTextObj());
737 : }
738 :
739 0 : if (!mpView->EndCreateObj(SDRCREATE_FORCEEND))
740 : {
741 : // Textobjekt konnte nicht erzeugt werden
742 0 : mxTextObj.reset(0);
743 : }
744 0 : else if (nSlotId == SID_TEXT_FITTOSIZE)
745 : {
746 0 : ImpSetAttributesFitToSize(GetTextObj());
747 :
748 0 : SetInEditMode(rMEvt, sal_False);
749 : }
750 0 : else if ( nSlotId == SID_TEXT_FITTOSIZE_VERTICAL )
751 : {
752 0 : ImpSetAttributesFitToSizeVertical(GetTextObj());
753 :
754 0 : SetInEditMode(rMEvt, sal_False);
755 : }
756 : else
757 : {
758 0 : ImpSetAttributesFitCommon(GetTextObj());
759 :
760 : // Damit die Handles und der graue Rahmen stimmen
761 0 : mpView->AdjustMarkHdl();
762 0 : mpView->PickHandle(aPnt);
763 0 : SetInEditMode(rMEvt, sal_False);
764 : }
765 : }
766 0 : else if ( mpView && mpView->IsAction())
767 : {
768 0 : mpView->EndAction();
769 : }
770 :
771 0 : ForcePointer(&rMEvt);
772 0 : mpWindow->ReleaseMouse();
773 0 : sal_uInt16 nDrgLog1 = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
774 :
775 0 : if ( mpView && !mpView->AreObjectsMarked() &&
776 0 : Abs(aMDPos.X() - aPnt.X()) < nDrgLog1 &&
777 0 : Abs(aMDPos.Y() - aPnt.Y()) < nDrgLog1 &&
778 0 : !rMEvt.IsShift() && !rMEvt.IsMod2() )
779 : {
780 0 : SdrPageView* pPV2 = mpView->GetSdrPageView();
781 0 : SdrViewEvent aVEvt;
782 0 : mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
783 0 : mpView->MarkObj(aVEvt.pRootObj, pPV2);
784 : }
785 :
786 0 : if ( !mxTextObj.is() && mpView )
787 : {
788 0 : if ( ( (!bEmptyTextObj && bPermanent) ||
789 0 : (!bFirstObjCreated && !bPermanent) ) &&
790 0 : !mpDocSh->IsReadOnly() &&
791 : nSlotId != SID_TEXTEDIT )
792 : {
793 : /**********************************************************************
794 : * Mengentext (linksbuendiges AutoGrow)
795 : **********************************************************************/
796 0 : mpView->SetCurrentObj(OBJ_TEXT);
797 0 : mpView->SetEditMode(SDREDITMODE_CREATE);
798 0 : sal_uInt16 nDrgLog = sal_uInt16 ( mpWindow->PixelToLogic(Size(DRGPIX,0)).Width() );
799 0 : mpView->BegCreateObj(aMDPos, (OutputDevice*) NULL, nDrgLog);
800 :
801 0 : sal_Bool bSnapEnabled = mpView->IsSnapEnabled();
802 :
803 0 : if (bSnapEnabled)
804 0 : mpView->SetSnapEnabled(sal_False);
805 :
806 0 : aPnt.X() += nDrgLog + nDrgLog;
807 0 : aPnt.Y() += nDrgLog + nDrgLog;
808 0 : mpView->MovAction(aPnt);
809 :
810 0 : mxTextObj.reset( dynamic_cast< SdrTextObj* >( mpView->GetCreateObj() ) );
811 :
812 0 : if(mxTextObj.is())
813 : {
814 0 : GetTextObj()->SetDisableAutoWidthOnDragging(sal_True);
815 : }
816 :
817 0 : if(!mpView->EndCreateObj(SDRCREATE_FORCEEND))
818 : {
819 0 : mxTextObj.reset(0);
820 : }
821 :
822 0 : if(bSnapEnabled)
823 0 : mpView->SetSnapEnabled(bSnapEnabled);
824 :
825 0 : if(mxTextObj.is())
826 : {
827 0 : SfxItemSet aSet(mpViewShell->GetPool());
828 0 : aSet.Put(SdrTextMinFrameHeightItem(0));
829 0 : aSet.Put(SdrTextMinFrameWidthItem(0));
830 0 : aSet.Put(SdrTextAutoGrowHeightItem(sal_True));
831 0 : aSet.Put(SdrTextAutoGrowWidthItem(sal_True));
832 :
833 0 : if(nSlotId == SID_ATTR_CHAR_VERTICAL)
834 : {
835 : // Here, all items which need to be different from pool default need to be set
836 : // again on the newly created text object.
837 : // Since this is a simple klick text object, it is first created, then SetVertical()
838 : // is used, then ImpSetAttributesForNewTextObject is called and then the object is
839 : // deleted again since not the minimum drag distance was travelled. Then, a new
840 : // klick text object is created and thus all that stuff needs to be set again here.
841 : //
842 : // Before using the new object the vertical writing mode
843 : // needs to be set. This is done here at the OutlinerParaObject
844 : // directly to not mirror the layout text items involved. These items will be set
845 : // below.
846 0 : OutlinerParaObject* pPara = GetTextObj()->GetOutlinerParaObject();
847 :
848 0 : if(!pPara)
849 : {
850 0 : GetTextObj()->ForceOutlinerParaObject();
851 0 : pPara = GetTextObj()->GetOutlinerParaObject();
852 : }
853 :
854 0 : if(pPara && sal_True != pPara->IsVertical())
855 : {
856 : // set ParaObject orientation accordingly
857 0 : pPara->SetVertical(sal_True);
858 : }
859 :
860 0 : aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT));
861 :
862 : // Analog to the else case below, for vertical simple click texts
863 : // one of the defaulted setted items from ImpSetAttributesForNewTextObject
864 : // needs to be adapted to non-block mode.
865 0 : const SfxItemSet& rSet = mpView->GetDefaultAttr();
866 0 : SvxFrameDirection eDirection = (SvxFrameDirection)((SvxFrameDirectionItem&)rSet.Get(EE_PARA_WRITINGDIR)).GetValue();
867 :
868 0 : if(FRMDIR_HORI_RIGHT_TOP == eDirection || FRMDIR_VERT_TOP_RIGHT == eDirection)
869 : {
870 0 : aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_BOTTOM));
871 : }
872 : else
873 : {
874 0 : aSet.Put(SdrTextVertAdjustItem(SDRTEXTVERTADJUST_TOP));
875 : }
876 : }
877 : else
878 : {
879 : // This is for Format/Page settings. Since this also leads
880 : // to the object defaults to be changed, i think this code can be
881 : // removed. CL. wanted to take a look before adding this.
882 :
883 : // Look in the object defaults if left-to-right is wanted. If
884 : // yes, set text anchoring to right to let the box grow to left.
885 0 : const SfxItemSet& rSet = mpView->GetDefaultAttr();
886 0 : SvxFrameDirection eDirection = (SvxFrameDirection)((SvxFrameDirectionItem&)rSet.Get(EE_PARA_WRITINGDIR)).GetValue();
887 :
888 0 : if(FRMDIR_HORI_RIGHT_TOP == eDirection)
889 : {
890 0 : aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_RIGHT));
891 : }
892 : else
893 : {
894 0 : aSet.Put(SdrTextHorzAdjustItem(SDRTEXTHORZADJUST_LEFT));
895 : }
896 : }
897 :
898 0 : GetTextObj()->SetMergedItemSet(aSet);
899 0 : GetTextObj()->SetDisableAutoWidthOnDragging(sal_True);
900 0 : SetInEditMode(rMEvt, sal_False);
901 : }
902 :
903 0 : bFirstObjCreated = sal_True;
904 : }
905 : else
906 : {
907 : // In die Fkt. Selektion wechseln
908 0 : if (mpView->SdrEndTextEdit() == SDRENDTEXTEDIT_DELETED)
909 : {
910 0 : mxTextObj.reset(0);
911 : }
912 :
913 : mpViewShell->GetViewFrame()->GetDispatcher()->Execute( SID_OBJECT_SELECT,
914 0 : SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD );
915 : }
916 : }
917 :
918 0 : bMBDown = sal_False;
919 0 : FuConstruct::MouseButtonUp(rMEvt);
920 0 : return (bReturn);
921 : }
922 :
923 : /*************************************************************************
924 : |*
925 : |* Tastaturereignisse bearbeiten
926 : |*
927 : |* Wird ein KeyEvent bearbeitet, so ist der Return-Wert sal_True, andernfalls
928 : |* sal_False.
929 : |*
930 : \************************************************************************/
931 :
932 0 : sal_Bool FuText::KeyInput(const KeyEvent& rKEvt)
933 : {
934 0 : sal_Bool bReturn = sal_False;
935 0 : mpView->SetMarkHdlWhenTextEdit(sal_True);
936 :
937 0 : KeyCode nCode = rKEvt.GetKeyCode();
938 0 : sal_Bool bShift = nCode.IsShift();
939 :
940 0 : if(mxTextObj.is())
941 : {
942 : // maybe object is deleted, test if it's equal to the selected object
943 0 : const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
944 0 : SdrObject* pSelectedObj = 0L;
945 :
946 0 : if(1 == rMarkList.GetMarkCount())
947 : {
948 0 : SdrMark* pMark = rMarkList.GetMark(0);
949 0 : pSelectedObj = pMark->GetMarkedSdrObj();
950 : }
951 :
952 0 : if(mxTextObj.get() != pSelectedObj)
953 : {
954 0 : mxTextObj.reset(0);
955 : }
956 : }
957 :
958 0 : if ( mxTextObj.is() && mxTextObj->GetObjInventor() == SdrInventor && mxTextObj->GetObjIdentifier() == OBJ_TITLETEXT && rKEvt.GetKeyCode().GetCode() == KEY_RETURN )
959 : {
960 : // Titeltext-Objekt: immer "weiche" Umbrueche
961 0 : bShift = sal_True;
962 : }
963 :
964 0 : sal_uInt16 nKey = nCode.GetCode();
965 0 : KeyCode aKeyCode (nKey, bShift, nCode.IsMod1(), nCode.IsMod2(), nCode.IsMod3() );
966 0 : KeyEvent aKEvt(rKEvt.GetCharCode(), aKeyCode);
967 :
968 0 : sal_Bool bOK = sal_True;
969 :
970 0 : if (mpDocSh->IsReadOnly())
971 : {
972 0 : bOK = !EditEngine::DoesKeyChangeText(aKEvt);
973 : }
974 0 : if( aKeyCode.GetCode() == KEY_PAGEUP || aKeyCode.GetCode() == KEY_PAGEDOWN )
975 : {
976 0 : bOK = sal_False; // default handling in base class
977 : }
978 :
979 0 : if (bOK && mpView->KeyInput(aKEvt, mpWindow) )
980 : {
981 0 : bReturn = sal_True;
982 :
983 0 : mpViewShell->GetViewFrame()->GetBindings().Invalidate( SidArray );
984 :
985 : }
986 0 : else if (aKeyCode == KEY_ESCAPE)
987 : {
988 0 : bReturn = cancel();
989 : }
990 :
991 0 : if( bPermanent )
992 : {
993 0 : mpView->SetCurrentObj(OBJ_TEXT);
994 0 : mpView->SetEditMode(SDREDITMODE_CREATE);
995 : }
996 :
997 0 : if (!bReturn)
998 : {
999 0 : bReturn = FuDraw::KeyInput(aKEvt);
1000 : }
1001 :
1002 0 : return (bReturn);
1003 : }
1004 :
1005 :
1006 :
1007 : /*************************************************************************
1008 : |*
1009 : |* Function aktivieren
1010 : |*
1011 : \************************************************************************/
1012 :
1013 0 : void FuText::Activate()
1014 : {
1015 0 : mpView->SetQuickTextEditMode(mpViewShell->GetFrameView()->IsQuickEdit());
1016 :
1017 : // #i89661# it's no longer necessary to make it so big here, it's fine tuned
1018 : // for text objects in SdrMarkView::CheckSingleSdrObjectHit
1019 0 : mpView->SetHitTolerancePixel( 2 * HITPIX );
1020 :
1021 0 : OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
1022 :
1023 0 : if (pOLV)
1024 0 : pOLV->ShowCursor();
1025 :
1026 0 : FuConstruct::Activate();
1027 :
1028 0 : if( pOLV )
1029 0 : mpView->SetEditMode(SDREDITMODE_EDIT);
1030 0 : }
1031 :
1032 :
1033 : /*************************************************************************
1034 : |*
1035 : |* Function deaktivieren
1036 : |*
1037 : \************************************************************************/
1038 :
1039 0 : void FuText::Deactivate()
1040 : {
1041 0 : OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
1042 :
1043 0 : if (pOLV)
1044 0 : pOLV->HideCursor();
1045 :
1046 0 : mpView->SetHitTolerancePixel( HITPIX );
1047 :
1048 0 : FuConstruct::Deactivate();
1049 0 : }
1050 :
1051 :
1052 : /*************************************************************************
1053 : |*
1054 : |* Objekt in Edit-Mode setzen
1055 : |*
1056 : \************************************************************************/
1057 :
1058 0 : void FuText::SetInEditMode(const MouseEvent& rMEvt, sal_Bool bQuickDrag)
1059 : {
1060 0 : SdrPageView* pPV = mpView->GetSdrPageView();
1061 0 : if( mxTextObj.is() && (mxTextObj->GetPage() == pPV->GetPage()) )
1062 : {
1063 0 : mpView->SetCurrentObj(OBJ_TEXT);
1064 :
1065 0 : if( bPermanent )
1066 0 : mpView->SetEditMode(SDREDITMODE_CREATE);
1067 : else
1068 0 : mpView->SetEditMode(SDREDITMODE_EDIT);
1069 :
1070 0 : sal_Bool bEmptyOutliner = sal_False;
1071 :
1072 0 : if (!GetTextObj()->GetOutlinerParaObject() && mpView->GetTextEditOutliner())
1073 : {
1074 0 : ::Outliner* pOutl = mpView->GetTextEditOutliner();
1075 0 : sal_uLong nParaAnz = pOutl->GetParagraphCount();
1076 0 : Paragraph* p1stPara = pOutl->GetParagraph( 0 );
1077 :
1078 0 : if (nParaAnz==1 && p1stPara)
1079 : {
1080 : // Bei nur einem Pararaph
1081 0 : if (pOutl->GetText(p1stPara).Len() == 0)
1082 : {
1083 0 : bEmptyOutliner = sal_True;
1084 : }
1085 : }
1086 : }
1087 :
1088 0 : if (GetTextObj() != mpView->GetTextEditObject() || bEmptyOutliner)
1089 : {
1090 0 : sal_uInt32 nInv = mxTextObj->GetObjInventor();
1091 0 : sal_uInt16 nSdrObjKind = mxTextObj->GetObjIdentifier();
1092 :
1093 0 : if (nInv == SdrInventor && GetTextObj()->HasTextEdit() &&
1094 : (nSdrObjKind == OBJ_TEXT ||
1095 : nSdrObjKind == OBJ_TITLETEXT ||
1096 0 : nSdrObjKind == OBJ_OUTLINETEXT || !mxTextObj->IsEmptyPresObj() ) )
1097 : {
1098 : // Neuen Outliner machen (gehoert der SdrObjEditView)
1099 0 : SdrOutliner* pOutl = SdrMakeOutliner( OUTLINERMODE_OUTLINEOBJECT, mpDoc );
1100 :
1101 0 : if (bEmptyOutliner)
1102 0 : mpView->SdrEndTextEdit(sal_True);
1103 :
1104 0 : SdrTextObj* pTextObj = GetTextObj();
1105 0 : if( pTextObj )
1106 : {
1107 0 : OutlinerParaObject* pOPO = pTextObj->GetOutlinerParaObject();
1108 0 : if( ( pOPO && pOPO->IsVertical() ) || (nSlotId == SID_ATTR_CHAR_VERTICAL) || (nSlotId == SID_TEXT_FITTOSIZE_VERTICAL) )
1109 0 : pOutl->SetVertical( sal_True );
1110 :
1111 0 : if( pTextObj->getTextCount() > 1 )
1112 : {
1113 0 : Point aPix(rMEvt.GetPosPixel());
1114 0 : Point aPnt(mpWindow->PixelToLogic(aPix));
1115 0 : pTextObj->setActiveText( pTextObj->CheckTextHit(aPnt ) );
1116 : }
1117 :
1118 0 : if (mpView->SdrBeginTextEdit(pTextObj, pPV, mpWindow, sal_True, pOutl) && mxTextObj->GetObjInventor() == SdrInventor)
1119 : {
1120 0 : bFirstObjCreated = sal_True;
1121 0 : DeleteDefaultText();
1122 :
1123 0 : OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
1124 :
1125 0 : nSdrObjKind = mxTextObj->GetObjIdentifier();
1126 :
1127 0 : SdrViewEvent aVEvt;
1128 0 : SdrHitKind eHit = mpView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
1129 :
1130 0 : if (eHit == SDRHIT_TEXTEDIT)
1131 : {
1132 : // Text getroffen
1133 0 : if (nSdrObjKind == OBJ_TEXT ||
1134 : nSdrObjKind == OBJ_TITLETEXT ||
1135 : nSdrObjKind == OBJ_OUTLINETEXT ||
1136 : nSdrObjKind == OBJ_TABLE ||
1137 : nSlotId == SID_TEXTEDIT ||
1138 : !bQuickDrag)
1139 : {
1140 0 : pOLV->MouseButtonDown(rMEvt);
1141 0 : pOLV->MouseMove(rMEvt);
1142 0 : pOLV->MouseButtonUp(rMEvt);
1143 : }
1144 :
1145 0 : if (mpViewShell->GetFrameView()->IsQuickEdit() && bQuickDrag && GetTextObj()->GetOutlinerParaObject())
1146 : {
1147 0 : pOLV->MouseButtonDown(rMEvt);
1148 : }
1149 : }
1150 : else
1151 : {
1152 : // Move cursor to end of text
1153 0 : ESelection aNewSelection(EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND, EE_PARA_NOT_FOUND, EE_INDEX_NOT_FOUND);
1154 0 : pOLV->SetSelection(aNewSelection);
1155 0 : }
1156 : }
1157 : else
1158 : {
1159 0 : mpView->RestoreDefaultText(dynamic_cast< SdrTextObj* >( mxTextObj.get() ));
1160 : }
1161 : }
1162 : }
1163 : }
1164 : }
1165 : else
1166 : {
1167 0 : mxTextObj.reset(0);
1168 : }
1169 0 : }
1170 :
1171 : /*************************************************************************
1172 : |*
1173 : |* Texteingabe wird gestartet, ggf. Default-Text loeschen
1174 : |*
1175 : \************************************************************************/
1176 :
1177 0 : sal_Bool FuText::DeleteDefaultText()
1178 : {
1179 0 : sal_Bool bDeleted = sal_False;
1180 :
1181 0 : if ( mxTextObj.is() && mxTextObj->IsEmptyPresObj() )
1182 : {
1183 0 : String aString;
1184 0 : SdPage* pPage = (SdPage*) mxTextObj->GetPage();
1185 :
1186 0 : if (pPage)
1187 : {
1188 0 : PresObjKind ePresObjKind = pPage->GetPresObjKind(mxTextObj.get());
1189 :
1190 0 : if ( (ePresObjKind == PRESOBJ_TITLE ||
1191 : ePresObjKind == PRESOBJ_OUTLINE ||
1192 : ePresObjKind == PRESOBJ_NOTES ||
1193 : ePresObjKind == PRESOBJ_TEXT) &&
1194 0 : !pPage->IsMasterPage() )
1195 : {
1196 0 : ::Outliner* pOutliner = mpView->GetTextEditOutliner();
1197 0 : SfxStyleSheet* pSheet = pOutliner->GetStyleSheet( 0 );
1198 0 : sal_Bool bIsUndoEnabled = pOutliner->IsUndoEnabled();
1199 0 : if( bIsUndoEnabled )
1200 0 : pOutliner->EnableUndo(sal_False);
1201 :
1202 0 : pOutliner->SetText( String(), pOutliner->GetParagraph( 0 ) );
1203 :
1204 0 : if( bIsUndoEnabled )
1205 0 : pOutliner->EnableUndo(sal_True);
1206 :
1207 0 : if (pSheet &&
1208 : (ePresObjKind == PRESOBJ_NOTES || ePresObjKind == PRESOBJ_TEXT))
1209 0 : pOutliner->SetStyleSheet(0, pSheet);
1210 :
1211 0 : mxTextObj->SetEmptyPresObj(sal_True);
1212 0 : bDeleted = sal_True;
1213 : }
1214 0 : }
1215 : }
1216 :
1217 0 : return(bDeleted);
1218 : }
1219 :
1220 : /*************************************************************************
1221 : |*
1222 : |* Command-event
1223 : |*
1224 : \************************************************************************/
1225 :
1226 0 : sal_Bool FuText::Command(const CommandEvent& rCEvt)
1227 : {
1228 0 : return( FuPoor::Command(rCEvt) );
1229 : }
1230 :
1231 : /*************************************************************************
1232 : |*
1233 : |* Help-event
1234 : |*
1235 : \************************************************************************/
1236 :
1237 0 : sal_Bool FuText::RequestHelp(const HelpEvent& rHEvt)
1238 : {
1239 0 : sal_Bool bReturn = sal_False;
1240 :
1241 0 : OutlinerView* pOLV = mpView->GetTextEditOutlinerView();
1242 :
1243 0 : if ((Help::IsBalloonHelpEnabled() || Help::IsQuickHelpEnabled()) &&
1244 0 : mxTextObj.is() && pOLV && pOLV->GetFieldUnderMousePointer())
1245 : {
1246 0 : String aHelpText;
1247 0 : const SvxFieldItem* pFieldItem = pOLV->GetFieldUnderMousePointer();
1248 0 : const SvxFieldData* pField = pFieldItem->GetField();
1249 :
1250 0 : if (pField && pField->ISA(SvxURLField))
1251 : {
1252 : /******************************************************************
1253 : * URL-Field
1254 : ******************************************************************/
1255 0 : aHelpText = INetURLObject::decode( ((const SvxURLField*)pField)->GetURL(), '%', INetURLObject::DECODE_WITH_CHARSET );
1256 : }
1257 0 : if (aHelpText.Len())
1258 : {
1259 0 : Rectangle aLogicPix = mpWindow->LogicToPixel(mxTextObj->GetLogicRect());
1260 0 : Rectangle aScreenRect(mpWindow->OutputToScreenPixel(aLogicPix.TopLeft()),
1261 0 : mpWindow->OutputToScreenPixel(aLogicPix.BottomRight()));
1262 :
1263 0 : if (Help::IsBalloonHelpEnabled())
1264 : {
1265 0 : bReturn = Help::ShowBalloon( (Window*)mpWindow, rHEvt.GetMousePosPixel(), aScreenRect, aHelpText);
1266 : }
1267 0 : else if (Help::IsQuickHelpEnabled())
1268 : {
1269 0 : bReturn = Help::ShowQuickHelp( (Window*)mpWindow, aScreenRect, aHelpText);
1270 : }
1271 0 : }
1272 : }
1273 :
1274 0 : if (!bReturn)
1275 : {
1276 0 : bReturn = FuConstruct::RequestHelp(rHEvt);
1277 : }
1278 :
1279 0 : return(bReturn);
1280 : }
1281 :
1282 : /*************************************************************************
1283 : |*
1284 : |* Request verarbeiten
1285 : |*
1286 : \************************************************************************/
1287 :
1288 0 : void FuText::ReceiveRequest(SfxRequest& rReq)
1289 : {
1290 0 : nSlotId = rReq.GetSlot();
1291 :
1292 : // Dann Basisklasse rufen (dort wird u.a. nSlotId NICHT gesetzt)
1293 0 : FuPoor::ReceiveRequest(rReq);
1294 :
1295 0 : if (nSlotId == SID_TEXTEDIT || mpViewShell->GetFrameView()->IsQuickEdit() || SID_ATTR_CHAR == nSlotId)
1296 : {
1297 0 : MouseEvent aMEvt(mpWindow->GetPointerPosPixel());
1298 :
1299 0 : mxTextObj.reset(0);
1300 :
1301 0 : if (nSlotId == SID_TEXTEDIT)
1302 : {
1303 : // Wird gerade editiert?
1304 0 : if(!bTestText)
1305 0 : mxTextObj.reset( dynamic_cast< SdrTextObj* >( mpView->GetTextEditObject() ) );
1306 :
1307 0 : if (!mxTextObj.is())
1308 : {
1309 : // Try to select an object
1310 0 : SdrPageView* pPV = mpView->GetSdrPageView();
1311 0 : SdrViewEvent aVEvt;
1312 0 : mpView->PickAnything(aMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
1313 0 : mpView->MarkObj(aVEvt.pRootObj, pPV);
1314 :
1315 0 : if (aVEvt.pObj && aVEvt.pObj->ISA(SdrTextObj))
1316 : {
1317 0 : mxTextObj.reset( static_cast< SdrTextObj* >( aVEvt.pObj ) );
1318 0 : }
1319 : }
1320 : }
1321 0 : else if (mpView->AreObjectsMarked())
1322 : {
1323 0 : const SdrMarkList& rMarkList = mpView->GetMarkedObjectList();
1324 :
1325 0 : if (rMarkList.GetMarkCount() == 1)
1326 : {
1327 0 : SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();
1328 :
1329 0 : if (pObj->ISA(SdrTextObj))
1330 : {
1331 0 : mxTextObj.reset( static_cast< SdrTextObj* >( pObj ) );
1332 : }
1333 : }
1334 : }
1335 :
1336 0 : sal_Bool bQuickDrag = sal_True;
1337 :
1338 0 : const SfxItemSet* pArgs = rReq.GetArgs();
1339 :
1340 0 : if (pArgs
1341 :
1342 : // test for type before using
1343 : && SID_TEXTEDIT == nSlotId
1344 0 : && SFX_ITEM_SET == pArgs->GetItemState(SID_TEXTEDIT)
1345 :
1346 0 : && (sal_uInt16) ((SfxUInt16Item&) pArgs->Get(SID_TEXTEDIT)).GetValue() == 2)
1347 : {
1348 : // Anwahl per Doppelklick -> kein QuickDrag zulassen
1349 0 : bQuickDrag = sal_False;
1350 : }
1351 :
1352 0 : SetInEditMode(aMEvt, bQuickDrag);
1353 : }
1354 0 : }
1355 :
1356 0 : void FuText::DoubleClick(const MouseEvent& )
1357 : {
1358 : // Nothing to do
1359 0 : }
1360 :
1361 : /** Removed the insertion of default text and putting a new text
1362 : object directly into edit mode.
1363 : */
1364 0 : SdrObject* FuText::CreateDefaultObject(const sal_uInt16 nID, const Rectangle& rRectangle)
1365 : {
1366 :
1367 : SdrObject* pObj = SdrObjFactory::MakeNewObject(
1368 0 : mpView->GetCurrentObjInventor(), mpView->GetCurrentObjIdentifier(),
1369 0 : 0L, mpDoc);
1370 :
1371 0 : if(pObj)
1372 : {
1373 0 : if(pObj->ISA(SdrTextObj))
1374 : {
1375 0 : SdrTextObj* pText = (SdrTextObj*)pObj;
1376 0 : pText->SetLogicRect(rRectangle);
1377 :
1378 0 : sal_Bool bVertical = (SID_ATTR_CHAR_VERTICAL == nID || SID_TEXT_FITTOSIZE_VERTICAL == nID);
1379 0 : pText->SetVerticalWriting(bVertical);
1380 :
1381 0 : ImpSetAttributesForNewTextObject(pText);
1382 :
1383 0 : if (nSlotId == SID_TEXT_FITTOSIZE)
1384 : {
1385 0 : ImpSetAttributesFitToSize(pText);
1386 : }
1387 0 : else if ( nSlotId == SID_TEXT_FITTOSIZE_VERTICAL )
1388 : {
1389 0 : ImpSetAttributesFitToSizeVertical(pText);
1390 : }
1391 : else
1392 : {
1393 0 : ImpSetAttributesFitCommon(pText);
1394 : }
1395 :
1396 : // Put text object into edit mode.
1397 0 : SdrPageView* pPV = mpView->GetSdrPageView();
1398 0 : mpView->SdrBeginTextEdit(pText, pPV);
1399 : }
1400 : else
1401 : {
1402 : OSL_FAIL("Object is NO text object");
1403 : }
1404 : }
1405 :
1406 0 : return pObj;
1407 : }
1408 :
1409 :
1410 :
1411 :
1412 : /** is called when the currenct function should be aborted. <p>
1413 : This is used when a function gets a KEY_ESCAPE but can also
1414 : be called directly.
1415 :
1416 : @returns true if a active function was aborted
1417 : */
1418 0 : bool FuText::cancel()
1419 : {
1420 0 : if ( mpView->IsTextEdit() )
1421 : {
1422 0 : if(mpView->SdrEndTextEdit() == SDRENDTEXTEDIT_DELETED)
1423 0 : mxTextObj.reset(0);
1424 :
1425 0 : mpView->SetCurrentObj(OBJ_TEXT);
1426 0 : mpView->SetEditMode(SDREDITMODE_EDIT);
1427 0 : return true;
1428 : }
1429 : else
1430 : {
1431 0 : return false;
1432 : }
1433 : }
1434 :
1435 0 : void FuText::ChangeFontSize( bool bGrow, OutlinerView* pOLV, const FontList* pFontList, ::sd::View* pView )
1436 : {
1437 0 : if( !pFontList || !pView )
1438 0 : return;
1439 :
1440 0 : if( pOLV )
1441 : {
1442 0 : pOLV->GetEditView().ChangeFontSize( bGrow, pFontList );
1443 : }
1444 : else
1445 : {
1446 :
1447 0 : const SdrMarkList& rMarkList = pView->GetMarkedObjectList();
1448 0 : for( sal_uInt32 nMark = 0; nMark < rMarkList.GetMarkCount(); nMark++ )
1449 : {
1450 0 : SdrTextObj* pTextObj = dynamic_cast< SdrTextObj* >( rMarkList.GetMark(nMark)->GetMarkedSdrObj() );
1451 0 : if( pTextObj )
1452 : {
1453 0 : for( sal_Int32 nText = 0; nText < pTextObj->getTextCount(); nText++ )
1454 : {
1455 0 : pTextObj->setActiveText( nText );
1456 :
1457 : // Put text object into edit mode.
1458 0 : SdrPageView* pPV = pView->GetSdrPageView();
1459 0 : pView->SdrBeginTextEdit(pTextObj, pPV);
1460 :
1461 0 : pOLV = pView->GetTextEditOutlinerView();
1462 0 : if( pOLV )
1463 : {
1464 0 : EditEngine* pEditEngine = pOLV->GetEditView().GetEditEngine();
1465 0 : if( pEditEngine )
1466 : {
1467 0 : ESelection aSel;
1468 0 : aSel.nEndPara = pEditEngine->GetParagraphCount()-1;
1469 0 : aSel.nEndPos = pEditEngine->GetTextLen(aSel.nEndPara);
1470 0 : pOLV->SetSelection(aSel);
1471 : }
1472 :
1473 0 : ChangeFontSize( bGrow, pOLV, pFontList, pView );
1474 : }
1475 :
1476 0 : pView->SdrEndTextEdit();
1477 : }
1478 :
1479 0 : SfxItemSet aShapeSet( pTextObj->GetMergedItemSet() );
1480 0 : if( EditView::ChangeFontSize( bGrow, aShapeSet, pFontList ) )
1481 : {
1482 0 : pTextObj->SetObjectItemNoBroadcast( aShapeSet.Get( EE_CHAR_FONTHEIGHT ) );
1483 0 : pTextObj->SetObjectItemNoBroadcast( aShapeSet.Get( EE_CHAR_FONTHEIGHT_CJK ) );
1484 0 : pTextObj->SetObjectItemNoBroadcast( aShapeSet.Get( EE_CHAR_FONTHEIGHT_CTL ) );
1485 0 : }
1486 : }
1487 : }
1488 : }
1489 : }
1490 :
1491 9 : } // end of namespace sd
1492 :
1493 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
