?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
build fix: no comphelper/profilezone.hxx in this branch
[LibreOffice.git] / vcl / source / control / edit.cxx
blobcf0fe9ce07595e108d3dbe5b6ac4a796656d8cef
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 <tools/rc.h>
21 #include <comphelper/lok.hxx>
22
23 #include <vcl/IDialogRenderable.hxx>
24 #include <vcl/decoview.hxx>
25 #include <vcl/event.hxx>
26 #include <vcl/cursor.hxx>
27 #include <vcl/virdev.hxx>
28 #include <vcl/menu.hxx>
29 #include <vcl/edit.hxx>
30 #include <vcl/layout.hxx>
31 #include <vcl/svapp.hxx>
32 #include <vcl/settings.hxx>
33 #include <vcl/uitest/uiobject.hxx>
34
35 #include <window.h>
36 #include <svdata.hxx>
37 #include <svids.hrc>
38 #include <controldata.hxx>
39
40 #include <osl/mutex.hxx>
41
42 #include <com/sun/star/i18n/BreakIterator.hpp>
43 #include <com/sun/star/i18n/CharacterIteratorMode.hpp>
44 #include <com/sun/star/i18n/WordType.hpp>
45 #include <cppuhelper/weak.hxx>
46 #include <com/sun/star/datatransfer/XTransferable.hpp>
47 #include <com/sun/star/datatransfer/clipboard/XClipboard.hpp>
48 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
49
50 #include <com/sun/star/datatransfer/dnd/DNDConstants.hpp>
51 #include <com/sun/star/datatransfer/dnd/XDragGestureRecognizer.hpp>
52 #include <com/sun/star/datatransfer/dnd/XDropTarget.hpp>
53
54 #include <com/sun/star/i18n/InputSequenceChecker.hpp>
55 #include <com/sun/star/i18n/InputSequenceCheckMode.hpp>
56 #include <com/sun/star/i18n/ScriptType.hpp>
57 #include <com/sun/star/container/XNameAccess.hpp>
58
59 #include <com/sun/star/uno/Any.hxx>
60
61 #include <comphelper/processfactory.hxx>
62 #include <comphelper/string.hxx>
63
64 #include <sot/exchange.hxx>
65 #include <sot/formats.hxx>
66 #include <sal/macros.h>
67
68 #include <vcl/unohelp.hxx>
69 #include <vcl/unohelp2.hxx>
70
71 #include <officecfg/Office/Common.hxx>
72
73 #include <memory>
74
75 using namespace ::com::sun::star;
76 using namespace ::com::sun::star::uno;
77 using namespace ::com::sun::star::lang;
78
79 // - Redo
80 // - Bei Tracking-Cancel DefaultSelection wieder herstellen
81
82 static FncGetSpecialChars pImplFncGetSpecialChars = nullptr;
83
84 #define EDIT_ALIGN_LEFT 1
85 #define EDIT_ALIGN_CENTER 2
86 #define EDIT_ALIGN_RIGHT 3
87
88 #define EDIT_DEL_LEFT 1
89 #define EDIT_DEL_RIGHT 2
90
91 #define EDIT_DELMODE_SIMPLE 11
92 #define EDIT_DELMODE_RESTOFWORD 12
93 #define EDIT_DELMODE_RESTOFCONTENT 13
94
95 struct DDInfo
96 {
97 vcl::Cursor aCursor;
98 Selection aDndStartSel;
99 sal_Int32 nDropPos;
100 bool bStarterOfDD;
101 bool bDroppedInMe;
102 bool bVisCursor;
103 bool bIsStringSupported;
104
105 DDInfo()
106 {
107 aCursor.SetStyle( CURSOR_SHADOW );
108 nDropPos = 0;
109 bStarterOfDD = false;
110 bDroppedInMe = false;
111 bVisCursor = false;
112 bIsStringSupported = false;
113 }
114 };
115
116 struct Impl_IMEInfos
117 {
118 OUString aOldTextAfterStartPos;
119 std::unique_ptr<ExtTextInputAttr[]>
120 pAttribs;
121 sal_Int32 nPos;
122 sal_Int32 nLen;
123 bool bCursor;
124 bool bWasCursorOverwrite;
125
126 Impl_IMEInfos(sal_Int32 nPos, const OUString& rOldTextAfterStartPos);
127
128 void CopyAttribs(const ExtTextInputAttr* pA, sal_Int32 nL);
129 void DestroyAttribs();
130 };
131
132 Impl_IMEInfos::Impl_IMEInfos(sal_Int32 nP, const OUString& rOldTextAfterStartPos)
133 : aOldTextAfterStartPos(rOldTextAfterStartPos)
134 {
135 nPos = nP;
136 nLen = 0;
137 bCursor = true;
138 pAttribs = nullptr;
139 bWasCursorOverwrite = false;
140 }
141
142 void Impl_IMEInfos::CopyAttribs(const ExtTextInputAttr* pA, sal_Int32 nL)
143 {
144 nLen = nL;
145 pAttribs.reset(new ExtTextInputAttr[ nL ]);
146 memcpy( pAttribs.get(), pA, nL*sizeof(ExtTextInputAttr) );
147 }
148
149 void Impl_IMEInfos::DestroyAttribs()
150 {
151 pAttribs.reset();
152 nLen = 0;
153 }
154
155 Edit::Edit( WindowType nType )
156 : Control( nType )
157 {
158 ImplInitEditData();
159 }
160
161 Edit::Edit( vcl::Window* pParent, WinBits nStyle )
162 : Control( WINDOW_EDIT )
163 {
164 ImplInitEditData();
165 ImplInit( pParent, nStyle );
166 }
167
168 void Edit::SetWidthInChars(sal_Int32 nWidthInChars)
169 {
170 if (mnWidthInChars != nWidthInChars)
171 {
172 mnWidthInChars = nWidthInChars;
173 queue_resize();
174 }
175 }
176
177 void Edit::setMaxWidthChars(sal_Int32 nWidth)
178 {
179 if (nWidth != mnMaxWidthChars)
180 {
181 mnMaxWidthChars = nWidth;
182 queue_resize();
183 }
184 }
185
186 bool Edit::set_property(const OString &rKey, const OString &rValue)
187 {
188 if (rKey == "width-chars")
189 SetWidthInChars(rValue.toInt32());
190 else if (rKey == "max-width-chars")
191 setMaxWidthChars(rValue.toInt32());
192 else if (rKey == "max-length")
193 {
194 sal_Int32 nTextLen = rValue.toInt32();
195 SetMaxTextLen(nTextLen == 0 ? EDIT_NOLIMIT : nTextLen);
196 }
197 else if (rKey == "editable")
198 {
199 bool bReadOnly = !toBool(rValue);
200 SetReadOnly(bReadOnly);
201 //disable tab to traverse into readonly editables
202 WinBits nBits = GetStyle();
203 nBits &= ~(WB_TABSTOP|WB_NOTABSTOP);
204 if (!bReadOnly)
205 nBits |= WB_TABSTOP;
206 else
207 nBits |= WB_NOTABSTOP;
208 SetStyle(nBits);
209 }
210 else if (rKey == "visibility")
211 {
212 WinBits nBits = GetStyle();
213 nBits &= ~(WB_PASSWORD);
214 if (!toBool(rValue))
215 nBits |= WB_PASSWORD;
216 SetStyle(nBits);
217 }
218 else if (rKey == "placeholder-text")
219 SetPlaceholderText(OStringToOUString(rValue, RTL_TEXTENCODING_UTF8));
220 else
221 return Control::set_property(rKey, rValue);
222 return true;
223 }
224
225 Edit::~Edit()
226 {
227 disposeOnce();
228 }
229
230 void Edit::dispose()
231 {
232 delete mpDDInfo;
233 mpDDInfo = nullptr;
234
235 vcl::Cursor* pCursor = GetCursor();
236 if ( pCursor )
237 {
238 SetCursor( nullptr );
239 delete pCursor;
240 }
241
242 delete mpIMEInfos;
243 mpIMEInfos = nullptr;
244
245 delete mpUpdateDataTimer;
246 mpUpdateDataTimer = nullptr;
247
248 if ( mxDnDListener.is() )
249 {
250 if ( GetDragGestureRecognizer().is() )
251 {
252 uno::Reference< datatransfer::dnd::XDragGestureListener> xDGL( mxDnDListener, uno::UNO_QUERY );
253 GetDragGestureRecognizer()->removeDragGestureListener( xDGL );
254 }
255 if ( GetDropTarget().is() )
256 {
257 uno::Reference< datatransfer::dnd::XDropTargetListener> xDTL( mxDnDListener, uno::UNO_QUERY );
258 GetDropTarget()->removeDropTargetListener( xDTL );
259 }
260
261 uno::Reference< lang::XEventListener> xEL( mxDnDListener, uno::UNO_QUERY );
262 xEL->disposing( lang::EventObject() ); // #95154# #96585# Empty Source means it's the Client
263 mxDnDListener.clear();
264 }
265
266 SetType(WINDOW_WINDOW);
267
268 mpSubEdit.disposeAndClear();
269 Control::dispose();
270 }
271
272 void Edit::ImplInitEditData()
273 {
274 mpSubEdit = VclPtr<Edit>();
275 mpUpdateDataTimer = nullptr;
276 mpFilterText = nullptr;
277 mnXOffset = 0;
278 mnAlign = EDIT_ALIGN_LEFT;
279 mnMaxTextLen = EDIT_NOLIMIT;
280 mnWidthInChars = -1;
281 mnMaxWidthChars = -1;
282 mbModified = false;
283 mbInternModified = false;
284 mbReadOnly = false;
285 mbInsertMode = true;
286 mbClickedInSelection = false;
287 mbActivePopup = false;
288 mbIsSubEdit = false;
289 mbInMBDown = false;
290 mpDDInfo = nullptr;
291 mpIMEInfos = nullptr;
292 mcEchoChar = 0;
293
294 // --- RTL --- no default mirroring for Edit controls
295 // note: controls that use a subedit will revert this (SpinField, ComboBox)
296 EnableRTL( false );
297
298 vcl::unohelper::DragAndDropWrapper* pDnDWrapper = new vcl::unohelper::DragAndDropWrapper( this );
299 mxDnDListener = pDnDWrapper;
300 }
301
302 bool Edit::ImplUseNativeBorder(vcl::RenderContext& rRenderContext, WinBits nStyle)
303 {
304 bool bRet = rRenderContext.IsNativeControlSupported(ImplGetNativeControlType(),
305 ControlPart::HasBackgroundTexture)
306 && ((nStyle & WB_BORDER) && !(nStyle & WB_NOBORDER));
307 if (!bRet && mbIsSubEdit)
308 {
309 vcl::Window* pWindow = GetParent();
310 nStyle = pWindow->GetStyle();
311 bRet = pWindow->IsNativeControlSupported(ImplGetNativeControlType(),
312 ControlPart::HasBackgroundTexture)
313 && ((nStyle & WB_BORDER) && !(nStyle & WB_NOBORDER));
314 }
315 return bRet;
316 }
317
318 void Edit::ImplInit(vcl::Window* pParent, WinBits nStyle)
319 {
320 nStyle = ImplInitStyle(nStyle);
321
322 if (!(nStyle & (WB_CENTER | WB_RIGHT)))
323 nStyle |= WB_LEFT;
324
325 Control::ImplInit(pParent, nStyle, nullptr);
326
327 mbReadOnly = (nStyle & WB_READONLY) != 0;
328
329 mnAlign = EDIT_ALIGN_LEFT;
330
331 // --- RTL --- hack: right align until keyinput and cursor travelling works
332 if( IsRTLEnabled() )
333 mnAlign = EDIT_ALIGN_RIGHT;
334
335 if ( nStyle & WB_RIGHT )
336 mnAlign = EDIT_ALIGN_RIGHT;
337 else if ( nStyle & WB_CENTER )
338 mnAlign = EDIT_ALIGN_CENTER;
339
340 SetCursor( new vcl::Cursor );
341
342 SetPointer( Pointer( PointerStyle::Text ) );
343
344 uno::Reference< datatransfer::dnd::XDragGestureListener> xDGL( mxDnDListener, uno::UNO_QUERY );
345 uno::Reference< datatransfer::dnd::XDragGestureRecognizer > xDGR = GetDragGestureRecognizer();
346 if ( xDGR.is() )
347 {
348 xDGR->addDragGestureListener( xDGL );
349 uno::Reference< datatransfer::dnd::XDropTargetListener> xDTL( mxDnDListener, uno::UNO_QUERY );
350 GetDropTarget()->addDropTargetListener( xDTL );
351 GetDropTarget()->setActive( true );
352 GetDropTarget()->setDefaultActions( datatransfer::dnd::DNDConstants::ACTION_COPY_OR_MOVE );
353 }
354 }
355
356 WinBits Edit::ImplInitStyle( WinBits nStyle )
357 {
358 if ( !(nStyle & WB_NOTABSTOP) )
359 nStyle |= WB_TABSTOP;
360 if ( !(nStyle & WB_NOGROUP) )
361 nStyle |= WB_GROUP;
362
363 return nStyle;
364 }
365
366 bool Edit::IsCharInput( const KeyEvent& rKeyEvent )
367 {
368 // In the future we must use new Unicode functions for this
369 sal_Unicode cCharCode = rKeyEvent.GetCharCode();
370 return ((cCharCode >= 32) && (cCharCode != 127) &&
371 !rKeyEvent.GetKeyCode().IsMod3() &&
372 !rKeyEvent.GetKeyCode().IsMod2() &&
373 !rKeyEvent.GetKeyCode().IsMod1() );
374 }
375
376 void Edit::ImplModified()
377 {
378 mbModified = true;
379 Modify();
380 }
381
382 void Edit::ApplySettings(vcl::RenderContext& rRenderContext)
383 {
384 Control::ApplySettings(rRenderContext);
385
386 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
387
388 const vcl::Font& aFont = rStyleSettings.GetFieldFont();
389 ApplyControlFont(rRenderContext, aFont);
390
391 ImplClearLayoutData();
392
393 Color aTextColor = rStyleSettings.GetFieldTextColor();
394 ApplyControlForeground(rRenderContext, aTextColor);
395
396 if (ImplUseNativeBorder(rRenderContext, GetStyle()) || IsPaintTransparent())
397 {
398 // Transparent background
399 rRenderContext.SetBackground();
400 rRenderContext.SetFillColor();
401 }
402 else if (IsControlBackground())
403 {
404 rRenderContext.SetBackground(GetControlBackground());
405 rRenderContext.SetFillColor(GetControlBackground());
406 }
407 else
408 {
409 rRenderContext.SetBackground(rStyleSettings.GetFieldColor());
410 rRenderContext.SetFillColor(rStyleSettings.GetFieldColor());
411 }
412 }
413
414 long Edit::ImplGetExtraXOffset() const
415 {
416 // MT 09/2002: nExtraOffsetX should become a member, instead of checking every time,
417 // but I need an incompatible update for this...
418 // #94095# Use extra offset only when edit has a border
419 long nExtraOffset = 0;
420 if( ( GetStyle() & WB_BORDER ) || ( mbIsSubEdit && ( GetParent()->GetStyle() & WB_BORDER ) ) )
421 nExtraOffset = 2;
422
423 return nExtraOffset;
424 }
425
426 long Edit::ImplGetExtraYOffset() const
427 {
428 long nExtraOffset = 0;
429 ControlType eCtrlType = ImplGetNativeControlType();
430 if (eCtrlType != ControlType::EditboxNoBorder)
431 {
432 // add some space between text entry and border
433 nExtraOffset = 2;
434 }
435 return nExtraOffset;
436 }
437
438 OUString Edit::ImplGetText() const
439 {
440 if ( mcEchoChar || (GetStyle() & WB_PASSWORD) )
441 {
442 sal_Unicode cEchoChar;
443 if ( mcEchoChar )
444 cEchoChar = mcEchoChar;
445 else
446 cEchoChar = sal_Unicode(0x2022);
447 OUStringBuffer aText;
448 comphelper::string::padToLength(aText, maText.getLength(), cEchoChar);
449 return aText.makeStringAndClear();
450 }
451 else
452 return maText.toString();
453 }
454
455 void Edit::ImplInvalidateOrRepaint()
456 {
457 if( IsPaintTransparent() )
458 {
459 Invalidate();
460 // FIXME: this is currently only on OS X
461 if( ImplGetSVData()->maNWFData.mbNoFocusRects )
462 Update();
463 }
464 else
465 Invalidate();
466 }
467
468 long Edit::ImplGetTextYPosition() const
469 {
470 if ( GetStyle() & WB_TOP )
471 return ImplGetExtraXOffset();
472 else if ( GetStyle() & WB_BOTTOM )
473 return GetOutputSizePixel().Height() - GetTextHeight() - ImplGetExtraXOffset();
474 return ( GetOutputSizePixel().Height() - GetTextHeight() ) / 2;
475 }
476
477 void Edit::ImplRepaint(vcl::RenderContext& rRenderContext, const Rectangle& rRectangle)
478 {
479 if (!IsReallyVisible())
480 return;
481
482 ApplySettings(rRenderContext);
483
484 const OUString aText = ImplGetText();
485 const sal_Int32 nLen = aText.getLength();
486
487 long nDXBuffer[256];
488 std::unique_ptr<long[]> pDXBuffer;
489 long* pDX = nDXBuffer;
490
491 if (nLen)
492 {
493 if ((size_t) (2 * nLen) > SAL_N_ELEMENTS(nDXBuffer))
494 {
495 pDXBuffer.reset(new long[2 * (nLen + 1)]);
496 pDX = pDXBuffer.get();
497 }
498
499 GetCaretPositions(aText, pDX, 0, nLen);
500 }
501
502 long nTH = GetTextHeight();
503 Point aPos(mnXOffset, ImplGetTextYPosition());
504
505 vcl::Cursor* pCursor = GetCursor();
506 bool bVisCursor = pCursor && pCursor->IsVisible();
507 if (pCursor)
508 pCursor->Hide();
509
510 ImplClearBackground(rRenderContext, rRectangle, 0, GetOutputSizePixel().Width()-1);
511
512 bool bPaintPlaceholderText = aText.isEmpty() && !maPlaceholderText.isEmpty();
513
514 const StyleSettings& rStyleSettings = rRenderContext.GetSettings().GetStyleSettings();
515
516 if (!IsEnabled() || bPaintPlaceholderText)
517 rRenderContext.SetTextColor(rStyleSettings.GetDisableColor());
518
519 // Set background color of the normal text
520 if ((GetStyle() & WB_FORCECTRLBACKGROUND) != 0 && IsControlBackground())
521 {
522 // check if we need to set ControlBackground even in NWF case
523 rRenderContext.Push(PushFlags::FILLCOLOR | PushFlags::LINECOLOR);
524 rRenderContext.SetLineColor();
525 rRenderContext.SetFillColor(GetControlBackground());
526 rRenderContext.DrawRect(Rectangle(aPos, Size(GetOutputSizePixel().Width() - 2 * mnXOffset, GetOutputSizePixel().Height())));
527 rRenderContext.Pop();
528
529 rRenderContext.SetTextFillColor(GetControlBackground());
530 }
531 else if (IsPaintTransparent() || ImplUseNativeBorder(rRenderContext, GetStyle()))
532 rRenderContext.SetTextFillColor();
533 else
534 rRenderContext.SetTextFillColor(IsControlBackground() ? GetControlBackground() : rStyleSettings.GetFieldColor());
535
536 ImplPaintBorder(rRenderContext, 0, GetOutputSizePixel().Width());
537
538 bool bDrawSelection = maSelection.Len() && (HasFocus() || (GetStyle() & WB_NOHIDESELECTION) || mbActivePopup);
539
540 aPos.X() = mnXOffset + ImplGetExtraXOffset();
541 if (bPaintPlaceholderText)
542 {
543 rRenderContext.DrawText(aPos, maPlaceholderText);
544 }
545 else if (!bDrawSelection && !mpIMEInfos)
546 {
547 rRenderContext.DrawText(aPos, aText, 0, nLen);
548 }
549 else
550 {
551 // save graphics state
552 rRenderContext.Push();
553 // first calculate higlighted and non highlighted clip regions
554 vcl::Region aHiglightClipRegion;
555 vcl::Region aNormalClipRegion;
556 Selection aTmpSel(maSelection);
557 aTmpSel.Justify();
558 // selection is highlighted
559 for(sal_Int32 i = 0; i < nLen; ++i)
560 {
561 Rectangle aRect(aPos, Size(10, nTH));
562 aRect.Left() = pDX[2 * i] + mnXOffset + ImplGetExtraXOffset();
563 aRect.Right() = pDX[2 * i + 1] + mnXOffset + ImplGetExtraXOffset();
564 aRect.Justify();
565 bool bHighlight = false;
566 if (i >= aTmpSel.Min() && i < aTmpSel.Max())
567 bHighlight = true;
568
569 if (mpIMEInfos && mpIMEInfos->pAttribs &&
570 i >= mpIMEInfos->nPos && i < (mpIMEInfos->nPos+mpIMEInfos->nLen) &&
571 (mpIMEInfos->pAttribs[i - mpIMEInfos->nPos] & ExtTextInputAttr::Highlight))
572 {
573 bHighlight = true;
574 }
575
576 if (bHighlight)
577 aHiglightClipRegion.Union(aRect);
578 else
579 aNormalClipRegion.Union(aRect);
580 }
581 // draw normal text
582 Color aNormalTextColor = rRenderContext.GetTextColor();
583 rRenderContext.SetClipRegion(aNormalClipRegion);
584
585 if (IsPaintTransparent())
586 rRenderContext.SetTextFillColor();
587 else
588 {
589 // Set background color when part of the text is selected
590 if (ImplUseNativeBorder(rRenderContext, GetStyle()))
591 {
592 if( (GetStyle() & WB_FORCECTRLBACKGROUND) != 0 && IsControlBackground() )
593 rRenderContext.SetTextFillColor(GetControlBackground());
594 else
595 rRenderContext.SetTextFillColor();
596 }
597 else
598 {
599 rRenderContext.SetTextFillColor(IsControlBackground() ? GetControlBackground() : rStyleSettings.GetFieldColor());
600 }
601 }
602 rRenderContext.DrawText(aPos, aText, 0, nLen);
603
604 // draw highlighted text
605 rRenderContext.SetClipRegion(aHiglightClipRegion);
606 rRenderContext.SetTextColor(rStyleSettings.GetHighlightTextColor());
607 rRenderContext.SetTextFillColor(rStyleSettings.GetHighlightColor());
608 rRenderContext.DrawText(aPos, aText, 0, nLen);
609
610 // if IME info exists loop over portions and output different font attributes
611 if (mpIMEInfos && mpIMEInfos->pAttribs)
612 {
613 for(int n = 0; n < 2; n++)
614 {
615 vcl::Region aRegion;
616 if (n == 0)
617 {
618 rRenderContext.SetTextColor(aNormalTextColor);
619 if (IsPaintTransparent())
620 rRenderContext.SetTextFillColor();
621 else
622 rRenderContext.SetTextFillColor(IsControlBackground() ? GetControlBackground() : rStyleSettings.GetFieldColor());
623 aRegion = aNormalClipRegion;
624 }
625 else
626 {
627 rRenderContext.SetTextColor(rStyleSettings.GetHighlightTextColor());
628 rRenderContext.SetTextFillColor(rStyleSettings.GetHighlightColor());
629 aRegion = aHiglightClipRegion;
630 }
631
632 for(int i = 0; i < mpIMEInfos->nLen; )
633 {
634 ExtTextInputAttr nAttr = mpIMEInfos->pAttribs[i];
635 vcl::Region aClip;
636 int nIndex = i;
637 while (nIndex < mpIMEInfos->nLen && mpIMEInfos->pAttribs[nIndex] == nAttr) // #112631# check nIndex before using it
638 {
639 Rectangle aRect( aPos, Size( 10, nTH ) );
640 aRect.Left() = pDX[2 * (nIndex + mpIMEInfos->nPos)] + mnXOffset + ImplGetExtraXOffset();
641 aRect.Right() = pDX[2 * (nIndex + mpIMEInfos->nPos) + 1] + mnXOffset + ImplGetExtraXOffset();
642 aRect.Justify();
643 aClip.Union(aRect);
644 nIndex++;
645 }
646 i = nIndex;
647 aClip.Intersect(aRegion);
648 if (!aClip.IsEmpty() && nAttr != ExtTextInputAttr::NONE)
649 {
650 vcl::Font aFont = rRenderContext.GetFont();
651 if (nAttr & ExtTextInputAttr::Underline)
652 aFont.SetUnderline(LINESTYLE_SINGLE);
653 else if (nAttr & ExtTextInputAttr::BoldUnderline)
654 aFont.SetUnderline( LINESTYLE_BOLD);
655 else if (nAttr & ExtTextInputAttr::DottedUnderline)
656 aFont.SetUnderline( LINESTYLE_DOTTED);
657 else if (nAttr & ExtTextInputAttr::DashDotUnderline)
658 aFont.SetUnderline( LINESTYLE_DASHDOT);
659 else if (nAttr & ExtTextInputAttr::GrayWaveline)
660 {
661 aFont.SetUnderline(LINESTYLE_WAVE);
662 rRenderContext.SetTextLineColor(Color(COL_LIGHTGRAY));
663 }
664 rRenderContext.SetFont(aFont);
665
666 if (nAttr & ExtTextInputAttr::RedText)
667 rRenderContext.SetTextColor(Color(COL_RED));
668 else if (nAttr & ExtTextInputAttr::HalfToneText)
669 rRenderContext.SetTextColor(Color(COL_LIGHTGRAY));
670
671 rRenderContext.SetClipRegion(aClip);
672 rRenderContext.DrawText(aPos, aText, 0, nLen);
673 }
674 }
675 }
676 }
677
678 // restore graphics state
679 rRenderContext.Pop();
680 }
681
682 if (bVisCursor && (!mpIMEInfos || mpIMEInfos->bCursor))
683 pCursor->Show();
684 }
685
686 void Edit::ImplDelete( const Selection& rSelection, sal_uInt8 nDirection, sal_uInt8 nMode )
687 {
688 const sal_Int32 nTextLen = ImplGetText().getLength();
689
690 // loeschen moeglich?
691 if ( !rSelection.Len() &&
692 (((rSelection.Min() == 0) && (nDirection == EDIT_DEL_LEFT)) ||
693 ((rSelection.Max() == nTextLen) && (nDirection == EDIT_DEL_RIGHT))) )
694 return;
695
696 ImplClearLayoutData();
697
698 Selection aSelection( rSelection );
699 aSelection.Justify();
700
701 if ( !aSelection.Len() )
702 {
703 uno::Reference < i18n::XBreakIterator > xBI = ImplGetBreakIterator();
704 if ( nDirection == EDIT_DEL_LEFT )
705 {
706 if ( nMode == EDIT_DELMODE_RESTOFWORD )
707 {
708 i18n::Boundary aBoundary = xBI->getWordBoundary( maText.toString(), aSelection.Min(),
709 GetSettings().GetLanguageTag().getLocale(), i18n::WordType::ANYWORD_IGNOREWHITESPACES, true );
710 if ( aBoundary.startPos == aSelection.Min() )
711 aBoundary = xBI->previousWord( maText.toString(), aSelection.Min(),
712 GetSettings().GetLanguageTag().getLocale(), i18n::WordType::ANYWORD_IGNOREWHITESPACES );
713 aSelection.Min() = aBoundary.startPos;
714 }
715 else if ( nMode == EDIT_DELMODE_RESTOFCONTENT )
716 {
717 aSelection.Min() = 0;
718 }
719 else
720 {
721 sal_Int32 nCount = 1;
722 aSelection.Min() = xBI->previousCharacters( maText.toString(), aSelection.Min(),
723 GetSettings().GetLanguageTag().getLocale(), i18n::CharacterIteratorMode::SKIPCHARACTER, nCount, nCount );
724 }
725 }
726 else
727 {
728 if ( nMode == EDIT_DELMODE_RESTOFWORD )
729 {
730 i18n::Boundary aBoundary = xBI->nextWord( maText.toString(), aSelection.Max(),
731 GetSettings().GetLanguageTag().getLocale(), i18n::WordType::ANYWORD_IGNOREWHITESPACES );
732 aSelection.Max() = aBoundary.startPos;
733 }
734 else if ( nMode == EDIT_DELMODE_RESTOFCONTENT )
735 {
736 aSelection.Max() = nTextLen;
737 }
738 else
739 {
740 sal_Int32 nCount = 1;
741 aSelection.Max() = xBI->nextCharacters( maText.toString(), aSelection.Max(),
742 GetSettings().GetLanguageTag().getLocale(), i18n::CharacterIteratorMode::SKIPCHARACTER, nCount, nCount );
743 }
744 }
745 }
746
747 maText.remove( static_cast<sal_Int32>(aSelection.Min()), static_cast<sal_Int32>(aSelection.Len()) );
748 maSelection.Min() = aSelection.Min();
749 maSelection.Max() = aSelection.Min();
750 ImplAlignAndPaint();
751 mbInternModified = true;
752 }
753
754 OUString Edit::ImplGetValidString( const OUString& rString )
755 {
756 OUString aValidString( rString );
757 aValidString = aValidString.replaceAll("\n", "").replaceAll("\r", "");
758 aValidString = aValidString.replace('\t', ' ');
759 return aValidString;
760 }
761
762 uno::Reference < i18n::XBreakIterator > Edit::ImplGetBreakIterator()
763 {
764 //!! since we don't want to become incompatible in the next minor update
765 //!! where this code will get integrated into, xISC will be a local
766 //!! variable instead of a class member!
767 uno::Reference< uno::XComponentContext > xContext = ::comphelper::getProcessComponentContext();
768 return i18n::BreakIterator::create(xContext);
769 }
770
771 uno::Reference < i18n::XExtendedInputSequenceChecker > const & Edit::ImplGetInputSequenceChecker()
772 {
773 if ( !mxISC.is() )
774 {
775 mxISC = i18n::InputSequenceChecker::create(
776 ::comphelper::getProcessComponentContext() );
777 }
778 return mxISC;
779 }
780
781 void Edit::ShowTruncationWarning( vcl::Window* pParent )
782 {
783 ResMgr* pResMgr = ImplGetResMgr();
784 if( pResMgr )
785 {
786 ScopedVclPtrInstance< MessageDialog > aBox( pParent, ResId(SV_EDIT_WARNING_STR, *pResMgr), VclMessageType::Warning );
787 aBox->Execute();
788 }
789 }
790
791 bool Edit::ImplTruncateToMaxLen( OUString& rStr, sal_Int32 nSelectionLen ) const
792 {
793 bool bWasTruncated = false;
794 if (maText.getLength() - nSelectionLen > mnMaxTextLen - rStr.getLength())
795 {
796 sal_Int32 nErasePos = mnMaxTextLen - maText.getLength() + nSelectionLen;
797 rStr = rStr.copy( 0, nErasePos );
798 bWasTruncated = true;
799 }
800 return bWasTruncated;
801 }
802
803 void Edit::ImplInsertText( const OUString& rStr, const Selection* pNewSel, bool bIsUserInput )
804 {
805 Selection aSelection( maSelection );
806 aSelection.Justify();
807
808 OUString aNewText( ImplGetValidString( rStr ) );
809 ImplTruncateToMaxLen( aNewText, aSelection.Len() );
810
811 ImplClearLayoutData();
812
813 if ( aSelection.Len() )
814 maText.remove( static_cast<sal_Int32>(aSelection.Min()), static_cast<sal_Int32>(aSelection.Len()) );
815 else if ( !mbInsertMode && (aSelection.Max() < maText.getLength()) )
816 maText.remove( static_cast<sal_Int32>(aSelection.Max()), 1 );
817
818 // take care of input-sequence-checking now
819 if (bIsUserInput && !rStr.isEmpty())
820 {
821 SAL_WARN_IF( rStr.getLength() != 1, "vcl", "unexpected string length. User input is expected to provide 1 char only!" );
822
823 // determine if input-sequence-checking should be applied or not
824
825 uno::Reference < i18n::XBreakIterator > xBI( ImplGetBreakIterator(), UNO_QUERY );
826 bool bIsInputSequenceChecking = rStr.getLength() == 1 &&
827 officecfg::Office::Common::I18N::CTL::CTLFont::get() &&
828 officecfg::Office::Common::I18N::CTL::CTLSequenceChecking::get() &&
829 aSelection.Min() > 0 && /* first char needs not to be checked */
830 xBI.is() && i18n::ScriptType::COMPLEX == xBI->getScriptType( rStr, 0 );
831
832 uno::Reference < i18n::XExtendedInputSequenceChecker > xISC;
833 if (bIsInputSequenceChecking && (xISC = ImplGetInputSequenceChecker()).is())
834 {
835 sal_Unicode cChar = rStr[0];
836 sal_Int32 nTmpPos = static_cast< sal_Int32 >( aSelection.Min() );
837 sal_Int16 nCheckMode = officecfg::Office::Common::I18N::CTL::CTLSequenceCheckingRestricted::get()?
838 i18n::InputSequenceCheckMode::STRICT : i18n::InputSequenceCheckMode::BASIC;
839
840 // the text that needs to be checked is only the one
841 // before the current cursor position
842 const OUString aOldText( maText.getStr(), nTmpPos);
843 OUString aTmpText( aOldText );
844 if (officecfg::Office::Common::I18N::CTL::CTLSequenceCheckingTypeAndReplace::get())
845 {
846 xISC->correctInputSequence( aTmpText, nTmpPos - 1, cChar, nCheckMode );
847
848 // find position of first character that has changed
849 sal_Int32 nOldLen = aOldText.getLength();
850 sal_Int32 nTmpLen = aTmpText.getLength();
851 const sal_Unicode *pOldTxt = aOldText.getStr();
852 const sal_Unicode *pTmpTxt = aTmpText.getStr();
853 sal_Int32 nChgPos = 0;
854 while ( nChgPos < nOldLen && nChgPos < nTmpLen &&
855 pOldTxt[nChgPos] == pTmpTxt[nChgPos] )
856 ++nChgPos;
857
858 const OUString aChgText( aTmpText.copy( nChgPos ) );
859
860 // remove text from first pos to be changed to current pos
861 maText.remove( nChgPos, nTmpPos - nChgPos );
862
863 if (!aChgText.isEmpty())
864 {
865 aNewText = aChgText;
866 aSelection.Min() = nChgPos; // position for new text to be inserted
867 }
868 else
869 aNewText.clear();
870 }
871 else
872 {
873 // should the character be ignored (i.e. not get inserted) ?
874 if (!xISC->checkInputSequence( aOldText, nTmpPos - 1, cChar, nCheckMode ))
875 aNewText.clear();
876 }
877 }
878
879 // at this point now we will insert the non-empty text 'normally' some lines below...
880 }
881
882 if ( !aNewText.isEmpty() )
883 maText.insert( static_cast<sal_Int32>(aSelection.Min()), aNewText );
884
885 if ( !pNewSel )
886 {
887 maSelection.Min() = aSelection.Min() + aNewText.getLength();
888 maSelection.Max() = maSelection.Min();
889 }
890 else
891 {
892 maSelection = *pNewSel;
893 if ( maSelection.Min() > maText.getLength() )
894 maSelection.Min() = maText.getLength();
895 if ( maSelection.Max() > maText.getLength() )
896 maSelection.Max() = maText.getLength();
897 }
898
899 ImplAlignAndPaint();
900 mbInternModified = true;
901 }
902
903 void Edit::ImplSetText( const OUString& rText, const Selection* pNewSelection )
904 {
905 // we delete text by "selecting" the old text completely then calling InsertText; this is flicker free
906 if ( ( rText.getLength() <= mnMaxTextLen ) &&
907 ( (rText != maText.getStr()) || (pNewSelection && (*pNewSelection != maSelection)) ) )
908 {
909 ImplClearLayoutData();
910 maSelection.Min() = 0;
911 maSelection.Max() = maText.getLength();
912 if ( mnXOffset || HasPaintEvent() )
913 {
914 mnXOffset = 0;
915 maText = ImplGetValidString( rText );
916
917 // #i54929# recalculate mnXOffset before ImplSetSelection,
918 // else cursor ends up in wrong position
919 ImplAlign();
920
921 if ( pNewSelection )
922 ImplSetSelection( *pNewSelection, false );
923
924 if ( mnXOffset && !pNewSelection )
925 maSelection.Max() = 0;
926
927 Invalidate();
928 }
929 else
930 ImplInsertText( rText, pNewSelection );
931
932 CallEventListeners( VCLEVENT_EDIT_MODIFY );
933 }
934 }
935
936 ControlType Edit::ImplGetNativeControlType() const
937 {
938 ControlType nCtrl = ControlType::Generic;
939 const vcl::Window* pControl = mbIsSubEdit ? GetParent() : this;
940
941 switch (pControl->GetType())
942 {
943 case WINDOW_COMBOBOX:
944 case WINDOW_PATTERNBOX:
945 case WINDOW_NUMERICBOX:
946 case WINDOW_METRICBOX:
947 case WINDOW_CURRENCYBOX:
948 case WINDOW_DATEBOX:
949 case WINDOW_TIMEBOX:
950 case WINDOW_LONGCURRENCYBOX:
951 nCtrl = ControlType::Combobox;
952 break;
953
954 case WINDOW_MULTILINEEDIT:
955 if ( GetWindow( GetWindowType::Border ) != this )
956 nCtrl = ControlType::MultilineEditbox;
957 else
958 nCtrl = ControlType::EditboxNoBorder;
959 break;
960
961 case WINDOW_EDIT:
962 case WINDOW_PATTERNFIELD:
963 case WINDOW_METRICFIELD:
964 case WINDOW_CURRENCYFIELD:
965 case WINDOW_DATEFIELD:
966 case WINDOW_TIMEFIELD:
967 case WINDOW_LONGCURRENCYFIELD:
968 case WINDOW_NUMERICFIELD:
969 case WINDOW_SPINFIELD:
970 if (pControl->GetStyle() & WB_SPIN)
971 nCtrl = ControlType::Spinbox;
972 else
973 {
974 if (GetWindow(GetWindowType::Border) != this)
975 nCtrl = ControlType::Editbox;
976 else
977 nCtrl = ControlType::EditboxNoBorder;
978 }
979 break;
980
981 default:
982 nCtrl = ControlType::Editbox;
983 }
984 return nCtrl;
985 }
986
987 void Edit::ImplClearBackground(vcl::RenderContext& rRenderContext, const Rectangle& rRectangle, long nXStart, long nXEnd )
988 {
989 /*
990 * note: at this point the cursor must be switched off already
991 */
992 Point aTmpPoint;
993 Rectangle aRect(aTmpPoint, GetOutputSizePixel());
994 aRect.Left() = nXStart;
995 aRect.Right() = nXEnd;
996
997 if( !(ImplUseNativeBorder(rRenderContext, GetStyle()) || IsPaintTransparent()))
998 rRenderContext.Erase(aRect);
999 else if (SupportsDoubleBuffering() && mbIsSubEdit)
1000 {
1001 // ImplPaintBorder() is a NOP, we have a native border, and this is a sub-edit of a control.
1002 // That means we have to draw the parent native widget to paint the edit area to clear our background.
1003 PaintBufferGuard g(ImplGetWindowImpl()->mpFrameData, GetParent());
1004 GetParent()->Paint(rRenderContext, rRectangle);
1005 }
1006 }
1007
1008 void Edit::ImplPaintBorder(vcl::RenderContext& rRenderContext, long nXStart, long nXEnd)
1009 {
1010 // this is not needed when double-buffering
1011 if (SupportsDoubleBuffering())
1012 return;
1013
1014 Point aTmpPoint;
1015 Rectangle aRect(aTmpPoint, GetOutputSizePixel());
1016 aRect.Left() = nXStart;
1017 aRect.Right() = nXEnd;
1018
1019 if (ImplUseNativeBorder(rRenderContext, GetStyle()) || IsPaintTransparent())
1020 {
1021 // draw the inner part by painting the whole control using its border window
1022 vcl::Window* pBorder = GetWindow(GetWindowType::Border);
1023 if (pBorder == this)
1024 {
1025 // we have no border, use parent
1026 vcl::Window* pControl = mbIsSubEdit ? GetParent() : this;
1027 pBorder = pControl->GetWindow(GetWindowType::Border);
1028 if (pBorder == this)
1029 pBorder = GetParent();
1030 }
1031
1032 if (pBorder)
1033 {
1034 // set proper clipping region to not overdraw the whole control
1035 vcl::Region aClipRgn = GetPaintRegion();
1036 if (!aClipRgn.IsNull())
1037 {
1038 // transform clipping region to border window's coordinate system
1039 if (IsRTLEnabled() != pBorder->IsRTLEnabled() && AllSettings::GetLayoutRTL())
1040 {
1041 // need to mirror in case border is not RTL but edit is (or vice versa)
1042
1043 // mirror
1044 Rectangle aBounds(aClipRgn.GetBoundRect());
1045 int xNew = GetOutputSizePixel().Width() - aBounds.GetWidth() - aBounds.Left();
1046 aClipRgn.Move(xNew - aBounds.Left(), 0);
1047
1048 // move offset of border window
1049 Point aBorderOffs;
1050 aBorderOffs = pBorder->ScreenToOutputPixel(OutputToScreenPixel(aBorderOffs));
1051 aClipRgn.Move(aBorderOffs.X(), aBorderOffs.Y());
1052 }
1053 else
1054 {
1055 // normal case
1056 Point aBorderOffs;
1057 aBorderOffs = pBorder->ScreenToOutputPixel(OutputToScreenPixel(aBorderOffs));
1058 aClipRgn.Move(aBorderOffs.X(), aBorderOffs.Y());
1059 }
1060
1061 vcl::Region oldRgn(pBorder->GetClipRegion());
1062 pBorder->SetClipRegion(aClipRgn);
1063
1064 pBorder->Paint(*pBorder, Rectangle());
1065
1066 pBorder->SetClipRegion(oldRgn);
1067 }
1068 else
1069 {
1070 pBorder->Paint(*pBorder, Rectangle());
1071 }
1072 }
1073 }
1074 }
1075
1076 void Edit::ImplShowCursor( bool bOnlyIfVisible )
1077 {
1078 if ( !IsUpdateMode() || ( bOnlyIfVisible && !IsReallyVisible() ) )
1079 return;
1080
1081 vcl::Cursor* pCursor = GetCursor();
1082 OUString aText = ImplGetText();
1083
1084 long nTextPos = 0;
1085
1086 long nDXBuffer[256];
1087 std::unique_ptr<long[]> pDXBuffer;
1088 long* pDX = nDXBuffer;
1089
1090 if( !aText.isEmpty() )
1091 {
1092 if( (size_t) (2*aText.getLength()) > SAL_N_ELEMENTS(nDXBuffer) )
1093 {
1094 pDXBuffer.reset(new long[2*(aText.getLength()+1)]);
1095 pDX = pDXBuffer.get();
1096 }
1097
1098 GetCaretPositions( aText, pDX, 0, aText.getLength() );
1099
1100 if( maSelection.Max() < aText.getLength() )
1101 nTextPos = pDX[ 2*maSelection.Max() ];
1102 else
1103 nTextPos = pDX[ 2*aText.getLength()-1 ];
1104 }
1105
1106 long nCursorWidth = 0;
1107 if ( !mbInsertMode && !maSelection.Len() && (maSelection.Max() < aText.getLength()) )
1108 nCursorWidth = GetTextWidth(aText, maSelection.Max(), 1);
1109 long nCursorPosX = nTextPos + mnXOffset + ImplGetExtraXOffset();
1110
1111 // cursor should land in visible area
1112 const Size aOutSize = GetOutputSizePixel();
1113 if ( (nCursorPosX < 0) || (nCursorPosX >= aOutSize.Width()) )
1114 {
1115 long nOldXOffset = mnXOffset;
1116
1117 if ( nCursorPosX < 0 )
1118 {
1119 mnXOffset = - nTextPos;
1120 long nMaxX = 0;
1121 mnXOffset += aOutSize.Width() / 5;
1122 if ( mnXOffset > nMaxX )
1123 mnXOffset = nMaxX;
1124 }
1125 else
1126 {
1127 mnXOffset = (aOutSize.Width()-ImplGetExtraXOffset()) - nTextPos;
1128 // Etwas mehr?
1129 if ( (aOutSize.Width()-ImplGetExtraXOffset()) < nTextPos )
1130 {
1131 long nMaxNegX = (aOutSize.Width()-ImplGetExtraXOffset()) - GetTextWidth( aText );
1132 mnXOffset -= aOutSize.Width() / 5;
1133 if ( mnXOffset < nMaxNegX ) // beides negativ...
1134 mnXOffset = nMaxNegX;
1135 }
1136 }
1137
1138 nCursorPosX = nTextPos + mnXOffset + ImplGetExtraXOffset();
1139 if ( nCursorPosX == aOutSize.Width() ) // dann nicht sichtbar...
1140 nCursorPosX--;
1141
1142 if ( mnXOffset != nOldXOffset )
1143 ImplInvalidateOrRepaint();
1144 }
1145
1146 const long nTextHeight = GetTextHeight();
1147 const long nCursorPosY = ImplGetTextYPosition();
1148 if (pCursor)
1149 {
1150 pCursor->SetPos( Point( nCursorPosX, nCursorPosY ) );
1151 pCursor->SetSize( Size( nCursorWidth, nTextHeight ) );
1152 pCursor->Show();
1153 }
1154 }
1155
1156 void Edit::ImplAlign()
1157 {
1158 long nTextWidth = GetTextWidth( ImplGetText() );
1159 long nOutWidth = GetOutputSizePixel().Width();
1160
1161 if ( mnAlign == EDIT_ALIGN_LEFT )
1162 {
1163 if( mnXOffset && ( nTextWidth < nOutWidth ) )
1164 mnXOffset = 0;
1165
1166 }
1167 else if ( mnAlign == EDIT_ALIGN_RIGHT )
1168 {
1169 long nMinXOffset = nOutWidth - nTextWidth - 1 - ImplGetExtraXOffset();
1170 bool bRTL = IsRTLEnabled();
1171 if( mbIsSubEdit && GetParent() )
1172 bRTL = GetParent()->IsRTLEnabled();
1173 if( bRTL )
1174 {
1175 if( nTextWidth < nOutWidth )
1176 mnXOffset = nMinXOffset;
1177 }
1178 else
1179 {
1180 if( nTextWidth < nOutWidth )
1181 mnXOffset = nMinXOffset;
1182 else if ( mnXOffset < nMinXOffset )
1183 mnXOffset = nMinXOffset;
1184 }
1185 }
1186 else if( mnAlign == EDIT_ALIGN_CENTER )
1187 {
1188 // would be nicer with check while scrolling but then it's not centred in scrolled state
1189 mnXOffset = (nOutWidth - nTextWidth) / 2;
1190 }
1191 }
1192
1193 void Edit::ImplAlignAndPaint()
1194 {
1195 ImplAlign();
1196 ImplInvalidateOrRepaint();
1197 ImplShowCursor();
1198 }
1199
1200 sal_Int32 Edit::ImplGetCharPos( const Point& rWindowPos ) const
1201 {
1202 sal_Int32 nIndex = EDIT_NOLIMIT;
1203 OUString aText = ImplGetText();
1204
1205 long nDXBuffer[256];
1206 std::unique_ptr<long[]> pDXBuffer;
1207 long* pDX = nDXBuffer;
1208 if( (size_t) (2*aText.getLength()) > SAL_N_ELEMENTS(nDXBuffer) )
1209 {
1210 pDXBuffer.reset(new long[2*(aText.getLength()+1)]);
1211 pDX = pDXBuffer.get();
1212 }
1213
1214 GetCaretPositions( aText, pDX, 0, aText.getLength() );
1215 long nX = rWindowPos.X() - mnXOffset - ImplGetExtraXOffset();
1216 for( sal_Int32 i = 0; i < aText.getLength(); i++ )
1217 {
1218 if( (pDX[2*i] >= nX && pDX[2*i+1] <= nX) ||
1219 (pDX[2*i+1] >= nX && pDX[2*i] <= nX))
1220 {
1221 nIndex = i;
1222 if( pDX[2*i] < pDX[2*i+1] )
1223 {
1224 if( nX > (pDX[2*i]+pDX[2*i+1])/2 )
1225 nIndex++;
1226 }
1227 else
1228 {
1229 if( nX < (pDX[2*i]+pDX[2*i+1])/2 )
1230 nIndex++;
1231 }
1232 break;
1233 }
1234 }
1235 if( nIndex == EDIT_NOLIMIT )
1236 {
1237 nIndex = 0;
1238 long nDiff = std::abs( pDX[0]-nX );
1239 for( sal_Int32 i = 1; i < aText.getLength(); i++ )
1240 {
1241 long nNewDiff = std::abs( pDX[2*i]-nX );
1242
1243 if( nNewDiff < nDiff )
1244 {
1245 nIndex = i;
1246 nDiff = nNewDiff;
1247 }
1248 }
1249 if( nIndex == aText.getLength()-1 && std::abs( pDX[2*nIndex+1] - nX ) < nDiff )
1250 nIndex = EDIT_NOLIMIT;
1251 }
1252
1253 return nIndex;
1254 }
1255
1256 void Edit::ImplSetCursorPos( sal_Int32 nChar, bool bSelect )
1257 {
1258 Selection aSelection( maSelection );
1259 aSelection.Max() = nChar;
1260 if ( !bSelect )
1261 aSelection.Min() = aSelection.Max();
1262 ImplSetSelection( aSelection );
1263 }
1264
1265 void Edit::ImplCopyToSelectionClipboard()
1266 {
1267 if ( GetSelection().Len() )
1268 {
1269 css::uno::Reference<css::datatransfer::clipboard::XClipboard> aSelection(GetPrimarySelection());
1270 ImplCopy( aSelection );
1271 }
1272 }
1273
1274 void Edit::ImplCopy( uno::Reference< datatransfer::clipboard::XClipboard >& rxClipboard )
1275 {
1276 vcl::unohelper::TextDataObject::CopyStringTo( GetSelected(), rxClipboard );
1277 }
1278
1279 void Edit::ImplPaste( uno::Reference< datatransfer::clipboard::XClipboard >& rxClipboard )
1280 {
1281 if ( rxClipboard.is() )
1282 {
1283 uno::Reference< datatransfer::XTransferable > xDataObj;
1284
1285 try
1286 {
1287 SolarMutexReleaser aReleaser;
1288 xDataObj = rxClipboard->getContents();
1289 }
1290 catch( const css::uno::Exception& )
1291 {
1292 }
1293
1294 if ( xDataObj.is() )
1295 {
1296 datatransfer::DataFlavor aFlavor;
1297 SotExchange::GetFormatDataFlavor( SotClipboardFormatId::STRING, aFlavor );
1298 try
1299 {
1300 uno::Any aData = xDataObj->getTransferData( aFlavor );
1301 OUString aText;
1302 aData >>= aText;
1303 if( ImplTruncateToMaxLen( aText, maSelection.Len() ) )
1304 ShowTruncationWarning( this );
1305 ReplaceSelected( aText );
1306 }
1307 catch( const css::uno::Exception& )
1308 {
1309 }
1310 }
1311 }
1312 }
1313
1314 void Edit::MouseButtonDown( const MouseEvent& rMEvt )
1315 {
1316 if ( mpSubEdit )
1317 {
1318 Control::MouseButtonDown( rMEvt );
1319 return;
1320 }
1321
1322 sal_Int32 nCharPos = ImplGetCharPos( rMEvt.GetPosPixel() );
1323 Selection aSelection( maSelection );
1324 aSelection.Justify();
1325
1326 if ( rMEvt.GetClicks() < 4 )
1327 {
1328 mbClickedInSelection = false;
1329 if ( rMEvt.GetClicks() == 3 )
1330 {
1331 ImplSetSelection( Selection( 0, EDIT_NOLIMIT) );
1332 ImplCopyToSelectionClipboard();
1333
1334 }
1335 else if ( rMEvt.GetClicks() == 2 )
1336 {
1337 uno::Reference < i18n::XBreakIterator > xBI = ImplGetBreakIterator();
1338 i18n::Boundary aBoundary = xBI->getWordBoundary( maText.toString(), aSelection.Max(),
1339 GetSettings().GetLanguageTag().getLocale(), i18n::WordType::ANYWORD_IGNOREWHITESPACES, true );
1340 ImplSetSelection( Selection( aBoundary.startPos, aBoundary.endPos ) );
1341 ImplCopyToSelectionClipboard();
1342 }
1343 else if ( !rMEvt.IsShift() && HasFocus() && aSelection.IsInside( nCharPos ) )
1344 mbClickedInSelection = true;
1345 else if ( rMEvt.IsLeft() )
1346 ImplSetCursorPos( nCharPos, rMEvt.IsShift() );
1347
1348 if ( !mbClickedInSelection && rMEvt.IsLeft() && ( rMEvt.GetClicks() == 1 ) )
1349 StartTracking( StartTrackingFlags::ScrollRepeat );
1350 }
1351
1352 mbInMBDown = true; // then do not select all in GetFocus
1353 GrabFocus();
1354 mbInMBDown = false;
1355 }
1356
1357 void Edit::MouseButtonUp( const MouseEvent& rMEvt )
1358 {
1359 if ( mbClickedInSelection && rMEvt.IsLeft() )
1360 {
1361 sal_Int32 nCharPos = ImplGetCharPos( rMEvt.GetPosPixel() );
1362 ImplSetCursorPos( nCharPos, false );
1363 mbClickedInSelection = false;
1364 }
1365 else if ( rMEvt.IsMiddle() && !mbReadOnly &&
1366 ( GetSettings().GetMouseSettings().GetMiddleButtonAction() == MouseMiddleButtonAction::PasteSelection ) )
1367 {
1368 css::uno::Reference<css::datatransfer::clipboard::XClipboard> aSelection(Window::GetPrimarySelection());
1369 ImplPaste( aSelection );
1370 ImplModified();
1371 }
1372 }
1373
1374 void Edit::Tracking( const TrackingEvent& rTEvt )
1375 {
1376 if ( rTEvt.IsTrackingEnded() )
1377 {
1378 if ( mbClickedInSelection )
1379 {
1380 sal_Int32 nCharPos = ImplGetCharPos( rTEvt.GetMouseEvent().GetPosPixel() );
1381 ImplSetCursorPos( nCharPos, false );
1382 mbClickedInSelection = false;
1383 }
1384 else if ( rTEvt.GetMouseEvent().IsLeft() )
1385 {
1386 ImplCopyToSelectionClipboard();
1387 }
1388 }
1389 else
1390 {
1391 if( !mbClickedInSelection )
1392 {
1393 sal_Int32 nCharPos = ImplGetCharPos( rTEvt.GetMouseEvent().GetPosPixel() );
1394 ImplSetCursorPos( nCharPos, true );
1395 }
1396 }
1397
1398 if ( mpUpdateDataTimer && !mbIsSubEdit && mpUpdateDataTimer->IsActive() )
1399 mpUpdateDataTimer->Start();//do not update while the user is still travelling in the control
1400 }
1401
1402 bool Edit::ImplHandleKeyEvent( const KeyEvent& rKEvt )
1403 {
1404 bool bDone = false;
1405 sal_uInt16 nCode = rKEvt.GetKeyCode().GetCode();
1406 KeyFuncType eFunc = rKEvt.GetKeyCode().GetFunction();
1407
1408 mbInternModified = false;
1409
1410 if ( eFunc != KeyFuncType::DONTKNOW )
1411 {
1412 switch ( eFunc )
1413 {
1414 case KeyFuncType::CUT:
1415 {
1416 if ( !mbReadOnly && maSelection.Len() && !(GetStyle() & WB_PASSWORD) )
1417 {
1418 Cut();
1419 ImplModified();
1420 bDone = true;
1421 }
1422 }
1423 break;
1424
1425 case KeyFuncType::COPY:
1426 {
1427 if ( !(GetStyle() & WB_PASSWORD) )
1428 {
1429 Copy();
1430 bDone = true;
1431 }
1432 }
1433 break;
1434
1435 case KeyFuncType::PASTE:
1436 {
1437 if ( !mbReadOnly )
1438 {
1439 Paste();
1440 bDone = true;
1441 }
1442 }
1443 break;
1444
1445 case KeyFuncType::UNDO:
1446 {
1447 if ( !mbReadOnly )
1448 {
1449 Undo();
1450 bDone = true;
1451 }
1452 }
1453 break;
1454
1455 default:
1456 eFunc = KeyFuncType::DONTKNOW;
1457 }
1458 }
1459
1460 if ( !bDone && rKEvt.GetKeyCode().IsMod1() && !rKEvt.GetKeyCode().IsMod2() )
1461 {
1462 if ( nCode == KEY_A )
1463 {
1464 ImplSetSelection( Selection( 0, maText.getLength() ) );
1465 bDone = true;
1466 }
1467 else if ( rKEvt.GetKeyCode().IsShift() && (nCode == KEY_S) )
1468 {
1469 if ( pImplFncGetSpecialChars )
1470 {
1471 Selection aSaveSel = GetSelection(); // if someone changes the selection in Get/LoseFocus, e.g. URL bar
1472 OUString aChars = pImplFncGetSpecialChars( this, GetFont() );
1473 SetSelection( aSaveSel );
1474 if ( !aChars.isEmpty() )
1475 {
1476 ImplInsertText( aChars );
1477 ImplModified();
1478 }
1479 bDone = true;
1480 }
1481 }
1482 }
1483
1484 if ( eFunc == KeyFuncType::DONTKNOW && ! bDone )
1485 {
1486 switch ( nCode )
1487 {
1488 case css::awt::Key::SELECT_ALL:
1489 {
1490 ImplSetSelection( Selection( 0, maText.getLength() ) );
1491 bDone = true;
1492 }
1493 break;
1494
1495 case KEY_LEFT:
1496 case KEY_RIGHT:
1497 case KEY_HOME:
1498 case KEY_END:
1499 case css::awt::Key::MOVE_WORD_FORWARD:
1500 case css::awt::Key::SELECT_WORD_FORWARD:
1501 case css::awt::Key::MOVE_WORD_BACKWARD:
1502 case css::awt::Key::SELECT_WORD_BACKWARD:
1503 case css::awt::Key::MOVE_TO_BEGIN_OF_LINE:
1504 case css::awt::Key::MOVE_TO_END_OF_LINE:
1505 case css::awt::Key::SELECT_TO_BEGIN_OF_LINE:
1506 case css::awt::Key::SELECT_TO_END_OF_LINE:
1507 case css::awt::Key::MOVE_TO_BEGIN_OF_PARAGRAPH:
1508 case css::awt::Key::MOVE_TO_END_OF_PARAGRAPH:
1509 case css::awt::Key::SELECT_TO_BEGIN_OF_PARAGRAPH:
1510 case css::awt::Key::SELECT_TO_END_OF_PARAGRAPH:
1511 case css::awt::Key::MOVE_TO_BEGIN_OF_DOCUMENT:
1512 case css::awt::Key::MOVE_TO_END_OF_DOCUMENT:
1513 case css::awt::Key::SELECT_TO_BEGIN_OF_DOCUMENT:
1514 case css::awt::Key::SELECT_TO_END_OF_DOCUMENT:
1515 {
1516 if ( !rKEvt.GetKeyCode().IsMod2() )
1517 {
1518 ImplClearLayoutData();
1519 uno::Reference < i18n::XBreakIterator > xBI = ImplGetBreakIterator();
1520
1521 Selection aSel( maSelection );
1522 bool bWord = rKEvt.GetKeyCode().IsMod1();
1523 bool bSelect = rKEvt.GetKeyCode().IsShift();
1524 bool bGoLeft = (nCode == KEY_LEFT);
1525 bool bGoRight = (nCode == KEY_RIGHT);
1526 bool bGoHome = (nCode == KEY_HOME);
1527 bool bGoEnd = (nCode == KEY_END);
1528
1529 switch( nCode )
1530 {
1531 case css::awt::Key::MOVE_WORD_FORWARD:
1532 bGoRight = bWord = true;break;
1533 case css::awt::Key::SELECT_WORD_FORWARD:
1534 bGoRight = bSelect = bWord = true;break;
1535 case css::awt::Key::MOVE_WORD_BACKWARD:
1536 bGoLeft = bWord = true;break;
1537 case css::awt::Key::SELECT_WORD_BACKWARD:
1538 bGoLeft = bSelect = bWord = true;break;
1539 case css::awt::Key::SELECT_TO_BEGIN_OF_LINE:
1540 case css::awt::Key::SELECT_TO_BEGIN_OF_PARAGRAPH:
1541 case css::awt::Key::SELECT_TO_BEGIN_OF_DOCUMENT:
1542 bSelect = true;
1543 SAL_FALLTHROUGH;
1544 case css::awt::Key::MOVE_TO_BEGIN_OF_LINE:
1545 case css::awt::Key::MOVE_TO_BEGIN_OF_PARAGRAPH:
1546 case css::awt::Key::MOVE_TO_BEGIN_OF_DOCUMENT:
1547 bGoHome = true;break;
1548 case css::awt::Key::SELECT_TO_END_OF_LINE:
1549 case css::awt::Key::SELECT_TO_END_OF_PARAGRAPH:
1550 case css::awt::Key::SELECT_TO_END_OF_DOCUMENT:
1551 bSelect = true;
1552 SAL_FALLTHROUGH;
1553 case css::awt::Key::MOVE_TO_END_OF_LINE:
1554 case css::awt::Key::MOVE_TO_END_OF_PARAGRAPH:
1555 case css::awt::Key::MOVE_TO_END_OF_DOCUMENT:
1556 bGoEnd = true;break;
1557 default:
1558 break;
1559 };
1560
1561 // Range wird in ImplSetSelection geprueft...
1562 if ( bGoLeft && aSel.Max() )
1563 {
1564 if ( bWord )
1565 {
1566 i18n::Boundary aBoundary = xBI->getWordBoundary( maText.toString(), aSel.Max(),
1567 GetSettings().GetLanguageTag().getLocale(), i18n::WordType::ANYWORD_IGNOREWHITESPACES, true );
1568 if ( aBoundary.startPos == aSel.Max() )
1569 aBoundary = xBI->previousWord( maText.toString(), aSel.Max(),
1570 GetSettings().GetLanguageTag().getLocale(), i18n::WordType::ANYWORD_IGNOREWHITESPACES );
1571 aSel.Max() = aBoundary.startPos;
1572 }
1573 else
1574 {
1575 sal_Int32 nCount = 1;
1576 aSel.Max() = xBI->previousCharacters( maText.toString(), aSel.Max(),
1577 GetSettings().GetLanguageTag().getLocale(), i18n::CharacterIteratorMode::SKIPCHARACTER, nCount, nCount );
1578 }
1579 }
1580 else if ( bGoRight && ( aSel.Max() < maText.getLength() ) )
1581 {
1582 if ( bWord )
1583 {
1584 i18n::Boundary aBoundary = xBI->nextWord( maText.toString(), aSel.Max(),
1585 GetSettings().GetLanguageTag().getLocale(), i18n::WordType::ANYWORD_IGNOREWHITESPACES );
1586 aSel.Max() = aBoundary.startPos;
1587 }
1588 else
1589 {
1590 sal_Int32 nCount = 1;
1591 aSel.Max() = xBI->nextCharacters( maText.toString(), aSel.Max(),
1592 GetSettings().GetLanguageTag().getLocale(), i18n::CharacterIteratorMode::SKIPCHARACTER, nCount, nCount );
1593 }
1594 }
1595 else if ( bGoHome )
1596 {
1597 aSel.Max() = 0;
1598 }
1599 else if ( bGoEnd )
1600 {
1601 aSel.Max() = EDIT_NOLIMIT;
1602 }
1603
1604 if ( !bSelect )
1605 aSel.Min() = aSel.Max();
1606
1607 if ( aSel != GetSelection() )
1608 {
1609 ImplSetSelection( aSel );
1610 ImplCopyToSelectionClipboard();
1611 }
1612
1613 if (bGoEnd && maAutocompleteHdl.IsSet() && !rKEvt.GetKeyCode().GetModifier())
1614 {
1615 if ( (maSelection.Min() == maSelection.Max()) && (maSelection.Min() == maText.getLength()) )
1616 {
1617 maAutocompleteHdl.Call(*this);
1618 }
1619 }
1620
1621 bDone = true;
1622 }
1623 }
1624 break;
1625
1626 case css::awt::Key::DELETE_WORD_BACKWARD:
1627 case css::awt::Key::DELETE_WORD_FORWARD:
1628 case css::awt::Key::DELETE_TO_BEGIN_OF_LINE:
1629 case css::awt::Key::DELETE_TO_END_OF_LINE:
1630 case KEY_BACKSPACE:
1631 case KEY_DELETE:
1632 {
1633 if ( !mbReadOnly && !rKEvt.GetKeyCode().IsMod2() )
1634 {
1635 sal_uInt8 nDel = (nCode == KEY_DELETE) ? EDIT_DEL_RIGHT : EDIT_DEL_LEFT;
1636 sal_uInt8 nMode = rKEvt.GetKeyCode().IsMod1() ? EDIT_DELMODE_RESTOFWORD : EDIT_DELMODE_SIMPLE;
1637 if ( (nMode == EDIT_DELMODE_RESTOFWORD) && rKEvt.GetKeyCode().IsShift() )
1638 nMode = EDIT_DELMODE_RESTOFCONTENT;
1639 switch( nCode )
1640 {
1641 case css::awt::Key::DELETE_WORD_BACKWARD:
1642 nDel = EDIT_DEL_LEFT;
1643 nMode = EDIT_DELMODE_RESTOFWORD;
1644 break;
1645 case css::awt::Key::DELETE_WORD_FORWARD:
1646 nDel = EDIT_DEL_RIGHT;
1647 nMode = EDIT_DELMODE_RESTOFWORD;
1648 break;
1649 case css::awt::Key::DELETE_TO_BEGIN_OF_LINE:
1650 nDel = EDIT_DEL_LEFT;
1651 nMode = EDIT_DELMODE_RESTOFCONTENT;
1652 break;
1653 case css::awt::Key::DELETE_TO_END_OF_LINE:
1654 nDel = EDIT_DEL_RIGHT;
1655 nMode = EDIT_DELMODE_RESTOFCONTENT;
1656 break;
1657 default: break;
1658 }
1659 sal_Int32 nOldLen = maText.getLength();
1660 ImplDelete( maSelection, nDel, nMode );
1661 if ( maText.getLength() != nOldLen )
1662 ImplModified();
1663 bDone = true;
1664 }
1665 }
1666 break;
1667
1668 case KEY_INSERT:
1669 {
1670 if ( !mpIMEInfos && !mbReadOnly && !rKEvt.GetKeyCode().IsMod2() )
1671 {
1672 SetInsertMode( !mbInsertMode );
1673 bDone = true;
1674 }
1675 }
1676 break;
1677
1678 default:
1679 {
1680 if ( IsCharInput( rKEvt ) )
1681 {
1682 bDone = true; // read characters also when in ReadOnly
1683 if ( !mbReadOnly )
1684 {
1685 ImplInsertText(OUString(rKEvt.GetCharCode()), nullptr, true);
1686 if (maAutocompleteHdl.IsSet())
1687 {
1688 if ( (maSelection.Min() == maSelection.Max()) && (maSelection.Min() == maText.getLength()) )
1689 {
1690 maAutocompleteHdl.Call(*this);
1691 }
1692 }
1693 }
1694 }
1695 }
1696 }
1697 }
1698
1699 if ( mbInternModified )
1700 ImplModified();
1701
1702 return bDone;
1703 }
1704
1705 void Edit::KeyInput( const KeyEvent& rKEvt )
1706 {
1707 if ( mpUpdateDataTimer && !mbIsSubEdit && mpUpdateDataTimer->IsActive() )
1708 mpUpdateDataTimer->Start();//do not update while the user is still travelling in the control
1709
1710 if ( mpSubEdit || !ImplHandleKeyEvent( rKEvt ) )
1711 Control::KeyInput( rKEvt );
1712 }
1713
1714 void Edit::FillLayoutData() const
1715 {
1716 mpControlData->mpLayoutData.reset( new vcl::ControlLayoutData );
1717 const_cast<Edit*>(this)->Invalidate();
1718 }
1719
1720 void Edit::Paint(vcl::RenderContext& rRenderContext, const Rectangle& rRectangle)
1721 {
1722 if (!mpSubEdit)
1723 ImplRepaint(rRenderContext, rRectangle);
1724 }
1725
1726 void Edit::Resize()
1727 {
1728 if ( !mpSubEdit && IsReallyVisible() )
1729 {
1730 Control::Resize();
1731 // Wegen vertikaler Zentrierung...
1732 mnXOffset = 0;
1733 ImplAlign();
1734 Invalidate();
1735 ImplShowCursor();
1736 }
1737 }
1738
1739 void Edit::Draw( OutputDevice* pDev, const Point& rPos, const Size& rSize, DrawFlags nFlags )
1740 {
1741 ApplySettings(*pDev);
1742
1743 Point aPos = pDev->LogicToPixel( rPos );
1744 Size aSize = pDev->LogicToPixel( rSize );
1745 vcl::Font aFont = GetDrawPixelFont( pDev );
1746 OutDevType eOutDevType = pDev->GetOutDevType();
1747
1748 pDev->Push();
1749 pDev->SetMapMode();
1750 pDev->SetFont( aFont );
1751 pDev->SetTextFillColor();
1752
1753 // Border/Background
1754 pDev->SetLineColor();
1755 pDev->SetFillColor();
1756 bool bBorder = !(nFlags & DrawFlags::NoBorder ) && (GetStyle() & WB_BORDER);
1757 bool bBackground = !(nFlags & DrawFlags::NoBackground) && IsControlBackground();
1758 if ( bBorder || bBackground )
1759 {
1760 Rectangle aRect( aPos, aSize );
1761 if ( bBorder )
1762 {
1763 ImplDrawFrame( pDev, aRect );
1764 }
1765 if ( bBackground )
1766 {
1767 pDev->SetFillColor( GetControlBackground() );
1768 pDev->DrawRect( aRect );
1769 }
1770 }
1771
1772 // Inhalt
1773 if ( ( nFlags & DrawFlags::Mono ) || ( eOutDevType == OUTDEV_PRINTER ) )
1774 pDev->SetTextColor( Color( COL_BLACK ) );
1775 else
1776 {
1777 if ( !(nFlags & DrawFlags::NoDisable ) && !IsEnabled() )
1778 {
1779 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
1780 pDev->SetTextColor( rStyleSettings.GetDisableColor() );
1781 }
1782 else
1783 {
1784 pDev->SetTextColor( GetTextColor() );
1785 }
1786 }
1787
1788 const long nOnePixel = GetDrawPixel( pDev, 1 );
1789 const long nOffX = 3*nOnePixel;
1790 DrawTextFlags nTextStyle = DrawTextFlags::VCenter;
1791 Rectangle aTextRect( aPos, aSize );
1792
1793 if ( GetStyle() & WB_CENTER )
1794 nTextStyle |= DrawTextFlags::Center;
1795 else if ( GetStyle() & WB_RIGHT )
1796 nTextStyle |= DrawTextFlags::Right;
1797 else
1798 nTextStyle |= DrawTextFlags::Left;
1799
1800 aTextRect.Left() += nOffX;
1801 aTextRect.Right() -= nOffX;
1802
1803 OUString aText = ImplGetText();
1804 long nTextHeight = pDev->GetTextHeight();
1805 long nTextWidth = pDev->GetTextWidth( aText );
1806 long nOffY = (aSize.Height() - nTextHeight) / 2;
1807
1808 // Clipping?
1809 if ( (nOffY < 0) ||
1810 ((nOffY+nTextHeight) > aSize.Height()) ||
1811 ((nOffX+nTextWidth) > aSize.Width()) )
1812 {
1813 Rectangle aClip( aPos, aSize );
1814 if ( nTextHeight > aSize.Height() )
1815 aClip.Bottom() += nTextHeight-aSize.Height()+1; // prevent HP printers from 'optimizing'
1816 pDev->IntersectClipRegion( aClip );
1817 }
1818
1819 pDev->DrawText( aTextRect, aText, nTextStyle );
1820 pDev->Pop();
1821
1822 if ( GetSubEdit() )
1823 {
1824 GetSubEdit()->Draw( pDev, rPos, rSize, nFlags );
1825 }
1826 }
1827
1828 void Edit::ImplInvalidateOutermostBorder( vcl::Window* pWin )
1829 {
1830 // allow control to show focused state
1831 vcl::Window *pInvalWin = pWin, *pBorder = pWin;
1832 while( ( pBorder = pInvalWin->GetWindow( GetWindowType::Border ) ) != pInvalWin && pBorder &&
1833 pInvalWin->ImplGetFrame() == pBorder->ImplGetFrame() )
1834 {
1835 pInvalWin = pBorder;
1836 }
1837
1838 pInvalWin->Invalidate( InvalidateFlags::Children | InvalidateFlags::Update );
1839 }
1840
1841 void Edit::GetFocus()
1842 {
1843 if ( mpSubEdit )
1844 mpSubEdit->ImplGrabFocus( GetGetFocusFlags() );
1845 else if ( !mbActivePopup )
1846 {
1847 maUndoText = maText.toString();
1848
1849 SelectionOptions nSelOptions = GetSettings().GetStyleSettings().GetSelectionOptions();
1850 if ( !( GetStyle() & (WB_NOHIDESELECTION|WB_READONLY) )
1851 && ( GetGetFocusFlags() & (GetFocusFlags::Init|GetFocusFlags::Tab|GetFocusFlags::CURSOR|GetFocusFlags::Mnemonic) ) )
1852 {
1853 if ( nSelOptions & SelectionOptions::ShowFirst )
1854 {
1855 maSelection.Min() = maText.getLength();
1856 maSelection.Max() = 0;
1857 }
1858 else
1859 {
1860 maSelection.Min() = 0;
1861 maSelection.Max() = maText.getLength();
1862 }
1863 if ( mbIsSubEdit )
1864 static_cast<Edit*>(GetParent())->CallEventListeners( VCLEVENT_EDIT_SELECTIONCHANGED );
1865 else
1866 CallEventListeners( VCLEVENT_EDIT_SELECTIONCHANGED );
1867 }
1868
1869 ImplShowCursor();
1870
1871 // FIXME: this is currently only on OS X
1872 // check for other platforms that need similar handling
1873 if( ImplGetSVData()->maNWFData.mbNoFocusRects &&
1874 IsNativeWidgetEnabled() &&
1875 IsNativeControlSupported( ControlType::Editbox, ControlPart::Entire ) )
1876 {
1877 ImplInvalidateOutermostBorder( mbIsSubEdit ? GetParent() : this );
1878 }
1879 else if ( maSelection.Len() )
1880 {
1881 // Selektion malen
1882 if ( !HasPaintEvent() )
1883 ImplInvalidateOrRepaint();
1884 else
1885 Invalidate();
1886 }
1887
1888 SetInputContext( InputContext( GetFont(), !IsReadOnly() ? InputContextFlags::Text|InputContextFlags::ExtText : InputContextFlags::NONE ) );
1889 }
1890
1891 Control::GetFocus();
1892 }
1893
1894 void Edit::LoseFocus()
1895 {
1896 if ( mpUpdateDataTimer && !mbIsSubEdit && mpUpdateDataTimer->IsActive() )
1897 {
1898 //notify an update latest when the focus is lost
1899 mpUpdateDataTimer->Stop();
1900 mpUpdateDataTimer->Timeout();
1901 }
1902
1903 if ( !mpSubEdit )
1904 {
1905 // FIXME: this is currently only on OS X
1906 // check for other platforms that need similar handling
1907 if( ImplGetSVData()->maNWFData.mbNoFocusRects &&
1908 IsNativeWidgetEnabled() &&
1909 IsNativeControlSupported( ControlType::Editbox, ControlPart::Entire ) )
1910 {
1911 ImplInvalidateOutermostBorder( mbIsSubEdit ? GetParent() : this );
1912 }
1913
1914 if ( !mbActivePopup && !( GetStyle() & WB_NOHIDESELECTION ) && maSelection.Len() )
1915 ImplInvalidateOrRepaint(); // Selektion malen
1916 }
1917
1918 Control::LoseFocus();
1919 }
1920
1921 void Edit::Command( const CommandEvent& rCEvt )
1922 {
1923 if ( rCEvt.GetCommand() == CommandEventId::ContextMenu )
1924 {
1925 VclPtr<PopupMenu> pPopup = Edit::CreatePopupMenu();
1926
1927 if ( !maSelection.Len() )
1928 {
1929 pPopup->EnableItem( SV_MENU_EDIT_CUT, false );
1930 pPopup->EnableItem( SV_MENU_EDIT_COPY, false );
1931 pPopup->EnableItem( SV_MENU_EDIT_DELETE, false );
1932 }
1933
1934 if ( IsReadOnly() )
1935 {
1936 pPopup->EnableItem( SV_MENU_EDIT_CUT, false );
1937 pPopup->EnableItem( SV_MENU_EDIT_PASTE, false );
1938 pPopup->EnableItem( SV_MENU_EDIT_DELETE, false );
1939 pPopup->EnableItem( SV_MENU_EDIT_INSERTSYMBOL, false );
1940 }
1941 else
1942 {
1943 // only paste if text available in clipboard
1944 bool bData = false;
1945 uno::Reference< datatransfer::clipboard::XClipboard > xClipboard = GetClipboard();
1946
1947 if ( xClipboard.is() )
1948 {
1949 uno::Reference< datatransfer::XTransferable > xDataObj;
1950 {
1951 SolarMutexReleaser aReleaser;
1952 xDataObj = xClipboard->getContents();
1953 }
1954 if ( xDataObj.is() )
1955 {
1956 datatransfer::DataFlavor aFlavor;
1957 SotExchange::GetFormatDataFlavor( SotClipboardFormatId::STRING, aFlavor );
1958 bData = xDataObj->isDataFlavorSupported( aFlavor );
1959 }
1960 }
1961 pPopup->EnableItem( SV_MENU_EDIT_PASTE, bData );
1962 }
1963
1964 if ( maUndoText == maText.getStr() )
1965 pPopup->EnableItem( SV_MENU_EDIT_UNDO, false );
1966 if ( ( maSelection.Min() == 0 ) && ( maSelection.Max() == maText.getLength() ) )
1967 pPopup->EnableItem( SV_MENU_EDIT_SELECTALL, false );
1968 if ( !pImplFncGetSpecialChars )
1969 {
1970 sal_uInt16 nPos = pPopup->GetItemPos( SV_MENU_EDIT_INSERTSYMBOL );
1971 pPopup->RemoveItem( nPos );
1972 pPopup->RemoveItem( nPos-1 );
1973 }
1974
1975 mbActivePopup = true;
1976 Selection aSaveSel = GetSelection(); // if someone changes selection in Get/LoseFocus, e.g. URL bar
1977 Point aPos = rCEvt.GetMousePosPixel();
1978 if ( !rCEvt.IsMouseEvent() )
1979 {
1980 // Show menu eventually centered in selection
1981 Size aSize = GetOutputSizePixel();
1982 aPos = Point( aSize.Width()/2, aSize.Height()/2 );
1983 }
1984 sal_uInt16 n = pPopup->Execute( this, aPos );
1985 pPopup.disposeAndClear();
1986 SetSelection( aSaveSel );
1987 switch ( n )
1988 {
1989 case SV_MENU_EDIT_UNDO:
1990 Undo();
1991 ImplModified();
1992 break;
1993 case SV_MENU_EDIT_CUT:
1994 Cut();
1995 ImplModified();
1996 break;
1997 case SV_MENU_EDIT_COPY:
1998 Copy();
1999 break;
2000 case SV_MENU_EDIT_PASTE:
2001 Paste();
2002 ImplModified();
2003 break;
2004 case SV_MENU_EDIT_DELETE:
2005 DeleteSelected();
2006 ImplModified();
2007 break;
2008 case SV_MENU_EDIT_SELECTALL:
2009 ImplSetSelection( Selection( 0, maText.getLength() ) );
2010 break;
2011 case SV_MENU_EDIT_INSERTSYMBOL:
2012 {
2013 OUString aChars = pImplFncGetSpecialChars( this, GetFont() );
2014 SetSelection( aSaveSel );
2015 if ( !aChars.isEmpty() )
2016 {
2017 ImplInsertText( aChars );
2018 ImplModified();
2019 }
2020 }
2021 break;
2022 }
2023 mbActivePopup = false;
2024 }
2025 else if ( rCEvt.GetCommand() == CommandEventId::StartExtTextInput )
2026 {
2027 DeleteSelected();
2028 delete mpIMEInfos;
2029 sal_Int32 nPos = static_cast<sal_Int32>(maSelection.Max());
2030 mpIMEInfos = new Impl_IMEInfos( nPos, OUString(maText.getStr() + nPos ) );
2031 mpIMEInfos->bWasCursorOverwrite = !IsInsertMode();
2032 }
2033 else if ( rCEvt.GetCommand() == CommandEventId::EndExtTextInput )
2034 {
2035 bool bInsertMode = !mpIMEInfos->bWasCursorOverwrite;
2036 delete mpIMEInfos;
2037 mpIMEInfos = nullptr;
2038
2039 SetInsertMode(bInsertMode);
2040 ImplModified();
2041
2042 Invalidate();
2043
2044 // #i25161# call auto complete handler for ext text commit also
2045 if (maAutocompleteHdl.IsSet())
2046 {
2047 if ( (maSelection.Min() == maSelection.Max()) && (maSelection.Min() == maText.getLength()) )
2048 {
2049 maAutocompleteHdl.Call(*this);
2050 }
2051 }
2052 }
2053 else if ( rCEvt.GetCommand() == CommandEventId::ExtTextInput )
2054 {
2055 const CommandExtTextInputData* pData = rCEvt.GetExtTextInputData();
2056
2057 maText.remove( mpIMEInfos->nPos, mpIMEInfos->nLen );
2058 maText.insert( mpIMEInfos->nPos, pData->GetText() );
2059 if ( mpIMEInfos->bWasCursorOverwrite )
2060 {
2061 const sal_Int32 nOldIMETextLen = mpIMEInfos->nLen;
2062 const sal_Int32 nNewIMETextLen = pData->GetText().getLength();
2063 if ( ( nOldIMETextLen > nNewIMETextLen ) &&
2064 ( nNewIMETextLen < mpIMEInfos->aOldTextAfterStartPos.getLength() ) )
2065 {
2066 // restore old characters
2067 const sal_Int32 nRestore = nOldIMETextLen - nNewIMETextLen;
2068 maText.insert( mpIMEInfos->nPos + nNewIMETextLen, mpIMEInfos->aOldTextAfterStartPos.copy( nNewIMETextLen, nRestore ) );
2069 }
2070 else if ( ( nOldIMETextLen < nNewIMETextLen ) &&
2071 ( nOldIMETextLen < mpIMEInfos->aOldTextAfterStartPos.getLength() ) )
2072 {
2073 const sal_Int32 nOverwrite = ( nNewIMETextLen > mpIMEInfos->aOldTextAfterStartPos.getLength()
2074 ? mpIMEInfos->aOldTextAfterStartPos.getLength() : nNewIMETextLen ) - nOldIMETextLen;
2075 maText.remove( mpIMEInfos->nPos + nNewIMETextLen, nOverwrite );
2076 }
2077 }
2078
2079 if ( pData->GetTextAttr() )
2080 {
2081 mpIMEInfos->CopyAttribs( pData->GetTextAttr(), pData->GetText().getLength() );
2082 mpIMEInfos->bCursor = pData->IsCursorVisible();
2083 }
2084 else
2085 {
2086 mpIMEInfos->DestroyAttribs();
2087 }
2088
2089 ImplAlignAndPaint();
2090 sal_Int32 nCursorPos = mpIMEInfos->nPos + pData->GetCursorPos();
2091 SetSelection( Selection( nCursorPos, nCursorPos ) );
2092 SetInsertMode( !pData->IsCursorOverwrite() );
2093
2094 if ( pData->IsCursorVisible() )
2095 GetCursor()->Show();
2096 else
2097 GetCursor()->Hide();
2098 }
2099 else if ( rCEvt.GetCommand() == CommandEventId::CursorPos )
2100 {
2101 if ( mpIMEInfos )
2102 {
2103 sal_Int32 nCursorPos = GetSelection().Max();
2104 SetCursorRect( nullptr, GetTextWidth( maText.toString(), nCursorPos, mpIMEInfos->nPos+mpIMEInfos->nLen-nCursorPos ) );
2105 }
2106 else
2107 {
2108 SetCursorRect();
2109 }
2110 }
2111 else if ( rCEvt.GetCommand() == CommandEventId::SelectionChange )
2112 {
2113 const CommandSelectionChangeData *pData = rCEvt.GetSelectionChangeData();
2114 Selection aSelection( pData->GetStart(), pData->GetEnd() );
2115 SetSelection(aSelection);
2116 }
2117 else if ( rCEvt.GetCommand() == CommandEventId::QueryCharPosition )
2118 {
2119 if (mpIMEInfos && mpIMEInfos->nLen > 0)
2120 {
2121 OUString aText = ImplGetText();
2122 long nDXBuffer[256];
2123 std::unique_ptr<long[]> pDXBuffer;
2124 long* pDX = nDXBuffer;
2125
2126 if( !aText.isEmpty() )
2127 {
2128 if( (size_t) (2*aText.getLength()) > SAL_N_ELEMENTS(nDXBuffer) )
2129 {
2130 pDXBuffer.reset(new long[2*(aText.getLength()+1)]);
2131 pDX = pDXBuffer.get();
2132 }
2133
2134 GetCaretPositions( aText, pDX, 0, aText.getLength() );
2135 }
2136 long nTH = GetTextHeight();
2137 Point aPos( mnXOffset, ImplGetTextYPosition() );
2138
2139 std::unique_ptr<Rectangle[]> aRects(new Rectangle[ mpIMEInfos->nLen ]);
2140 for ( int nIndex = 0; nIndex < mpIMEInfos->nLen; ++nIndex )
2141 {
2142 Rectangle aRect( aPos, Size( 10, nTH ) );
2143 aRect.Left() = pDX[2*(nIndex+mpIMEInfos->nPos)] + mnXOffset + ImplGetExtraXOffset();
2144 aRects[ nIndex ] = aRect;
2145 }
2146 SetCompositionCharRect( aRects.get(), mpIMEInfos->nLen );
2147 }
2148 }
2149 else
2150 Control::Command( rCEvt );
2151 }
2152
2153 void Edit::StateChanged( StateChangedType nType )
2154 {
2155 if (nType == StateChangedType::InitShow)
2156 {
2157 if (!mpSubEdit)
2158 {
2159 mnXOffset = 0; // if GrabFocus before while size was still wrong
2160 ImplAlign();
2161 if (!mpSubEdit)
2162 ImplShowCursor(false);
2163 Invalidate();
2164 }
2165 }
2166 else if (nType == StateChangedType::Enable)
2167 {
2168 if (!mpSubEdit)
2169 {
2170 // change text color only
2171 ImplInvalidateOrRepaint();
2172 }
2173 }
2174 else if (nType == StateChangedType::Style || nType == StateChangedType::Mirroring)
2175 {
2176 WinBits nStyle = GetStyle();
2177 if (nType == StateChangedType::Style)
2178 {
2179 nStyle = ImplInitStyle(GetStyle());
2180 SetStyle(nStyle);
2181 }
2182
2183 sal_uInt16 nOldAlign = mnAlign;
2184 mnAlign = EDIT_ALIGN_LEFT;
2185
2186 // --- RTL --- hack: right align until keyinput and cursor travelling works
2187 // edits are always RTL disabled
2188 // however the parent edits contain the correct setting
2189 if (mbIsSubEdit && GetParent()->IsRTLEnabled())
2190 {
2191 if (GetParent()->GetStyle() & WB_LEFT)
2192 mnAlign = EDIT_ALIGN_RIGHT;
2193 if (nType == StateChangedType::Mirroring)
2194 SetLayoutMode(ComplexTextLayoutFlags::BiDiRtl | ComplexTextLayoutFlags::TextOriginLeft);
2195 }
2196 else if (mbIsSubEdit && !GetParent()->IsRTLEnabled())
2197 {
2198 if (nType == StateChangedType::Mirroring)
2199 SetLayoutMode(ComplexTextLayoutFlags::TextOriginLeft);
2200 }
2201
2202 if (nStyle & WB_RIGHT)
2203 mnAlign = EDIT_ALIGN_RIGHT;
2204 else if (nStyle & WB_CENTER)
2205 mnAlign = EDIT_ALIGN_CENTER;
2206 if (!maText.isEmpty() && (mnAlign != nOldAlign))
2207 {
2208 ImplAlign();
2209 Invalidate();
2210 }
2211
2212 }
2213 else if (nType == StateChangedType::Zoom)
2214 {
2215 if (!mpSubEdit)
2216 {
2217 ApplySettings(*this);
2218 ImplShowCursor();
2219 Invalidate();
2220 }
2221 }
2222 else if (nType == StateChangedType::ControlFont)
2223 {
2224 if (!mpSubEdit)
2225 {
2226 ApplySettings(*this);
2227 ImplShowCursor();
2228 Invalidate();
2229 }
2230 }
2231 else if (nType == StateChangedType::ControlForeground)
2232 {
2233 if (!mpSubEdit)
2234 {
2235 ApplySettings(*this);
2236 Invalidate();
2237 }
2238 }
2239 else if (nType == StateChangedType::ControlBackground)
2240 {
2241 if (!mpSubEdit)
2242 {
2243 ApplySettings(*this);
2244 Invalidate();
2245 }
2246 }
2247
2248 Control::StateChanged(nType);
2249 }
2250
2251 void Edit::DataChanged( const DataChangedEvent& rDCEvt )
2252 {
2253 if ( (rDCEvt.GetType() == DataChangedEventType::FONTS) ||
2254 (rDCEvt.GetType() == DataChangedEventType::FONTSUBSTITUTION) ||
2255 ((rDCEvt.GetType() == DataChangedEventType::SETTINGS) &&
2256 (rDCEvt.GetFlags() & AllSettingsFlags::STYLE)) )
2257 {
2258 if ( !mpSubEdit )
2259 {
2260 ApplySettings(*this);
2261 ImplShowCursor();
2262 Invalidate();
2263 }
2264 }
2265
2266 Control::DataChanged( rDCEvt );
2267 }
2268
2269 void Edit::ImplShowDDCursor()
2270 {
2271 if (!mpDDInfo->bVisCursor)
2272 {
2273 long nTextWidth = GetTextWidth( maText.toString(), 0, mpDDInfo->nDropPos );
2274 long nTextHeight = GetTextHeight();
2275 Rectangle aCursorRect( Point( nTextWidth + mnXOffset, (GetOutputSize().Height()-nTextHeight)/2 ), Size( 2, nTextHeight ) );
2276 mpDDInfo->aCursor.SetWindow( this );
2277 mpDDInfo->aCursor.SetPos( aCursorRect.TopLeft() );
2278 mpDDInfo->aCursor.SetSize( aCursorRect.GetSize() );
2279 mpDDInfo->aCursor.Show();
2280 mpDDInfo->bVisCursor = true;
2281 }
2282 }
2283
2284 void Edit::ImplHideDDCursor()
2285 {
2286 if ( mpDDInfo && mpDDInfo->bVisCursor )
2287 {
2288 mpDDInfo->aCursor.Hide();
2289 mpDDInfo->bVisCursor = false;
2290 }
2291 }
2292
2293 TextFilter::TextFilter(const OUString &rForbiddenChars)
2294 : sForbiddenChars(rForbiddenChars)
2295 {
2296 }
2297
2298 TextFilter::~TextFilter()
2299 {
2300 }
2301
2302 OUString TextFilter::filter(const OUString &rText)
2303 {
2304 OUString sTemp(rText);
2305 for (sal_Int32 i = 0; i < sForbiddenChars.getLength(); ++i)
2306 {
2307 sTemp = sTemp.replaceAll(OUStringLiteral1(sForbiddenChars[i]), "");
2308 }
2309 return sTemp;
2310 }
2311
2312 void Edit::filterText()
2313 {
2314 Selection aSel = GetSelection();
2315 const OUString sOrig = GetText();
2316 const OUString sNew = mpFilterText->filter(GetText());
2317 if (sOrig != sNew)
2318 {
2319 sal_Int32 nDiff = sOrig.getLength() - sNew.getLength();
2320 if (nDiff)
2321 {
2322 aSel.setMin(aSel.getMin() - nDiff);
2323 aSel.setMax(aSel.getMin());
2324 }
2325 SetText(sNew);
2326 SetSelection(aSel);
2327 }
2328 }
2329
2330 void Edit::Modify()
2331 {
2332 if (mpFilterText)
2333 filterText();
2334
2335 if ( mbIsSubEdit )
2336 {
2337 static_cast<Edit*>(GetParent())->Modify();
2338 }
2339 else
2340 {
2341 if ( mpUpdateDataTimer )
2342 mpUpdateDataTimer->Start();
2343
2344 if ( ImplCallEventListenersAndHandler( VCLEVENT_EDIT_MODIFY, [this] () { maModifyHdl.Call(*this); } ) )
2345 // have been destroyed while calling into the handlers
2346 return;
2347
2348 // #i13677# notify edit listeners about caret position change
2349 CallEventListeners( VCLEVENT_EDIT_CARETCHANGED );
2350 // FIXME: this is currently only on OS X
2351 // check for other platforms that need similar handling
2352 if( ImplGetSVData()->maNWFData.mbNoFocusRects &&
2353 IsNativeWidgetEnabled() &&
2354 IsNativeControlSupported( ControlType::Editbox, ControlPart::Entire ) )
2355 {
2356 ImplInvalidateOutermostBorder( this );
2357 }
2358 }
2359 }
2360
2361 void Edit::UpdateData()
2362 {
2363 maUpdateDataHdl.Call( *this );
2364 }
2365
2366 IMPL_LINK_NOARG(Edit, ImplUpdateDataHdl, Timer *, void)
2367 {
2368 UpdateData();
2369 }
2370
2371 void Edit::EnableUpdateData( sal_uLong nTimeout )
2372 {
2373 if ( !nTimeout )
2374 DisableUpdateData();
2375 else
2376 {
2377 if ( !mpUpdateDataTimer )
2378 {
2379 mpUpdateDataTimer = new Timer("UpdateDataTimer");
2380 mpUpdateDataTimer->SetTimeoutHdl( LINK( this, Edit, ImplUpdateDataHdl ) );
2381 mpUpdateDataTimer->SetDebugName( "vcl::Edit mpUpdateDataTimer" );
2382 }
2383
2384 mpUpdateDataTimer->SetTimeout( nTimeout );
2385 }
2386 }
2387
2388 void Edit::DisableUpdateData()
2389 {
2390 delete mpUpdateDataTimer;
2391 mpUpdateDataTimer = nullptr;
2392 }
2393
2394 void Edit::SetEchoChar( sal_Unicode c )
2395 {
2396 mcEchoChar = c;
2397 if ( mpSubEdit )
2398 mpSubEdit->SetEchoChar( c );
2399 }
2400
2401 void Edit::SetReadOnly( bool bReadOnly )
2402 {
2403 if ( mbReadOnly != bool(bReadOnly) )
2404 {
2405 mbReadOnly = bReadOnly;
2406 if ( mpSubEdit )
2407 mpSubEdit->SetReadOnly( bReadOnly );
2408
2409 CompatStateChanged( StateChangedType::ReadOnly );
2410 }
2411 }
2412
2413 void Edit::SetInsertMode( bool bInsert )
2414 {
2415 if ( bInsert != mbInsertMode )
2416 {
2417 mbInsertMode = bInsert;
2418 if ( mpSubEdit )
2419 mpSubEdit->SetInsertMode( bInsert );
2420 else
2421 ImplShowCursor();
2422 }
2423 }
2424
2425 bool Edit::IsInsertMode() const
2426 {
2427 if ( mpSubEdit )
2428 return mpSubEdit->IsInsertMode();
2429 else
2430 return mbInsertMode;
2431 }
2432
2433 void Edit::SetMaxTextLen(sal_Int32 nMaxLen)
2434 {
2435 mnMaxTextLen = nMaxLen > 0 ? nMaxLen : EDIT_NOLIMIT;
2436
2437 if ( mpSubEdit )
2438 mpSubEdit->SetMaxTextLen( mnMaxTextLen );
2439 else
2440 {
2441 if ( maText.getLength() > mnMaxTextLen )
2442 ImplDelete( Selection( mnMaxTextLen, maText.getLength() ), EDIT_DEL_RIGHT, EDIT_DELMODE_SIMPLE );
2443 }
2444 }
2445
2446 void Edit::SetSelection( const Selection& rSelection )
2447 {
2448 // If the selection was changed from outside, e.g. by MouseButtonDown, don't call Tracking()
2449 // directly afterwards which would change the selection again
2450 if ( IsTracking() )
2451 EndTracking();
2452 else if ( mpSubEdit && mpSubEdit->IsTracking() )
2453 mpSubEdit->EndTracking();
2454
2455 ImplSetSelection( rSelection );
2456 }
2457
2458 void Edit::ImplSetSelection( const Selection& rSelection, bool bPaint )
2459 {
2460 if ( mpSubEdit )
2461 mpSubEdit->ImplSetSelection( rSelection );
2462 else
2463 {
2464 if ( rSelection != maSelection )
2465 {
2466 Selection aOld( maSelection );
2467 Selection aNew( rSelection );
2468
2469 if ( aNew.Min() > maText.getLength() )
2470 aNew.Min() = maText.getLength();
2471 if ( aNew.Max() > maText.getLength() )
2472 aNew.Max() = maText.getLength();
2473 if ( aNew.Min() < 0 )
2474 aNew.Min() = 0;
2475 if ( aNew.Max() < 0 )
2476 aNew.Max() = 0;
2477
2478 if ( aNew != maSelection )
2479 {
2480 ImplClearLayoutData();
2481 Selection aTemp = maSelection;
2482 maSelection = aNew;
2483
2484 if ( bPaint && ( aOld.Len() || aNew.Len() || IsPaintTransparent() ) )
2485 ImplInvalidateOrRepaint();
2486 ImplShowCursor();
2487
2488 bool bCaret = false, bSelection = false;
2489 long nB=aNew.Max(), nA=aNew.Min(),oB=aTemp.Max(), oA=aTemp.Min();
2490 long nGap = nB-nA, oGap = oB-oA;
2491 if (nB != oB)
2492 bCaret = true;
2493 if (nGap != 0 || oGap != 0)
2494 bSelection = true;
2495
2496 if (bSelection)
2497 {
2498 if ( mbIsSubEdit )
2499 static_cast<Edit*>(GetParent())->CallEventListeners( VCLEVENT_EDIT_SELECTIONCHANGED );
2500 else
2501 CallEventListeners( VCLEVENT_EDIT_SELECTIONCHANGED );
2502 }
2503
2504 if (bCaret)
2505 {
2506 if ( mbIsSubEdit )
2507 static_cast<Edit*>(GetParent())->CallEventListeners( VCLEVENT_EDIT_CARETCHANGED );
2508 else
2509 CallEventListeners( VCLEVENT_EDIT_CARETCHANGED );
2510 }
2511
2512 // #103511# notify combobox listeners of deselection
2513 if( !maSelection && GetParent() && GetParent()->GetType() == WINDOW_COMBOBOX )
2514 static_cast<Edit*>(GetParent())->CallEventListeners( VCLEVENT_COMBOBOX_DESELECT );
2515 }
2516 }
2517 }
2518 }
2519
2520 const Selection& Edit::GetSelection() const
2521 {
2522 if ( mpSubEdit )
2523 return mpSubEdit->GetSelection();
2524 else
2525 return maSelection;
2526 }
2527
2528 void Edit::ReplaceSelected( const OUString& rStr )
2529 {
2530 if ( mpSubEdit )
2531 mpSubEdit->ReplaceSelected( rStr );
2532 else
2533 ImplInsertText( rStr );
2534 }
2535
2536 void Edit::DeleteSelected()
2537 {
2538 if ( mpSubEdit )
2539 mpSubEdit->DeleteSelected();
2540 else
2541 {
2542 if ( maSelection.Len() )
2543 ImplDelete( maSelection, EDIT_DEL_RIGHT, EDIT_DELMODE_SIMPLE );
2544 }
2545 }
2546
2547 OUString Edit::GetSelected() const
2548 {
2549 if ( mpSubEdit )
2550 return mpSubEdit->GetSelected();
2551 else
2552 {
2553 Selection aSelection( maSelection );
2554 aSelection.Justify();
2555 return OUString( maText.getStr() + aSelection.Min(), aSelection.Len() );
2556 }
2557 }
2558
2559 void Edit::Cut()
2560 {
2561 if ( !(GetStyle() & WB_PASSWORD ) )
2562 {
2563 Copy();
2564 ReplaceSelected( OUString() );
2565 }
2566 }
2567
2568 void Edit::Copy()
2569 {
2570 if ( !(GetStyle() & WB_PASSWORD ) )
2571 {
2572 css::uno::Reference<css::datatransfer::clipboard::XClipboard> aClipboard(GetClipboard());
2573 ImplCopy( aClipboard );
2574 }
2575 }
2576
2577 void Edit::Paste()
2578 {
2579 css::uno::Reference<css::datatransfer::clipboard::XClipboard> aClipboard(GetClipboard());
2580 ImplPaste( aClipboard );
2581 }
2582
2583 void Edit::Undo()
2584 {
2585 if ( mpSubEdit )
2586 mpSubEdit->Undo();
2587 else
2588 {
2589 const OUString aText( maText.toString() );
2590 ImplDelete( Selection( 0, aText.getLength() ), EDIT_DEL_RIGHT, EDIT_DELMODE_SIMPLE );
2591 ImplInsertText( maUndoText );
2592 ImplSetSelection( Selection( 0, maUndoText.getLength() ) );
2593 maUndoText = aText;
2594 }
2595 }
2596
2597 void Edit::SetText( const OUString& rStr )
2598 {
2599 if ( mpSubEdit )
2600 mpSubEdit->SetText( rStr ); // not directly ImplSetText if SetText overridden
2601 else
2602 {
2603 Selection aNewSel( 0, 0 ); // prevent scrolling
2604 ImplSetText( rStr, &aNewSel );
2605 }
2606 }
2607
2608 void Edit::SetText( const OUString& rStr, const Selection& rSelection )
2609 {
2610 if ( mpSubEdit )
2611 mpSubEdit->SetText( rStr, rSelection );
2612 else
2613 ImplSetText( rStr, &rSelection );
2614 }
2615
2616 OUString Edit::GetText() const
2617 {
2618 if ( mpSubEdit )
2619 return mpSubEdit->GetText();
2620 else
2621 return maText.toString();
2622 }
2623
2624 void Edit::SetCursorAtLast(){
2625 ImplSetCursorPos( GetText().getLength(), false );
2626 }
2627
2628 void Edit::SetPlaceholderText( const OUString& rStr )
2629 {
2630 if ( mpSubEdit )
2631 mpSubEdit->SetPlaceholderText( rStr );
2632 else if ( maPlaceholderText != rStr )
2633 {
2634 maPlaceholderText = rStr;
2635 if ( GetText().isEmpty() )
2636 Invalidate();
2637 }
2638 }
2639
2640 OUString Edit::GetPlaceholderText() const
2641 {
2642 if ( mpSubEdit )
2643 return mpSubEdit->GetPlaceholderText();
2644
2645 return maPlaceholderText;
2646 }
2647
2648 void Edit::SetModifyFlag()
2649 {
2650 if ( mpSubEdit )
2651 mpSubEdit->mbModified = true;
2652 else
2653 mbModified = true;
2654 }
2655
2656 void Edit::ClearModifyFlag()
2657 {
2658 if ( mpSubEdit )
2659 mpSubEdit->mbModified = false;
2660 else
2661 mbModified = false;
2662 }
2663
2664 void Edit::SetSubEdit(Edit* pEdit)
2665 {
2666 mpSubEdit.disposeAndClear();
2667 mpSubEdit.set(pEdit);
2668
2669 if (mpSubEdit)
2670 {
2671 SetPointer(PointerStyle::Arrow); // Nur das SubEdit hat den BEAM...
2672 mpSubEdit->mbIsSubEdit = true;
2673
2674 mpSubEdit->SetReadOnly(mbReadOnly);
2675 mpSubEdit->maAutocompleteHdl = maAutocompleteHdl;
2676 }
2677 }
2678
2679 Size Edit::CalcMinimumSizeForText(const OUString &rString) const
2680 {
2681 ControlType eCtrlType = ImplGetNativeControlType();
2682
2683 Size aSize;
2684 if (mnWidthInChars != -1)
2685 {
2686 //CalcSize calls CalcWindowSize, but we will call that also in this
2687 //function, so undo the first one with CalcOutputSize
2688 aSize = CalcOutputSize(CalcSize(mnWidthInChars));
2689 }
2690 else
2691 {
2692 OUString aString;
2693 if (mnMaxWidthChars != -1 && mnMaxWidthChars < rString.getLength())
2694 aString = rString.copy(0, mnMaxWidthChars);
2695 else
2696 aString = rString;
2697
2698 aSize.Height() = GetTextHeight();
2699 aSize.Width() = GetTextWidth(aString);
2700 aSize.Width() += ImplGetExtraXOffset() * 2;
2701
2702 // do not create edit fields in which one cannot enter anything
2703 // a default minimum width should exist for at least 3 characters
2704
2705 //CalcSize calls CalcWindowSize, but we will call that also in this
2706 //function, so undo the first one with CalcOutputSize
2707 Size aMinSize(CalcOutputSize(CalcSize(3)));
2708 if (aSize.Width() < aMinSize.Width())
2709 aSize.Width() = aMinSize.Width();
2710 }
2711
2712 aSize.Height() += ImplGetExtraYOffset() * 2;
2713
2714 aSize = CalcWindowSize( aSize );
2715
2716 // ask NWF what if it has an opinion, too
2717 ImplControlValue aControlValue;
2718 Rectangle aRect( Point( 0, 0 ), aSize );
2719 Rectangle aContent, aBound;
2720 if (GetNativeControlRegion(eCtrlType, ControlPart::Entire, aRect, ControlState::NONE,
2721 aControlValue, OUString(), aBound, aContent))
2722 {
2723 if (aBound.GetHeight() > aSize.Height())
2724 aSize.Height() = aBound.GetHeight();
2725 }
2726 return aSize;
2727 }
2728
2729 Size Edit::CalcMinimumSize() const
2730 {
2731 return CalcMinimumSizeForText(GetText());
2732 }
2733
2734 Size Edit::GetMinimumEditSize()
2735 {
2736 vcl::Window* pDefWin = ImplGetDefaultWindow();
2737 ScopedVclPtrInstance< Edit > aEdit( pDefWin, WB_BORDER );
2738 Size aSize( aEdit->CalcMinimumSize() );
2739 return aSize;
2740 }
2741
2742 Size Edit::GetOptimalSize() const
2743 {
2744 return CalcMinimumSize();
2745 }
2746
2747 Size Edit::CalcSize(sal_Int32 nChars) const
2748 {
2749 // width for N characters, independent from content.
2750 // works only correct for fixed fonts, average otherwise
2751 Size aSz( GetTextWidth( "x" ), GetTextHeight() );
2752 aSz.Width() *= nChars;
2753 aSz.Width() += ImplGetExtraXOffset() * 2;
2754 aSz = CalcWindowSize( aSz );
2755 return aSz;
2756 }
2757
2758 sal_Int32 Edit::GetMaxVisChars() const
2759 {
2760 const vcl::Window* pW = mpSubEdit ? mpSubEdit : this;
2761 sal_Int32 nOutWidth = pW->GetOutputSizePixel().Width();
2762 sal_Int32 nCharWidth = GetTextWidth( "x" );
2763 return nCharWidth ? nOutWidth/nCharWidth : 0;
2764 }
2765
2766 sal_Int32 Edit::GetCharPos( const Point& rWindowPos ) const
2767 {
2768 return ImplGetCharPos( rWindowPos );
2769 }
2770
2771 void Edit::SetGetSpecialCharsFunction( FncGetSpecialChars fn )
2772 {
2773 pImplFncGetSpecialChars = fn;
2774 }
2775
2776 FncGetSpecialChars Edit::GetGetSpecialCharsFunction()
2777 {
2778 return pImplFncGetSpecialChars;
2779 }
2780
2781 VclPtr<PopupMenu> Edit::CreatePopupMenu()
2782 {
2783 ResMgr* pResMgr = ImplGetResMgr();
2784 if( ! pResMgr )
2785 return VclPtr<PopupMenu>::Create();
2786
2787 VclPtrInstance<PopupMenu> pPopup( ResId( SV_RESID_MENU_EDIT, *pResMgr ) );
2788 const StyleSettings& rStyleSettings = Application::GetSettings().GetStyleSettings();
2789 if ( rStyleSettings.GetHideDisabledMenuItems() )
2790 pPopup->SetMenuFlags( MenuFlags::HideDisabledEntries );
2791 else
2792 pPopup->SetMenuFlags ( MenuFlags::AlwaysShowDisabledEntries );
2793 if ( rStyleSettings.GetContextMenuShortcuts() )
2794 {
2795 pPopup->SetAccelKey( SV_MENU_EDIT_UNDO, vcl::KeyCode( KeyFuncType::UNDO ) );
2796 pPopup->SetAccelKey( SV_MENU_EDIT_CUT, vcl::KeyCode( KeyFuncType::CUT ) );
2797 pPopup->SetAccelKey( SV_MENU_EDIT_COPY, vcl::KeyCode( KeyFuncType::COPY ) );
2798 pPopup->SetAccelKey( SV_MENU_EDIT_PASTE, vcl::KeyCode( KeyFuncType::PASTE ) );
2799 pPopup->SetAccelKey( SV_MENU_EDIT_DELETE, vcl::KeyCode( KeyFuncType::DELETE ) );
2800 pPopup->SetAccelKey( SV_MENU_EDIT_SELECTALL, vcl::KeyCode( KEY_A, false, true, false, false ) );
2801 pPopup->SetAccelKey( SV_MENU_EDIT_INSERTSYMBOL, vcl::KeyCode( KEY_S, true, true, false, false ) );
2802 }
2803 return pPopup;
2804 }
2805
2806 // css::datatransfer::dnd::XDragGestureListener
2807 void Edit::dragGestureRecognized( const css::datatransfer::dnd::DragGestureEvent& rDGE ) throw (css::uno::RuntimeException, std::exception)
2808 {
2809 SolarMutexGuard aVclGuard;
2810
2811 if ( !IsTracking() && maSelection.Len() &&
2812 !(GetStyle() & WB_PASSWORD) && (!mpDDInfo || !mpDDInfo->bStarterOfDD) ) // Kein Mehrfach D&D
2813 {
2814 Selection aSel( maSelection );
2815 aSel.Justify();
2816
2817 // Nur wenn Maus in der Selektion...
2818 Point aMousePos( rDGE.DragOriginX, rDGE.DragOriginY );
2819 sal_Int32 nCharPos = ImplGetCharPos( aMousePos );
2820 if ( (nCharPos >= aSel.Min()) && (nCharPos < aSel.Max()) )
2821 {
2822 if ( !mpDDInfo )
2823 mpDDInfo = new DDInfo;
2824
2825 mpDDInfo->bStarterOfDD = true;
2826 mpDDInfo->aDndStartSel = aSel;
2827
2828 if ( IsTracking() )
2829 EndTracking(); // Vor D&D Tracking ausschalten
2830
2831 vcl::unohelper::TextDataObject* pDataObj = new vcl::unohelper::TextDataObject( GetSelected() );
2832 sal_Int8 nActions = datatransfer::dnd::DNDConstants::ACTION_COPY;
2833 if ( !IsReadOnly() )
2834 nActions |= datatransfer::dnd::DNDConstants::ACTION_MOVE;
2835 rDGE.DragSource->startDrag( rDGE, nActions, 0 /*cursor*/, 0 /*image*/, pDataObj, mxDnDListener );
2836 if ( GetCursor() )
2837 GetCursor()->Hide();
2838
2839 }
2840 }
2841 }
2842
2843 // css::datatransfer::dnd::XDragSourceListener
2844 void Edit::dragDropEnd( const css::datatransfer::dnd::DragSourceDropEvent& rDSDE ) throw (css::uno::RuntimeException, std::exception)
2845 {
2846 SolarMutexGuard aVclGuard;
2847
2848 if (rDSDE.DropSuccess && (rDSDE.DropAction & datatransfer::dnd::DNDConstants::ACTION_MOVE) && mpDDInfo)
2849 {
2850 Selection aSel( mpDDInfo->aDndStartSel );
2851 if ( mpDDInfo->bDroppedInMe )
2852 {
2853 if ( aSel.Max() > mpDDInfo->nDropPos )
2854 {
2855 long nLen = aSel.Len();
2856 aSel.Min() += nLen;
2857 aSel.Max() += nLen;
2858 }
2859 }
2860 ImplDelete( aSel, EDIT_DEL_RIGHT, EDIT_DELMODE_SIMPLE );
2861 ImplModified();
2862 }
2863
2864 ImplHideDDCursor();
2865 delete mpDDInfo;
2866 mpDDInfo = nullptr;
2867 }
2868
2869 // css::datatransfer::dnd::XDropTargetListener
2870 void Edit::drop( const css::datatransfer::dnd::DropTargetDropEvent& rDTDE ) throw (css::uno::RuntimeException, std::exception)
2871 {
2872 SolarMutexGuard aVclGuard;
2873
2874 bool bChanges = false;
2875 if ( !mbReadOnly && mpDDInfo )
2876 {
2877 ImplHideDDCursor();
2878
2879 Selection aSel( maSelection );
2880 aSel.Justify();
2881
2882 if ( aSel.Len() && !mpDDInfo->bStarterOfDD )
2883 ImplDelete( aSel, EDIT_DEL_RIGHT, EDIT_DELMODE_SIMPLE );
2884
2885 mpDDInfo->bDroppedInMe = true;
2886
2887 aSel.Min() = mpDDInfo->nDropPos;
2888 aSel.Max() = mpDDInfo->nDropPos;
2889 ImplSetSelection( aSel );
2890
2891 uno::Reference< datatransfer::XTransferable > xDataObj = rDTDE.Transferable;
2892 if ( xDataObj.is() )
2893 {
2894 datatransfer::DataFlavor aFlavor;
2895 SotExchange::GetFormatDataFlavor( SotClipboardFormatId::STRING, aFlavor );
2896 if ( xDataObj->isDataFlavorSupported( aFlavor ) )
2897 {
2898 uno::Any aData = xDataObj->getTransferData( aFlavor );
2899 OUString aText;
2900 aData >>= aText;
2901 ImplInsertText( aText );
2902 bChanges = true;
2903 ImplModified();
2904 }
2905 }
2906
2907 if ( !mpDDInfo->bStarterOfDD )
2908 {
2909 delete mpDDInfo;
2910 mpDDInfo = nullptr;
2911 }
2912 }
2913
2914 rDTDE.Context->dropComplete( bChanges );
2915 }
2916
2917 void Edit::dragEnter( const css::datatransfer::dnd::DropTargetDragEnterEvent& rDTDE ) throw (css::uno::RuntimeException, std::exception)
2918 {
2919 if ( !mpDDInfo )
2920 {
2921 mpDDInfo = new DDInfo;
2922 }
2923 // search for string data type
2924 const Sequence< css::datatransfer::DataFlavor >& rFlavors( rDTDE.SupportedDataFlavors );
2925 sal_Int32 nEle = rFlavors.getLength();
2926 mpDDInfo->bIsStringSupported = false;
2927 for( sal_Int32 i = 0; i < nEle; i++ )
2928 {
2929 sal_Int32 nIndex = 0;
2930 const OUString aMimetype = rFlavors[i].MimeType.getToken( 0, ';', nIndex );
2931 if ( aMimetype == "text/plain" )
2932 {
2933 mpDDInfo->bIsStringSupported = true;
2934 break;
2935 }
2936 }
2937 }
2938
2939 void Edit::dragExit( const css::datatransfer::dnd::DropTargetEvent& ) throw (css::uno::RuntimeException, std::exception)
2940 {
2941 SolarMutexGuard aVclGuard;
2942
2943 ImplHideDDCursor();
2944 }
2945
2946 void Edit::dragOver( const css::datatransfer::dnd::DropTargetDragEvent& rDTDE ) throw (css::uno::RuntimeException, std::exception)
2947 {
2948 SolarMutexGuard aVclGuard;
2949
2950 Point aMousePos( rDTDE.LocationX, rDTDE.LocationY );
2951
2952 sal_Int32 nPrevDropPos = mpDDInfo->nDropPos;
2953 mpDDInfo->nDropPos = ImplGetCharPos( aMousePos );
2954
2955 /*
2956 Size aOutSize = GetOutputSizePixel();
2957 if ( ( aMousePos.X() < 0 ) || ( aMousePos.X() > aOutSize.Width() ) )
2958 {
2959 // Scroll?
2960 // No, I will not receive events in this case....
2961 }
2962 */
2963
2964 Selection aSel( maSelection );
2965 aSel.Justify();
2966
2967 // Don't accept drop in selection or read-only field...
2968 if ( IsReadOnly() || aSel.IsInside( mpDDInfo->nDropPos ) || ! mpDDInfo->bIsStringSupported )
2969 {
2970 ImplHideDDCursor();
2971 rDTDE.Context->rejectDrag();
2972 }
2973 else
2974 {
2975 // Alten Cursor wegzeichnen...
2976 if ( !mpDDInfo->bVisCursor || ( nPrevDropPos != mpDDInfo->nDropPos ) )
2977 {
2978 ImplHideDDCursor();
2979 ImplShowDDCursor();
2980 }
2981 rDTDE.Context->acceptDrag( rDTDE.DropAction );
2982 }
2983 }
2984
2985 OUString Edit::GetSurroundingText() const
2986 {
2987 if (mpSubEdit)
2988 return mpSubEdit->GetSurroundingText();
2989 return maText.toString();
2990 }
2991
2992 Selection Edit::GetSurroundingTextSelection() const
2993 {
2994 return GetSelection();
2995 }
2996
2997 FactoryFunction Edit::GetUITestFactory() const
2998 {
2999 return EditUIObject::create;
3000 }
3001
3002 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE