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