1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: Defines the Text Editor native side component

    15 *

    16 */

    17 

    18 // EXTERNAL INCLUDES

    19 #include <MMIDCustomComponentContainer.h>

    20 #include <lcdui.h>

    21 #include <aknappui.h>

    22 #include <aknnavi.h>

    23 #include <j2me/jdebug.h>

    24 

    25 // INTERNAL INCLUDES

    26 #include "CMIDTextEditor.h"

    27 #include "CMIDTextEditorEdwin.h"

    28 #include "CMIDEditingStateIndicator.h"

    29 #include "CMIDEdwinUtils.h"

    30 #include "CMIDUtils.h"

    31 #include "CMIDFont.h"

    32 

    33 // Default background color.

    34 const TInt KDefColorBgRed       = 0;

    35 const TInt KDefColorBgGreen     = 0;

    36 const TInt KDefColorBgBlue      = 0;

    37 const TInt KDefColorBgAlpha     = 0;

    38 

    39 // Default foreground color.

    40 const TInt KDefColorFgRed       = 0;

    41 const TInt KDefColorFgGreen     = 0;

    42 const TInt KDefColorFgBlue      = 0;

    43 const TInt KDefColorFgAlpha     = 255;

    44 

    45 // Default highlight background color.

    46 const TInt KDefColorHlBgRed     = 0;

    47 const TInt KDefColorHlBgGreen   = 0;

    48 const TInt KDefColorHlBgBlue    = 0;

    49 const TInt KDefColorHlBgAlpha   = 255;

    50 

    51 // Default highlight foreground color.

    52 const TInt KDefColorHlFgRed     = 255;

    53 const TInt KDefColorHlFgGreen   = 255;

    54 const TInt KDefColorHlFgBlue    = 255;

    55 const TInt KDefColorHlFgAlpha   = 255;

    56 

    57 // Count of compound components in this custom component.

    58 const TInt KComponentCount      = 2;

    59 

    60 // For all touch input modes to be disabled

    61 const TInt KAllTouchModesDisabled    = 63;

    62 

    63 // ---------------------------------------------------------------------------

    64 // CMIDTextEditor::NewL

    65 // ---------------------------------------------------------------------------

    66 //

    67 CMIDTextEditor* CMIDTextEditor::NewL(const TCtorParams& aParams)

    68 {

    69     CMIDTextEditor* self = new(ELeave) CMIDTextEditor();

    70     CleanupStack::PushL(self);

    71     self->ConstructL(aParams);

    72     CleanupStack::Pop(self);

    73     return self;

    74 }

    75 

    76 // ---------------------------------------------------------------------------

    77 // CMIDTextEditor::~CMIDTextEditor

    78 // ---------------------------------------------------------------------------

    79 //

    80 CMIDTextEditor::~CMIDTextEditor()

    81 {

    82     DEBUG("CMIDTextEditor::~CMIDTextEditor +");

    83 

    84 #ifdef RD_TACTILE_FEEDBACK

    85     if (iPenInputServerConnected)

    86     {

    87         // Close pen input server if the device is touch enabled and

    88         // connection was established

    89         iPenInputServerConnected = EFalse;

    90         iPenServer.Close();

    91     }

    92 #endif // RD_TACTILE_FEEDBACK

    93 

    94     // Remove this component from the container if set.

    95     if (iComponentContainer)

    96     {

    97         iComponentContainer->UnregisterComponent(this);

    98     }

    99 

   100     // Remove association from the previous direct container.

   101     if (iDirectContainer)

   102     {

   103         iDirectContainer->MdcRemoveContent(this);

   104     }

   105 

   106     delete iTextEdwin;

   107     delete iEdwinUtils;

   108     delete iEditingStateIndicator;

   109 

   110     iUtils = NULL;

   111 

   112     DEBUG("CMIDTextEditor::~CMIDTextEditor -");

   113 }

   114 

   115 // ---------------------------------------------------------------------------

   116 // CMIDTextEditor::CustomComponentControlCount

   117 // (other items are commented in the header file)

   118 // ---------------------------------------------------------------------------

   119 //

   120 TInt CMIDTextEditor::CustomComponentControlCount() const

   121 {

   122     return KComponentCount;

   123 }

   124 

   125 // ---------------------------------------------------------------------------

   126 // CMIDTextEditor::CustomComponentControl

   127 // (other items are commented in the header file)

   128 // ---------------------------------------------------------------------------

   129 //

   130 CCoeControl* CMIDTextEditor::CustomComponentControl(TInt aIndex)

   131 {

   132     switch (aIndex)

   133     {

   134     case 0:

   135     {

   136         return iTextEdwin;

   137     }

   138     case 1:

   139     {

   140         return iEditingStateIndicator;

   141     }

   142     default:

   143     {

   144         __ASSERT_DEBUG(EFalse, User::Invariant());

   145     }

   146     }

   147 

   148     return NULL;

   149 }

   150 

   151 // ---------------------------------------------------------------------------

   152 // CMIDTextEditor::CustomComponentContainerDisposing

   153 // (other items are commented in the header file)

   154 // ---------------------------------------------------------------------------

   155 //

   156 void CMIDTextEditor::CustomComponentContainerDisposing()

   157 {

   158     DEBUG("CMIDTextEditor::CustomComponentContainerDisposing +");

   159 

   160     // Remove container association.

   161     iComponentContainer = NULL;

   162 

   163     // Uninitialize the text editor window.

   164     iTextEdwin->Uninitialize();

   165 

   166     DEBUG("CMIDTextEditor::CustomComponentContainerDisposing -");

   167 }

   168 

   169 // ---------------------------------------------------------------------------

   170 // CMIDTextEditor::SetObserver

   171 // (other items are commented in the header file)

   172 // ---------------------------------------------------------------------------

   173 //

   174 void CMIDTextEditor::SetObserver(MMIDTextEditorObserver* aObserver)

   175 {

   176     DEBUG("CMIDTextEditor::SetObserver +");

   177 

   178     iObserver = aObserver;

   179     iTextEdwin->SetObserver(aObserver);

   180 

   181     DEBUG("CMIDTextEditor::SetObserver -");

   182 }

   183 

   184 // ---------------------------------------------------------------------------

   185 // CMIDTextEditor::isTouchEnabled

   186 // (other items are commented in the header file)

   187 // ---------------------------------------------------------------------------

   188 //

   189 TBool CMIDTextEditor::IsTouchEnabled()

   190 {

   191     return iTouchEnabled;

   192 }

   193 

   194 // ---------------------------------------------------------------------------

   195 // CMIDTextEditor::setTouchEnabled

   196 // (other items are commented in the header file)

   197 // ---------------------------------------------------------------------------

   198 //

   199 void CMIDTextEditor::SetTouchEnabled(TBool aEnabled)

   200 {

   201     iTouchEnabled = aEnabled;

   202 }

   203 

   204 // ---------------------------------------------------------------------------

   205 // CMIDTextEditor::SetEditorSize

   206 // (other items are commented in the header file)

   207 // ---------------------------------------------------------------------------

   208 //

   209 void CMIDTextEditor::SetEditorSize(TInt aWidth, TInt aHeight)

   210 {

   211     DEBUG_INT2("CMIDTextEditor::SetEditorSize + aWidth=%d, aHeight=%d",

   212                aWidth, aHeight);

   213 

   214     // We need store non-scaled size of editor for possible resolution

   215     // and fullscreen mode changes.

   216     iNonScaledEditorSize = TSize(aWidth, aHeight);

   217 

   218     // If parent is in fullscreen mode then it tries scale input size.

   219     // Only setting otherwise.

   220     if (!iRowCountActive &&iComponentContainer &&

   221             iComponentContainer->IsFullScreen())

   222     {

   223         iTextEdwin->SetSize(iUtils->DoScaling(aWidth, CMIDUtils::EHorizontal),

   224                             iUtils->DoScaling(aHeight, CMIDUtils::EVertical));

   225         // Update the size of the indicator. Height does not need to be

   226         // calculated.

   227         iEditingStateIndicator->SetSize(iUtils->DoScaling(

   228                                             aWidth, CMIDUtils::EHorizontal), -1);

   229     }

   230     else

   231     {

   232         iTextEdwin->SetSize(aWidth, aHeight);

   233         // Update the size of the indicator. Height does not need to be

   234         // calculated.

   235         iEditingStateIndicator->SetSize(aWidth, -1);

   236     }

   237 

   238     // Updating of position of indicator is needed for change of its size.

   239     UpdateIndicatorPosition();

   240 

   241     // Redraw the editor

   242     iTextEdwin->Redraw();

   243 

   244     // Change the flag so now the font size changes will not

   245     // resize the editor any more.

   246     iRowCountActive = EFalse;

   247 

   248     DEBUG("CMIDTextEditor::SetEditorSize -");

   249 }

   250 

   251 // ---------------------------------------------------------------------------

   252 // CMIDTextEditor::EditorSize

   253 // (other items are commented in the header file)

   254 // ---------------------------------------------------------------------------

   255 //

   256 TSize CMIDTextEditor::EditorSize() const

   257 {

   258     DEBUG("CMIDTextEditor::EditorSize");

   259 

   260     TSize editorSize = iTextEdwin->Size();

   261 

   262     // When scaling is on it has to descaled editor size.

   263     if (iComponentContainer && iComponentContainer->IsFullScreen())

   264     {

   265         editorSize = iUtils->DoDescaling(editorSize);

   266     }

   267 

   268     return editorSize;

   269 }

   270 

   271 // ---------------------------------------------------------------------------

   272 // CMIDTextEditor::SetParentL

   273 // (other items are commented in the header file)

   274 // ---------------------------------------------------------------------------

   275 //

   276 void CMIDTextEditor::SetParentL(

   277     MMIDCustomComponentContainer* aComponentContainer)

   278 {

   279     DEBUG("CMIDTextEditor::SetParentL +");

   280 

   281     // Remove association from the previous container.

   282     if (iComponentContainer)

   283     {

   284         DEBUG("CMIDTextEditor::SetParentL, unregistering old association");

   285 

   286         // Remove focus

   287         SetFocusStateL(EFalse);

   288         // Remove editor from container

   289         iComponentContainer->UnregisterComponent(this);

   290         // Set editor window uninitialized

   291         iTextEdwin->Uninitialize();

   292         iComponentContainer->Control().DrawDeferred();

   293         iComponentContainer = NULL;

   294     }

   295 

   296     // Associate this component to the new container.

   297     if (aComponentContainer)

   298     {

   299         DEBUG("CMIDTextEditor::SetParentL, registering new");

   300 

   301         CCoeControl& control = aComponentContainer->Control();

   302         // Register container window for the editor.

   303         iTextEdwin->SetContainerWindowL(control);

   304         iTextEdwin->SetTopParent(&control);

   305         // Initialize the editor window.

   306         iTextEdwin->InitializeL();

   307         // Set container window also for the indicator.

   308         iEditingStateIndicator->SetContainerWindowL(&control);

   309 

   310         // Register this custom component to the container.

   311         aComponentContainer->RegisterComponentL(this);

   312     }

   313 

   314     // Store container. NULL is ok.

   315     iComponentContainer = aComponentContainer;

   316 

   317     if (iComponentContainer &&

   318             iComponentContainer->IsFullScreen())

   319     {

   320         if (!iRowCountActive)

   321         {

   322             // When it is fullscreen we need call SetEditorSize to prevent wrong

   323             // scaling of TextEditor.

   324             // (only for TextEditor not created with row counter)

   325             SetEditorSize(iTextEdwin->Size().iWidth, iTextEdwin->Size().iHeight);

   326         }

   327         SetFontL(iNonScaledFont);

   328     }

   329 

   330     DEBUG("CMIDTextEditor::SetParentL -");

   331 }

   332 

   333 // ---------------------------------------------------------------------------

   334 // CMIDTextEditor::SetDirectContainerL

   335 // (other items are commented in the header file)

   336 // ---------------------------------------------------------------------------

   337 //

   338 void CMIDTextEditor::SetDirectContainerL(MDirectContainer* aDirectContainer)

   339 {

   340     // Remove association from the previous direct container.

   341     if (iDirectContainer)

   342     {

   343         iDirectContainer->MdcRemoveContent(this);

   344     }

   345 

   346     // Associate this component to the new direct container. Note that this

   347     // needs to be done in order to disable the direct screen access of

   348     // the MID parent component. This way it does not draw on top of

   349     // the text editor when repaint etc. methods are called.

   350     if (aDirectContainer)

   351     {

   352         aDirectContainer->MdcAddContent(this);

   353     }

   354 

   355     // Store new container. Or NULL if passed.

   356     iDirectContainer = aDirectContainer;

   357 }

   358 

   359 // ---------------------------------------------------------------------------

   360 // CMIDTextEditor::SetElevationL

   361 // (other items are commented in the header file)

   362 // ---------------------------------------------------------------------------

   363 //

   364 void CMIDTextEditor::SetElevationL(TInt aElevation)

   365 {

   366     DEBUG_INT("CMIDTextEditor::SetElevationL +, aElevation=%d", aElevation);

   367 

   368     // Parent must have been set.

   369     __ASSERT_DEBUG(iComponentContainer, User::Invariant());

   370 

   371     // The elevation is corrected in custom component container.

   372     iComponentContainer->SetComponentIndexL(this, aElevation);

   373 

   374     DEBUG("CMIDTextEditor::SetElevationL -");

   375 }

   376 

   377 // ---------------------------------------------------------------------------

   378 // CMIDTextEditor::Elevation

   379 // (other items are commented in the header file)

   380 // ---------------------------------------------------------------------------

   381 //

   382 TInt CMIDTextEditor::Elevation()

   383 {

   384     DEBUG("CMIDTextEditor::Elevation +");

   385 

   386     // Parent must have been set.

   387     __ASSERT_DEBUG(iComponentContainer, User::Invariant());

   388 

   389     TInt index = iComponentContainer->ComponentIndex(this);

   390 

   391     DEBUG_INT("CMIDTextEditor::Elevation - index=%d", index);

   392 

   393     return index;

   394 }

   395 

   396 void CMIDTextEditor::TraverseL(const TKeyEvent& aEvent)

   397 {

   398     if (iTextEdwin->Traverse(aEvent))

   399     {

   400         if (iObserver)

   401         {

   402             if ((aEvent.iCode == EKeyUpArrow) ||

   403                     (aEvent.iScanCode == EStdKeyUpArrow))

   404             {

   405                 iObserver->NotifyInputAction(

   406                     MMIDTextEditorObserver::EActionTraversePrevious);

   407             }

   408             else if ((aEvent.iCode == EKeyDownArrow) ||

   409                      (aEvent.iScanCode == EStdKeyDownArrow))

   410             {

   411                 iObserver->NotifyInputAction(

   412                     MMIDTextEditorObserver::EActionTraverseNext);

   413             }

   414         }

   415     }

   416     else

   417     {

   418         iTextEdwin->OfferKeyEventL(aEvent, EEventKeyDown);

   419     }

   420 }

   421 

   422 // ---------------------------------------------------------------------------

   423 // CMIDTextEditor::Show

   424 // (other items are commented in the header file)

   425 // ---------------------------------------------------------------------------

   426 //

   427 void CMIDTextEditor::SetVisibleL(TBool aVisible)

   428 {

   429     DEBUG_INT("CMIDTextEditor::SetVisibleL +, aVisible=%d", aVisible);

   430 

   431     // SetParentL must be called before Show.

   432     __ASSERT_DEBUG(iComponentContainer, User::Invariant());

   433 

   434     if (aVisible && !iTextEdwin->IsVisible())

   435     {

   436         DEBUG("CMIDTextEditor::SetVisibleL, setting editor visible");

   437 

   438         // Show the text editor when it is hidden.

   439         iTextEdwin->MakeVisible(aVisible);

   440 

   441         // If setting visible already focused editor

   442         if (iFocusState)

   443         {

   444             iFocusState = EFalse;

   445             SetFocusStateL(ETrue);

   446             // Cursor is not shown automatically if the editor has focus.

   447             // So, set cursor visible.

   448             iTextEdwin->SetCursorVisible(ETrue);

   449 

   450         }

   451         else

   452         {

   453             // MakeVisible automatically selects the editor's content

   454             // Remove the selection at this point. The selection can be

   455             // set again with the API.

   456             SetCursorPositionL(iTextEdwin->CursorPos());

   457         }

   458     }

   459     else if (!aVisible && iTextEdwin->IsVisible())

   460     {

   461         DEBUG("CMIDTextEditor::SetVisibleL, setting editor hidden");

   462 

   463         if (iFocusState)

   464         {

   465             // Remove the focus from the editor also.

   466             SetFocusStateL(EFalse);

   467             // Keep focus state for visibility changes

   468             iFocusState = ETrue;

   469         }

   470         // Hide the text editor when it is visible.

   471         iTextEdwin->MakeVisible(EFalse);

   472 

   473         // Always disable indicator if the editor is hidden.

   474         iEditingStateIndicator->MakeVisible(EFalse);

   475     }

   476 

   477     iTextEdwin->Redraw();

   478 

   479     DEBUG("CMIDTextEditor::SetVisibleL -");

   480 }

   481 

   482 // ---------------------------------------------------------------------------

   483 // CMIDTextEditor::IsVisible

   484 // (other items are commented in the header file)

   485 // ---------------------------------------------------------------------------

   486 //

   487 TBool CMIDTextEditor::IsVisible() const

   488 {

   489     return iTextEdwin->IsVisible();

   490 }

   491 

   492 // ---------------------------------------------------------------------------

   493 // CMIDTextEditor::SetPosition

   494 // (other items are commented in the header file)

   495 // ---------------------------------------------------------------------------

   496 //

   497 void CMIDTextEditor::SetPosition(TInt aX, TInt aY)

   498 {

   499     DEBUG_INT2("CMIDTextEditor::SetPosition +, aX=%d, aY=%d", aX, aY);

   500 

   501     // We need store non-scaled position for possible resolution

   502     // and fullscreen mode changes.

   503     iNonScaledPosition = TPoint(aX, aY);

   504 

   505     // If parent is in fullscreen mode then it tries scale input position.

   506     // Only setting otherwise.

   507     if (iComponentContainer && iComponentContainer->IsFullScreen())

   508     {

   509         DEBUG_INT2("CMIDTextEditor::SetPosition DoScaling, aX=%d, aY=%d",

   510                    iUtils->DoScaling(aX, CMIDUtils::EHorizontal),

   511                    iUtils->DoScaling(aY, CMIDUtils::EVertical));

   512         iTextEdwin->SetPosition(iUtils->DoScalingAndPositioning(TPoint(aX, aY)));

   513     }

   514     else

   515     {

   516         iTextEdwin->SetPosition(TPoint(aX, aY));

   517     }

   518 

   519     // There is needed redraw.

   520     iTextEdwin->Redraw();

   521 

   522     // Update indicator's position if needed.

   523     UpdateIndicatorPosition();

   524 

   525     DEBUG("CMIDTextEditor::SetPosition -");

   526 }

   527 

   528 // ---------------------------------------------------------------------------

   529 // CMIDTextEditor::SetCaretXY

   530 // (other items are commented in the header file)

   531 // ---------------------------------------------------------------------------

   532 //

   533 void CMIDTextEditor::SetCaretXYL(TInt aX, TInt aY)

   534 {

   535     DEBUG_INT2("CMIDTextEditor::SetCaretXY +, aX=%d, aY=%d", aX, aY);

   536 

   537     // Requested point should be already recalculated to be relative

   538     // to editor position on canvas.

   539     TPoint pos(aX, aY);

   540     // If position will be found in formatted text, posInfo will be filled

   541     // with desired informations.

   542     TTmPosInfo2 posInfo;

   543 

   544     if (iTextEdwin->TextLayout()->FindXyPos(pos, posInfo))

   545     {

   546         // Position was found. Try to set cursor to found position.

   547         iTextEdwin->SetCursorPosL(posInfo.iDocPos.iPos, EFalse);

   548     }

   549 

   550     DEBUG("CMIDTextEditor::SetCaretXY -");

   551 }

   552 

   553 // ---------------------------------------------------------------------------

   554 // CMIDTextEditor::SetFocusStateL

   555 // (other items are commented in the header file)

   556 // ---------------------------------------------------------------------------

   557 //

   558 void CMIDTextEditor::SetFocusStateL(TBool aFocusState)

   559 {

   560     DEBUG_INT("CMIDTextEditor::SetFocusStateL +, aFocusState=%d",

   561               aFocusState);

   562 

   563     if ((aFocusState) && !(iFocusState))

   564     {

   565         // Set focus if the text editor is not focused

   566         iFocusState = ETrue;

   567         // Call SetFocus on edwin

   568         iTextEdwin->SetFocus(ETrue);

   569         // Send the information about new focused component to parent

   570         iComponentContainer->SetFocusedComponent(this);

   571 

   572         // Set focus automatically selects the editor's content

   573         // Remove the selection at this point. The selection can be

   574         // set again with the API.

   575         SetCursorPositionL(iTextEdwin->CursorPos());

   576 

   577         // If the editor is not visible. do not show the cursor either.

   578         if (!iTextEdwin->IsVisible())

   579         {

   580             DEBUG("CMIDTextEditor::SetFocusStateL, hiding cursor");

   581 

   582             iTextEdwin->SetCursorVisible(EFalse);

   583         }

   584         else if (iEditingStateIndicator->EnabledState() ==

   585                  CMIDEditingStateIndicator::EIndicatorStateRelative)

   586         {

   587             // Enable the custom indicators as in Avkon if not controlled

   588             // by the client application

   589             iEditingStateIndicator->MakeVisible(ETrue);

   590         }

   591     }

   592     else if (!(aFocusState) && (iFocusState))

   593     {

   594         // Remove focus if the text editor is focused.

   595         iFocusState = EFalse;

   596 

   597         // Call SetFocus on edwin

   598         iTextEdwin->SetFocus(EFalse);

   599 

   600         if (iComponentContainer)

   601         {

   602             // Send the information about new focused component to parent

   603             iComponentContainer->SetFocusedComponent(NULL);

   604         }

   605 

   606         // Disable the custom indicators as in Avkon if not controlled by

   607         // the client application.

   608         if (iEditingStateIndicator->EnabledState() ==

   609                 CMIDEditingStateIndicator::EIndicatorStateRelative)

   610         {

   611             iEditingStateIndicator->MakeVisible(EFalse);

   612         }

   613     }

   614 

   615     iTextEdwin->Redraw();

   616 

   617     DEBUG("CMIDTextEditor::SetFocusStateL -");

   618 }

   619 

   620 TBool CMIDTextEditor::GetFocusState()

   621 {

   622     return iFocusState;

   623 }

   624 

   625 // ---------------------------------------------------------------------------

   626 // CMIDTextEditor::ContentL

   627 // (other items are commented in the header file)

   628 // ---------------------------------------------------------------------------

   629 //

   630 HBufC* CMIDTextEditor::ContentL()

   631 {

   632     DEBUG("CMIDTextEditor::ContentL +");

   633 

   634     HBufC* content = iTextEdwin->GetTextInHBufL();

   635 

   636     if (!content)

   637     {

   638         // Return an empty content if the current content of the editor

   639         // is NULL.

   640         content = HBufC::NewL(0);

   641 

   642         DEBUG("CMIDTextEditor::ContentL -, returning empty descriptor");

   643 

   644         return content;

   645     }

   646 

   647     TPtr ptr = content->Des();

   648 

   649     // Otherwise, convert content to Java specific format.

   650     // First, if the constraints indicates that this is a decimal field

   651     // convert the string from localized decimal.

   652     if (iTextEdwin->IsConstraintSet(MMIDTextField::EDecimal))

   653     {

   654         DEBUG("CMIDTextEditor::ContentL, convert from localized decimal");

   655 

   656         iEdwinUtils->ConvertFromLocalizedDecimal(content);

   657     }

   658 

   659     // Perform number conversion if it is needed.

   660     if (iEdwinUtils->IsNumberConversionNeeded(iConstraints))

   661     {

   662         DEBUG(

   663             "CMIDTextEditor::ContentL, language specific number conversion");

   664 

   665         AknTextUtils::ConvertDigitsTo(ptr, EDigitTypeWestern);

   666     }

   667 

   668     // Map Java-specific characters in the buffer.

   669     CMIDUtils::MapETextToJavaChars(content);

   670 

   671     DEBUG_STR("CMIDTextEditor::ContentL - content=%S", *content);

   672 

   673     return content;

   674 }

   675 

   676 // ---------------------------------------------------------------------------

   677 // CMIDTextEditor::SetContentL

   678 // (other items are commented in the header file)

   679 // ---------------------------------------------------------------------------

   680 //

   681 void CMIDTextEditor::SetContentL(const TDesC& aContent)

   682 {

   683     DEBUG("CMIDTextEditor::SetContentL +");

   684 

   685     // Leave if text is not valid for the current set of constraints.

   686     // Note that if the constraints are set to phone number invalid

   687     // characters are simply removed. See CMIDEdwin.

   688     if (!(iTextEdwin->IsConstraintSet(MMIDTextField::EPhoneNumber)) &&

   689             !(iEdwinUtils->ConstraintsValidForText(

   690                   aContent,

   691                   iConstraints, ETrue)))

   692     {

   693         User::Leave(KErrArgument);

   694     }

   695 

   696     // Get converted content (localized, number conversion and phone number

   697     // specific).

   698     HBufC* buf = ConvertedContentLC(aContent);

   699 

   700     // Set text to the editor window.

   701     iTextEdwin->SetTextL(buf);

   702 

   703     // Text buffer is not needed anymore, pop and destroy it.

   704     CleanupStack::PopAndDestroy(buf);

   705 

   706     // Text has been changed so inform the editor window that

   707     // it needs to redraw itself again.

   708     iTextEdwin->HandleTextChangedL();

   709 

   710     // Cursor state is not automatically updated. Do it here. False indicates

   711     // that the text is not selected from the point where the cursor is moved.

   712     SetCursorPositionL(ContentLength());

   713 

   714     DEBUG("CMIDTextEditor::SetContentL -");

   715 }

   716 

   717 // ---------------------------------------------------------------------------

   718 // CMIDTextEditor::InsertContentL

   719 // (other items are commented in the header file)

   720 // ---------------------------------------------------------------------------

   721 //

   722 void CMIDTextEditor::InsertContentL(const TDesC& aContent, TInt aPosition)

   723 {

   724     DEBUG_STR("CMIDTextEditor::InsertContentL +, aContent=%S", aContent);

   725     DEBUG_INT("CMIDTextEditor::InsertContentL, aPosition=%d", aPosition);

   726 

   727     // Validate the new content before making any conversions or

   728     // modifications.

   729     // Leave if text is not valid for the current set of constraints.

   730     // Note that if the constraints are set to phone number invalid

   731     // characters are simply removed. See CMIDEdwin.

   732     if (!(iTextEdwin->IsConstraintSet(MMIDTextField::EPhoneNumber)) &&

   733             !(iEdwinUtils->ConstraintsValidForText(

   734                   aContent,

   735                   iConstraints, ETrue)))

   736     {

   737         User::Leave(KErrArgument);

   738     }

   739 

   740     TInt contentLength = ContentLength();

   741 

   742     // Get cursor position internally because CursorPosition() checks

   743     // wether the editor window is initialized or not.

   744     TInt cursorPosition = CursorPosition();

   745 

   746     // Get language converted content.

   747     HBufC* originalContent = ContentL();

   748     CleanupStack::PushL(originalContent);

   749 

   750     // If position is negative, convert it to zero.

   751     if (aPosition < 0)

   752     {

   753         aPosition = 0;

   754     }

   755     // Or if the position is greater than the length.

   756     else if (aPosition > contentLength)

   757     {

   758         aPosition = contentLength;

   759     }

   760 

   761     DEBUG_INT("CMIDTextEditor::InsertContentL, aPosition=%d",

   762               aPosition);

   763     DEBUG_INT("CMIDTextEditor::InsertContentL, cursorPosition=%d",

   764               cursorPosition);

   765 

   766     // Get converted content (localized, number conversion and phone number

   767     // specific).

   768     HBufC* content = ConvertedContentLC(aContent);

   769 

   770     // Leave with KErrArgument if the content is not valid.

   771     if (!iEdwinUtils->ConstraintsValidForInsertedTextL(

   772                 *originalContent, *content, aPosition, iConstraints, ETrue))

   773     {

   774         DEBUG("CMIDTextEditor::InsertContentL -, text not valid");

   775 

   776         User::Leave(KErrArgument);

   777     }

   778 

   779     // Text can be now inserted.

   780     iTextEdwin->Text()->InsertL(aPosition, content->Des());

   781 

   782     // Notify editor that its content has been changed.

   783     iTextEdwin->HandleTextChangedL();

   784 

   785     // Update cursor position based on the inserted content.

   786     if (cursorPosition >= aPosition)

   787     {

   788         DEBUG("CMIDTextEditor::InsertContentL, adjusting cursor");

   789 

   790         // Cursor is set to the end of inserted text.

   791         cursorPosition += content->Length();

   792     }

   793 

   794     // else, cursor is on the left side of the inserted text.

   795     DEBUG_INT("CMIDTextEditor::InsertContentL, cursorPosition=%d",

   796               cursorPosition);

   797 

   798     SetCursorPositionL(cursorPosition);

   799 

   800     // New and original contents are not needed anymore.

   801     CleanupStack::PopAndDestroy(2, originalContent);

   802 

   803     DEBUG("CMIDTextEditor::InsertContentL -");

   804 }

   805 

   806 // ---------------------------------------------------------------------------

   807 // CMIDTextEditor::DeleteContentL

   808 // (other items are commented in the header file)

   809 // ---------------------------------------------------------------------------

   810 //

   811 void CMIDTextEditor::DeleteContentL(TInt aOffset, TInt aLength)

   812 {

   813     DEBUG_INT2("CMIDTextEditor::DeleteContentL +, aOffset=%d, aLength=%d",

   814                aOffset, aLength);

   815 

   816     TInt originalSize = ContentLength();

   817 

   818     // Get cursor position internally because CursorPosition() checks

   819     // wether the editor window is initialized or not.

   820     TInt cursorPosition = CursorPosition();

   821 

   822     // Store current content to local heap descriptor. The content

   823     // needs to be verified before actual deletion. Note that if

   824     // the constraints are not valid for the new text, the state of the

   825     // editor must not be changed by this method!!!

   826     HBufC* originalContent = HBufC::NewLC(originalSize);

   827 

   828     // Note that FEP transaction is also in this text content.

   829     // Note that this function cannot be totally leave safe because

   830     // the cursor must be replaced acording to the deletion.

   831     TPtr contentPtr = originalContent->Des();

   832     iTextEdwin->GetText(contentPtr);

   833 

   834     DEBUG_STR("CMIDTextEditor::DeleteContentL - old content=%S",

   835               contentPtr);

   836 

   837     // Perform deletion at this point. Editor is not changed yet.

   838     contentPtr.Delete(aOffset, aLength);

   839 

   840     DEBUG_STR("CMIDTextEditor::DeleteContentL - new content=%S",

   841               contentPtr);

   842 

   843     // Leave if the content is not valid for the current constraints.

   844     if (!iEdwinUtils->ConstraintsValidForText(

   845                 contentPtr, iConstraints, ETrue))

   846     {

   847         DEBUG("CMIDTextEditor::DeleteContentL -, text not valid");

   848 

   849         User::Leave(KErrArgument);

   850     }

   851 

   852     // Constraints are valid. Perform with the modified text. Setting the text

   853     // cancels to ongoing FEP transaction. Selection is also canceled.

   854     iTextEdwin->SetTextL(originalContent);

   855     CleanupStack::PopAndDestroy(originalContent);

   856 

   857     // Notify editor window that the text has changed.

   858     iTextEdwin->HandleTextChangedL();

   859 

   860     // Modify cursor position. FEP transaction cannot be restored anymore.

   861     // Cursor was in the middle of the deleted range.

   862     if ((cursorPosition > aOffset) &&

   863             (cursorPosition < aOffset + aLength))

   864     {

   865         cursorPosition = aOffset;

   866     }

   867     // Cursor was on the right side of the deleted range.

   868     else if (cursorPosition >= aOffset + aLength)

   869     {

   870         cursorPosition =

   871             (cursorPosition - aLength < 0 ? 0 : cursorPosition - aLength);

   872     }

   873 

   874     // else, cursor was on the left side and does not need modification.

   875     SetCursorPositionL(cursorPosition);

   876 

   877     DEBUG("CMIDTextEditor::DeleteContentL -");

   878 }

   879 

   880 // ---------------------------------------------------------------------------

   881 // CMIDTextEditor::ContentLength

   882 // (other items are commented in the header file)

   883 // ---------------------------------------------------------------------------

   884 //

   885 TInt CMIDTextEditor::ContentLength() const

   886 {

   887     DEBUG_INT("CMIDTextEditor::ContentLength, length=%d",

   888               iTextEdwin->TextLength());

   889 

   890     return iTextEdwin->TextLength();

   891 }

   892 

   893 // ---------------------------------------------------------------------------

   894 // CMIDTextEditor::ContentHeight

   895 // (other items are commented in the header file)

   896 // ---------------------------------------------------------------------------

   897 //

   898 TInt CMIDTextEditor::ContentHeight() const

   899 {

   900     DEBUG("CMIDTextEditor::ContentHeight +");

   901 

   902     // calculation of content height

   903     TInt lineHeight = iTextEdwin->LineHeight();

   904     TInt rowCount = iTextEdwin->NumberOfLines();

   905     TInt height = lineHeight * rowCount;

   906 

   907     // If parent is in fullscreen mode,

   908     // then content height has to be descaled.

   909     if (iComponentContainer && iComponentContainer->IsFullScreen())

   910     {

   911         height = iUtils->DoDescaling(height, CMIDUtils::EHorizontal);

   912     }

   913 

   914     DEBUG_INT("CMIDTextEditor::ContentHeight - , contentHeight=%d",

   915               height);

   916 

   917     return height;

   918 }

   919 

   920 // ---------------------------------------------------------------------------

   921 // CMIDTextEditor::LineMarginHeight

   922 // (other items are commented in the header file)

   923 // ---------------------------------------------------------------------------

   924 //

   925 TInt CMIDTextEditor::LineMarginHeight() const

   926 {

   927     DEBUG("CMIDTextEditor::LineMarginHeight +");

   928 

   929     // Currently line margin is equal to zero since content height is

   930     // line height * row count which gives the same height as the editor's

   931     // height is. There is no method for getting the line margin height

   932     // so at the moment it is considered to be zero.

   933 

   934     return 0;

   935 }

   936 

   937 // ---------------------------------------------------------------------------

   938 // CMIDTextEditor::VisibleContentPosition

   939 // (other items are commented in the header file)

   940 // ---------------------------------------------------------------------------

   941 //

   942 TInt CMIDTextEditor::VisibleContentPosition() const

   943 {

   944     return iTextEdwin->VisibleContentPosition();

   945 }

   946 

   947 // ---------------------------------------------------------------------------

   948 // CMIDTextEditor::SetSelectionL

   949 // (other items are commented in the header file)

   950 // ---------------------------------------------------------------------------

   951 //

   952 void CMIDTextEditor::SetSelectionL(TInt aIndex, TInt aLength)

   953 {

   954     DEBUG_INT2("CMIDTextEditor::SetSelectionL +, aIndex=%d, aLength=%d",

   955                aIndex, aLength);

   956 

   957     TInt endIndex = aIndex + aLength;

   958 

   959     __ASSERT_DEBUG((aIndex >= 0 && aIndex <= ContentLength()) &&

   960                    (aLength >= 0 && endIndex <= ContentLength()),

   961                    User::Invariant());

   962 

   963     // Set cursor to the beginning of the new selection and set the new

   964     // position using the end index and selection. CEikEdwin::SetSelectionL

   965     // always sets the cursor to the beginning of the selection so it cannot

   966     // be used.

   967     iTextEdwin->SetCursorPosL(aIndex, EFalse);

   968     iTextEdwin->SetCursorPosL(endIndex, ETrue);

   969 

   970     DEBUG("CMIDTextEditor::SetSelectionL -");

   971 }

   972 

   973 // ---------------------------------------------------------------------------

   974 // CMIDTextEditor::SelectionL

   975 // (other items are commented in the header file)

   976 // ---------------------------------------------------------------------------

   977 //

   978 HBufC* CMIDTextEditor::SelectionL()

   979 {

   980     DEBUG("CMIDTextEditor::SelectionL +");

   981 

   982     // Get the whole content from the editor. Content is already correctly

   983     // converted at this point when using ContentL() method.

   984     HBufC* content = ContentL();

   985     CleanupStack::PushL(content);

   986 

   987     // Get current selection and remove all other contents from the

   988     // descriptor.

   989     TCursorSelection selection = iTextEdwin->Selection();

   990     TInt lowerPos = selection.LowerPos();

   991     TInt length = selection.Length();

   992 

   993     DEBUG_INT2("CMIDTextEditor::SelectionL, lower pos=%d, length=%d",

   994                lowerPos, length);

   995 

   996     HBufC* ret = HBufC::NewL(length);

   997     TPtr retPtr = ret->Des();

   998 

   999     // Get the selected text from the editor and append it to the new

  1000     // descriptor.

  1001     retPtr.Append(content->Mid(lowerPos, length));

  1002 

  1003     // Content is not needed anymore.

  1004     CleanupStack::PopAndDestroy(content);

  1005 

  1006     DEBUG("CMIDTextEditor::SelectionL -");

  1007 

  1008     return ret;

  1009 }

  1010 

  1011 // ---------------------------------------------------------------------------

  1012 // CMIDTextEditor::SetConstraintsL

  1013 // (other items are commented in the header file)

  1014 // ---------------------------------------------------------------------------

  1015 //

  1016 void CMIDTextEditor::SetConstraintsL(TUint aConstraints)

  1017 {

  1018     DEBUG_INT("CMIDTextEditor::SetConstraintsL +, aConstraints=%d",

  1019               aConstraints);

  1020 

  1021     HBufC* content = ContentL();

  1022     CleanupStack::PushL(content);

  1023 

  1024     TBool currentTextValid =

  1025         iEdwinUtils->ConstraintsValidForText(

  1026             content->Des(), aConstraints, ETrue);

  1027 

  1028     // Set the content to empty if the new constraints are not valid

  1029     // for the current text.

  1030     if (!currentTextValid)

  1031     {

  1032         iTextEdwin->SetTextL(&KNullDesC);

  1033         iTextEdwin->SetCursorPosL(0, EFalse);

  1034         iTextEdwin->HandleTextChangedL();

  1035     }

  1036 

  1037     // Set constraints to the text editor window.

  1038     iTextEdwin->SetConstraintsL(aConstraints);

  1039     // Store constraints of this text editor.

  1040     iConstraints = aConstraints;

  1041 

  1042     if (currentTextValid)

  1043     {

  1044         // Convert breaks if needed if constraints that do not allow line

  1045         // breaks. Note that numeric, decimal and phonenumber do not allow

  1046         // line breaks and are checked before this so no need to check here

  1047         // again.

  1048         if (iConstraints & MMIDTextField::EPassword  ||

  1049                 iTextEdwin->IsConstraintSet(MMIDTextField::EUrl) ||

  1050                 iTextEdwin->IsConstraintSet(MMIDTextField::EMailAddr))

  1051         {

  1052             TPtr ptr = content->Des();

  1053             iEdwinUtils->CropToSingleLine(ptr);

  1054         }

  1055 

  1056         // Set the content to the editor as it was cleared during

  1057         // SetConstraintsL method.

  1058         SetContentL(*content);

  1059     }

  1060 

  1061     CleanupStack::PopAndDestroy(content);

  1062 

  1063     DEBUG("CMIDTextEditor::SetConstraintsL -");

  1064 }

  1065 

  1066 // ---------------------------------------------------------------------------

  1067 // CMIDTextEditor::SetMultilineL

  1068 // (other items are commented in the header file)

  1069 // ---------------------------------------------------------------------------

  1070 //

  1071 void CMIDTextEditor::SetMultilineL(TBool aMultiline)

  1072 {

  1073     DEBUG_INT("CMIDTextEditor::SetMultilineL +, aMultiline=%d", aMultiline);

  1074 

  1075     // Do nothing if the editor state is equal to the requested state or

  1076     // if the constraint modifier PASSWORD is set. Passwords are single

  1077     // line editors due to CMIDEdwinUtils::CPasswordText implementation.

  1078     if (aMultiline == iTextEdwin->IsWrapEnabled() ||

  1079             iConstraints & MMIDTextField::EPassword)

  1080     {

  1081         DEBUG("CMIDTextEditor::SetMultilineL -, ignoring request");

  1082 

  1083         return;

  1084     }

  1085 

  1086     // Content needs to be cropped to single line.

  1087     if (!aMultiline)

  1088     {

  1089         HBufC* content = ContentL();

  1090         CleanupStack::PushL(content);

  1091 

  1092         // Crop line and paragraph breaks.

  1093         TPtr ptr = content->Des();

  1094         iEdwinUtils->CropToSingleLine(ptr);

  1095 

  1096         // Set the cropped content to the editor.

  1097         SetContentL(*content);

  1098         CleanupStack::PopAndDestroy(content);

  1099     }

  1100 

  1101     // Apply wrap on.

  1102     iTextEdwin->SetWordWrapL(aMultiline);

  1103     // Text has been changed so inform the editor window that

  1104     // it needs to redraw itself again.

  1105     iTextEdwin->HandleTextChangedL();

  1106 

  1107     DEBUG("CMIDTextEditor::SetMultilineL -");

  1108 }

  1109 

  1110 // ---------------------------------------------------------------------------

  1111 // CMIDTextEditor::IsMultiline

  1112 // (other items are commented in the header file)

  1113 // ---------------------------------------------------------------------------

  1114 //

  1115 TBool CMIDTextEditor::IsMultiline()

  1116 {

  1117     DEBUG("CMIDTextEditor::IsMultiline +");

  1118     TBool multiline = iTextEdwin->IsWrapEnabled();

  1119     DEBUG("CMIDTextEditor::SetMultilineL -");

  1120     return multiline;

  1121 }

  1122 

  1123 

  1124 // ---------------------------------------------------------------------------

  1125 // CMIDTextEditor::SetInitialInputModeL

  1126 // (other items are commented in the header file)

  1127 // ---------------------------------------------------------------------------

  1128 //

  1129 void CMIDTextEditor::SetInitialInputModeL(const TDesC& aCharacterSubset)

  1130 {

  1131     DEBUG("CMIDTextEditor::SetInitialInputModeL +");

  1132 

  1133     // Edwin handles the initial input mode change.

  1134     iTextEdwin->SetInitialInputModeL(aCharacterSubset);