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 #ifdef RD_JAVA_S60_RELEASE_9_2

    25 // Used with partial VKB

    26 #include <AknPriv.hrh>

    27 #endif // RD_JAVA_S60_RELEASE_9_2

    28 

    29 // INTERNAL INCLUDES

    30 #include "CMIDTextEditor.h"

    31 #include "CMIDTextEditorEdwin.h"

    32 #include "CMIDEditingStateIndicator.h"

    33 #include "CMIDEdwinUtils.h"

    34 #include "CMIDUtils.h"

    35 #include "CMIDFont.h"

    36 #include "CMIDDisplayable.h"

    37 

    38 // Default background color.

    39 const TInt KDefColorBgRed       = 0;

    40 const TInt KDefColorBgGreen     = 0;

    41 const TInt KDefColorBgBlue      = 0;

    42 const TInt KDefColorBgAlpha     = 0;

    43 

    44 // Default foreground color.

    45 const TInt KDefColorFgRed       = 0;

    46 const TInt KDefColorFgGreen     = 0;

    47 const TInt KDefColorFgBlue      = 0;

    48 const TInt KDefColorFgAlpha     = 255;

    49 

    50 // Default highlight background color.

    51 const TInt KDefColorHlBgRed     = 0;

    52 const TInt KDefColorHlBgGreen   = 0;

    53 const TInt KDefColorHlBgBlue    = 0;

    54 const TInt KDefColorHlBgAlpha   = 255;

    55 

    56 // Default highlight foreground color.

    57 const TInt KDefColorHlFgRed     = 255;

    58 const TInt KDefColorHlFgGreen   = 255;

    59 const TInt KDefColorHlFgBlue    = 255;

    60 const TInt KDefColorHlFgAlpha   = 255;

    61 

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

    63 const TInt KComponentCount      = 2;

    64 

    65 // For all touch input modes to be disabled

    66 const TInt KAllTouchModesDisabled    = 63;

    67 

    68 // ---------------------------------------------------------------------------

    69 // CMIDTextEditor::NewL

    70 // ---------------------------------------------------------------------------

    71 //

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

    73 {

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

    75     CleanupStack::PushL(self);

    76     self->ConstructL(aParams);

    77     CleanupStack::Pop(self);

    78     return self;

    79 }

    80 

    81 // ---------------------------------------------------------------------------

    82 // CMIDTextEditor::~CMIDTextEditor

    83 // ---------------------------------------------------------------------------

    84 //

    85 CMIDTextEditor::~CMIDTextEditor()

    86 {

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

    88 

    89 #ifdef RD_TACTILE_FEEDBACK

    90     if (iPenInputServerConnected)

    91     {

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

    93         // connection was established

    94         iPenInputServerConnected = EFalse;

    95         iPenServer.Close();

    96     }

    97 #endif // RD_TACTILE_FEEDBACK

    98 

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

   100     if (iComponentContainer)

   101     {

   102         iComponentContainer->UnregisterComponent(this);

   103     }

   104 

   105     // Remove association from the previous direct container.

   106     if (iDirectContainer)

   107     {

   108         iDirectContainer->MdcRemoveContent(this);

   109     }

   110 

   111     delete iTextEdwin;

   112     delete iEdwinUtils;

   113     delete iEditingStateIndicator;

   114 

   115     iUtils = NULL;

   116     iComponentContainer = NULL;

   117     iDirectContainer = NULL;

   118 

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

   120 }

   121 

   122 // ---------------------------------------------------------------------------

   123 // CMIDTextEditor::CustomComponentControlCount

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

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

   126 //

   127 TInt CMIDTextEditor::CustomComponentControlCount() const

   128 {

   129     return KComponentCount;

   130 }

   131 

   132 // ---------------------------------------------------------------------------

   133 // CMIDTextEditor::CustomComponentControl

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

   135 // ---------------------------------------------------------------------------

   136 //

   137 CCoeControl* CMIDTextEditor::CustomComponentControl(TInt aIndex)

   138 {

   139     switch (aIndex)

   140     {

   141     case 0:

   142     {

   143         return iTextEdwin;

   144     }

   145     case 1:

   146     {

   147         return iEditingStateIndicator;

   148     }

   149     default:

   150     {

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

   152     }

   153     }

   154 

   155     return NULL;

   156 }

   157 

   158 // ---------------------------------------------------------------------------

   159 // CMIDTextEditor::CustomComponentContainerDisposing

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

   161 // ---------------------------------------------------------------------------

   162 //

   163 void CMIDTextEditor::CustomComponentContainerDisposing()

   164 {

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

   166 

   167 #ifdef RD_JAVA_S60_RELEASE_9_2

   168     if (iFocusState)

   169     {

   170         iTextEdwin->CloseVKB();

   171     }

   172 #endif // RD_JAVA_S60_RELEASE_9_2

   173 

   174     // Call SetFocus on edwin

   175     iTextEdwin->SetFocus(EFalse);

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

   177     // the client application.

   178     if (iEditingStateIndicator->EnabledState() ==

   179             CMIDEditingStateIndicator::EIndicatorStateRelative)

   180     {

   181         iEditingStateIndicator->MakeVisible(EFalse);

   182     }

   183     // Set editor window uninitialized

   184     iTextEdwin->Uninitialize();

   185     iComponentContainer = NULL;

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

   187 }

   188 

   189 // ---------------------------------------------------------------------------

   190 // CMIDTextEditor::SetObserver

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

   192 // ---------------------------------------------------------------------------

   193 //

   194 void CMIDTextEditor::SetObserver(MMIDTextEditorObserver* aObserver)

   195 {

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

   197 

   198     iObserver = aObserver;

   199     iTextEdwin->SetObserver(aObserver);

   200 

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

   202 }

   203 

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

   205 // CMIDTextEditor::isTouchEnabled

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

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

   208 //

   209 TBool CMIDTextEditor::IsTouchEnabled()

   210 {

   211     return iTouchEnabled;

   212 }

   213 

   214 // ---------------------------------------------------------------------------

   215 // CMIDTextEditor::setTouchEnabled

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

   217 // ---------------------------------------------------------------------------

   218 //

   219 void CMIDTextEditor::SetTouchEnabled(TBool aEnabled)

   220 {

   221     iTouchEnabled = aEnabled;

   222 }

   223 

   224 // ---------------------------------------------------------------------------

   225 // CMIDTextEditor::SetEditorSize

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

   227 // ---------------------------------------------------------------------------

   228 //

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

   230 {

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

   232                aWidth, aHeight);

   233 

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

   235     // and fullscreen mode changes.

   236     iNonScaledEditorSize = TSize(aWidth, aHeight);

   237 

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

   239     // Only setting otherwise.

   240     if (IsScalingOn())

   241     {

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

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

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

   245         // calculated.

   246         iEditingStateIndicator->SetSize(iUtils->DoScaling(

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

   248     }

   249     else

   250     {

   251         iTextEdwin->SetSize(aWidth, aHeight);

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

   253         // calculated.

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

   255     }

   256 

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

   258     UpdateIndicatorPosition();

   259 

   260     // Redraw the editor

   261     iTextEdwin->Redraw();

   262 

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

   264     // resize the editor any more.

   265     iRowCountActive = EFalse;

   266 

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

   268 }

   269 

   270 // ---------------------------------------------------------------------------

   271 // CMIDTextEditor::EditorSize

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

   273 // ---------------------------------------------------------------------------

   274 //

   275 TSize CMIDTextEditor::EditorSize() const

   276 {

   277     DEBUG("CMIDTextEditor::EditorSize");

   278 

   279     TSize editorSize = iTextEdwin->Size();

   280 

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

   282     if (IsScalingOn())

   283     {

   284         editorSize = iUtils->DoDescaling(editorSize);

   285     }

   286 

   287     return editorSize;

   288 }

   289 

   290 // ---------------------------------------------------------------------------

   291 // CMIDTextEditor::SetParentL

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

   293 // ---------------------------------------------------------------------------

   294 //

   295 void CMIDTextEditor::SetParentL(

   296     MMIDCustomComponentContainer* aComponentContainer)

   297 {

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

   299 

   300     // Remove association from the previous container.

   301     if (iComponentContainer)

   302     {

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

   304 

   305         // Remove focus

   306         SetFocusStateL(EFalse);

   307         // Remove editor from container

   308         iComponentContainer->UnregisterComponent(this);

   309         // Set editor window uninitialized

   310         iTextEdwin->Uninitialize();

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

   312         iComponentContainer = NULL;

   313     }

   314 

   315     // Associate this component to the new container.

   316     if (aComponentContainer)

   317     {

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

   319 

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

   321         // Register container window for the editor.

   322         iTextEdwin->SetContainerWindowL(control);

   323         iTextEdwin->SetTopParent(&control);

   324         // Initialize the editor window.

   325         CMIDDisplayable* displayable = NULL;

   326 #ifdef RD_JAVA_S60_RELEASE_9_2

   327         displayable = aComponentContainer->GetDisplayable();

   328 #endif // RD_JAVA_S60_RELEASE_9_2

   329         iTextEdwin->InitializeL(displayable);

   330         // Set container window also for the indicator.

   331         iEditingStateIndicator->SetContainerWindowL(&control);

   332 

   333         // Register this custom component to the container.

   334         aComponentContainer->RegisterComponentL(this);

   335     }

   336 

   337     // Store container. NULL is ok.

   338     iComponentContainer = aComponentContainer;

   339 

   340     if (iComponentContainer)

   341     {

   342         if (!iRowCountActive)

   343         {

   344             // We need call SetEditorSize to prevent wrong

   345             // scaling of TextEditor.

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

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

   348         }

   349         else

   350         {

   351             iNonScaledEditorSize = iTextEdwin->Size();

   352         }

   353         SetFontL(iNonScaledFont);

   354 

   355         if (iUtils)

   356         {

   357             // It sets edwin variables necessary for correct clipping.

   358             iTextEdwin->SetOnScreenCanvasRect(iUtils->GetOnScreenCanvasRect());

   359             iTextEdwin->SetScaling(IsScalingOn());

   360 

   361             // It sets indicator variables necessary for correct clipping.

   362             iEditingStateIndicator->SetScalingOn(IsScalingOn());

   363             iEditingStateIndicator->SetCanvasRect(iUtils->GetOnScreenCanvasRect());

   364         }

   365     }

   366 

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

   368 }

   369 

   370 // ---------------------------------------------------------------------------

   371 // CMIDTextEditor::SetDirectContainerL

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

   373 // ---------------------------------------------------------------------------

   374 //

   375 void CMIDTextEditor::SetDirectContainerL(MDirectContainer* aDirectContainer)

   376 {

   377     // Remove association from the previous direct container.

   378     if (iDirectContainer)

   379     {

   380         iDirectContainer->MdcRemoveContent(this);

   381     }

   382 

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

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

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

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

   387     if (aDirectContainer)

   388     {

   389         aDirectContainer->MdcAddContent(this);

   390     }

   391 

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

   393     iDirectContainer = aDirectContainer;

   394 }

   395 

   396 // ---------------------------------------------------------------------------

   397 // CMIDTextEditor::SetElevationL

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

   399 // ---------------------------------------------------------------------------

   400 //

   401 void CMIDTextEditor::SetElevationL(TInt aElevation)

   402 {

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

   404 

   405     // Parent must have been set.

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

   407 

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

   409     iComponentContainer->SetComponentIndexL(this, aElevation);

   410 

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

   412 }

   413 

   414 // ---------------------------------------------------------------------------

   415 // CMIDTextEditor::Elevation

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

   417 // ---------------------------------------------------------------------------

   418 //

   419 TInt CMIDTextEditor::Elevation()

   420 {

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

   422 

   423     // Parent must have been set.

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

   425 

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

   427 

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

   429 

   430     return index;

   431 }

   432 

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

   434 {

   435     if (iTextEdwin->Traverse(aEvent))

   436     {

   437         if (iObserver)

   438         {

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

   440                     (aEvent.iScanCode == EStdKeyUpArrow))

   441             {

   442                 iObserver->NotifyInputAction(

   443                     MMIDTextEditorObserver::EActionTraversePrevious);

   444             }

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

   446                      (aEvent.iScanCode == EStdKeyDownArrow))

   447             {

   448                 iObserver->NotifyInputAction(

   449                     MMIDTextEditorObserver::EActionTraverseNext);

   450             }

   451         }

   452     }

   453     else

   454     {

   455         iTextEdwin->OfferKeyEventL(aEvent, EEventKeyDown);

   456     }

   457 }

   458 

   459 // ---------------------------------------------------------------------------

   460 // CMIDTextEditor::Show

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

   462 // ---------------------------------------------------------------------------

   463 //

   464 void CMIDTextEditor::SetVisibleL(TBool aVisible)

   465 {

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

   467 

   468     // SetParentL must be called before Show.

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

   470 

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

   472     {

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

   474 

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

   476         iTextEdwin->MakeVisible(aVisible);

   477 

   478         // If setting visible already focused editor

   479         if (iFocusState)

   480         {

   481             iFocusState = EFalse;

   482             SetFocusStateL(ETrue);

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

   484             // So, set cursor visible.

   485             iTextEdwin->SetCursorVisible(ETrue);

   486         }

   487         else

   488         {

   489             // MakeVisible automatically selects the editor's content

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

   491             // set again with the API.

   492             SetCursorPositionL(iTextEdwin->CursorPos());

   493             iTextEdwin->Redraw();

   494         }

   495     }

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

   497     {

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

   499 

   500         if (iFocusState)

   501         {

   502             // Remove the focus from the editor also.

   503             SetFocusStateL(EFalse);

   504             // Keep focus state for visibility changes

   505             iFocusState = ETrue;

   506         }

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

   508         iTextEdwin->MakeVisible(EFalse);

   509 

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

   511         iEditingStateIndicator->MakeVisible(EFalse);

   512         iTextEdwin->Redraw();

   513     }

   514 

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

   516 }

   517 

   518 // ---------------------------------------------------------------------------

   519 // CMIDTextEditor::IsVisible

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

   521 // ---------------------------------------------------------------------------

   522 //

   523 TBool CMIDTextEditor::IsVisible() const

   524 {

   525     return iTextEdwin->IsVisible();

   526 }

   527 

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

   529 // CMIDTextEditor::SetPosition

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

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

   532 //

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

   534 {

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

   536 

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

   538     // and fullscreen mode changes.

   539     iNonScaledPosition = TPoint(aX, aY);

   540 

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

   542     // Only setting otherwise.

   543     if (IsScalingOn())

   544     {

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

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

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

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

   549     }

   550     else

   551     {

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

   553     }

   554 

   555     // There is needed redraw.

   556     iTextEdwin->Redraw();

   557 

   558     // Update indicator's position if needed.

   559     UpdateIndicatorPosition();

   560 

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

   562 }

   563 

   564 // ---------------------------------------------------------------------------

   565 // CMIDTextEditor::SetCaretXYL

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

   567 // ---------------------------------------------------------------------------

   568 //

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

   570 {

   571     DEBUG_INT2("CMIDTextEditor::SetCaretXYL +, aX=%d, aY=%d", aX, aY);

   572 

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

   574     // to editor position on canvas.

   575     TPoint pos(aX, aY);

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

   577     // with desired informations.

   578     TTmPosInfo2 posInfo;

   579 

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

   581     {

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

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

   584     }

   585 

   586     DEBUG("CMIDTextEditor::SetCaretXYL -");

   587 }

   588 

   589 // ---------------------------------------------------------------------------

   590 // CMIDTextEditor::SetFocusStateL

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

   592 // ---------------------------------------------------------------------------

   593 //

   594 void CMIDTextEditor::SetFocusStateL(TBool aFocusState)

   595 {

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

   597               aFocusState);

   598 

   599     if ((aFocusState) && !(iFocusState))

   600     {

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

   602         iFocusState = ETrue;

   603 

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

   605         iComponentContainer->SetFocusedComponent(this);

   606 

   607         // If the editor is visible, give him focus.

   608         if (iTextEdwin->IsVisible())

   609         {

   610             DEBUG("CMIDTextEditor::SetFocusStateL, visible - iTextEdwin->setFocus(true)");

   611             // Call SetFocus on edwin

   612             iTextEdwin->SetFocus(ETrue);

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

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

   615             // set again with the API.

   616             SetCursorPositionL(iTextEdwin->CursorPos());

   617 

   618             if (iEditingStateIndicator->EnabledState() ==

   619                     CMIDEditingStateIndicator::EIndicatorStateRelative)

   620             {

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

   622                 // by the client application

   623                 iEditingStateIndicator->MakeVisible(ETrue);

   624             }

   625             iTextEdwin->Redraw();

   626         }

   627     }

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

   629     {

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

   631         iFocusState = EFalse;

   632 

   633 #ifdef RD_JAVA_S60_RELEASE_9_2

   634         iTextEdwin->FocusLost();

   635 #endif // RD_JAVA_S60_RELEASE_9_2

   636 

   637         // Call SetFocus on edwin

   638         iTextEdwin->SetFocus(EFalse);

   639 

   640         if (iComponentContainer)

   641         {

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

   643             iComponentContainer->SetFocusedComponent(NULL);

   644         }

   645 

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

   647         // the client application.

   648         if (iEditingStateIndicator->EnabledState() ==

   649                 CMIDEditingStateIndicator::EIndicatorStateRelative)

   650         {

   651             iEditingStateIndicator->MakeVisible(EFalse);

   652         }

   653         iTextEdwin->Redraw();

   654     }

   655 

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

   657 }

   658 

   659 TBool CMIDTextEditor::GetFocusState()

   660 {

   661     return iFocusState;

   662 }

   663 

   664 // ---------------------------------------------------------------------------

   665 // CMIDTextEditor::ContentL

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

   667 // ---------------------------------------------------------------------------

   668 //

   669 HBufC* CMIDTextEditor::ContentL()

   670 {

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

   672 

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

   674 

   675     if (!content)

   676     {

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

   678         // is NULL.

   679         content = HBufC::NewL(0);

   680 

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

   682 

   683         return content;

   684     }

   685 

   686     TPtr ptr = content->Des();

   687 

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

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

   690     // convert the string from localized decimal.

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

   692     {

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

   694 

   695         iEdwinUtils->ConvertFromLocalizedDecimal(content);

   696     }

   697 

   698     // Perform number conversion if it is needed.

   699     if (iEdwinUtils->IsNumberConversionNeeded(iConstraints))

   700     {

   701         DEBUG(

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

   703 

   704         AknTextUtils::ConvertDigitsTo(ptr, EDigitTypeWestern);

   705     }

   706 

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

   708     CMIDUtils::MapETextToJavaChars(content);

   709 

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

   711 

   712     return content;

   713 }

   714 

   715 // ---------------------------------------------------------------------------

   716 // CMIDTextEditor::SetContentL

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

   718 // ---------------------------------------------------------------------------

   719 //

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

   721 {

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

   723 

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

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

   726     // characters are simply removed. See CMIDEdwin.

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

   728             !(iEdwinUtils->ConstraintsValidForText(

   729                   aContent,

   730                   iConstraints, ETrue)))

   731     {

   732         User::Leave(KErrArgument);

   733     }

   734 

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

   736     // specific).

   737     HBufC* buf = ConvertedContentLC(aContent);

   738 

   739     // Set text to the editor window.

   740     iTextEdwin->SetTextL(buf);

   741 

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

   743     CleanupStack::PopAndDestroy(buf);

   744 

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

   746     // it needs to redraw itself again.

   747     iTextEdwin->HandleTextChangedL();

   748 

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

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

   751     SetCursorPositionL(ContentLength());

   752 

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

   754 }

   755 

   756 // ---------------------------------------------------------------------------

   757 // CMIDTextEditor::InsertContentL

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

   759 // ---------------------------------------------------------------------------

   760 //

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

   762 {

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

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

   765 

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

   767     // modifications.

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

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

   770     // characters are simply removed. See CMIDEdwin.

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

   772             !(iEdwinUtils->ConstraintsValidForText(

   773                   aContent,

   774                   iConstraints, ETrue)))

   775     {

   776         User::Leave(KErrArgument);

   777     }

   778 

   779     TInt contentLength = ContentLength();

   780 

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

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

   783     TInt cursorPosition = CursorPosition();

   784 

   785     // Get language converted content.

   786     HBufC* originalContent = ContentL();

   787     CleanupStack::PushL(originalContent);

   788 

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

   790     if (aPosition < 0)

   791     {

   792         aPosition = 0;

   793     }

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

   795     else if (aPosition > contentLength)

   796     {

   797         aPosition = contentLength;

   798     }

   799 

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

   801               aPosition);

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

   803               cursorPosition);

   804 

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

   806     // specific).

   807     HBufC* content = ConvertedContentLC(aContent);

   808 

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

   810     if (!iEdwinUtils->ConstraintsValidForInsertedTextL(

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

   812     {

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

   814 

   815         User::Leave(KErrArgument);

   816     }

   817 

   818     // Text can be now inserted.

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

   820 

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

   822     iTextEdwin->HandleTextChangedL();

   823 

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

   825     if (cursorPosition >= aPosition)

   826     {

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

   828 

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

   830         cursorPosition += content->Length();

   831     }

   832 

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

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

   835               cursorPosition);

   836 

   837     SetCursorPositionL(cursorPosition);

   838 

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

   840     CleanupStack::PopAndDestroy(2, originalContent);

   841 

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

   843 }

   844 

   845 // ---------------------------------------------------------------------------

   846 // CMIDTextEditor::DeleteContentL

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

   848 // ---------------------------------------------------------------------------

   849 //

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

   851 {

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

   853                aOffset, aLength);

   854 

   855     TInt originalSize = ContentLength();

   856 

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

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

   859     TInt cursorPosition = CursorPosition();

   860 

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

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

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

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

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

   866 

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

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

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

   870     TPtr contentPtr = originalContent->Des();

   871     iTextEdwin->GetText(contentPtr);

   872 

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

   874               contentPtr);

   875 

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

   877     contentPtr.Delete(aOffset, aLength);

   878 

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

   880               contentPtr);

   881 

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

   883     if (!iEdwinUtils->ConstraintsValidForText(

   884                 contentPtr, iConstraints, ETrue))

   885     {

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

   887 

   888         User::Leave(KErrArgument);

   889     }

   890 

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

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

   893     iTextEdwin->SetTextL(originalContent);

   894     CleanupStack::PopAndDestroy(originalContent);

   895 

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

   897     iTextEdwin->HandleTextChangedL();

   898 

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

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

   901     if ((cursorPosition > aOffset) &&

   902             (cursorPosition < aOffset + aLength))

   903     {

   904         cursorPosition = aOffset;

   905     }

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

   907     else if (cursorPosition >= aOffset + aLength)

   908     {

   909         cursorPosition =

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

   911     }

   912 

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

   914     SetCursorPositionL(cursorPosition);

   915 

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

   917 }

   918 

   919 // ---------------------------------------------------------------------------

   920 // CMIDTextEditor::ContentLength

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

   922 // ---------------------------------------------------------------------------

   923 //

   924 TInt CMIDTextEditor::ContentLength() const

   925 {

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

   927               iTextEdwin->TextLength());

   928 

   929     return iTextEdwin->TextLength();

   930 }

   931 

   932 // ---------------------------------------------------------------------------

   933 // CMIDTextEditor::ContentHeight

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

   935 // ---------------------------------------------------------------------------

   936 //

   937 TInt CMIDTextEditor::ContentHeight() const

   938 {

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

   940 

   941     // calculation of content height

   942     TInt lineHeight = iTextEdwin->LineHeight();

   943     TInt rowCount = iTextEdwin->NumberOfLines();

   944     TInt height = lineHeight * rowCount;

   945 

   946     // If parent is in fullscreen mode,

   947     // then content height has to be descaled.

   948     if (IsScalingOn())

   949     {

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

   951     }

   952 

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

   954               height);

   955 

   956     return height;

   957 }

   958 

   959 // ---------------------------------------------------------------------------

   960 // CMIDTextEditor::LineMarginHeight

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

   962 // ---------------------------------------------------------------------------

   963 //

   964 TInt CMIDTextEditor::LineMarginHeight() const

   965 {

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

   967 

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

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

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

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

   972 

   973     return 0;

   974 }

   975 

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

   977 // CMIDTextEditor::VisibleContentPosition

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

   979 // ---------------------------------------------------------------------------

   980 //

   981 TInt CMIDTextEditor::VisibleContentPosition() const

   982 {

   983     return iTextEdwin->VisibleContentPosition();

   984 }

   985 

   986 // ---------------------------------------------------------------------------

   987 // CMIDTextEditor::SetSelectionL

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

   989 // ---------------------------------------------------------------------------

   990 //

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

   992 {

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

   994                aIndex, aLength);

   995 

   996     TInt endIndex = aIndex + aLength;

   997 

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

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

  1000                    User::Invariant());

  1001 

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

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

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

  1005     // be used.

  1006     iTextEdwin->SetCursorPosL(aIndex, EFalse);

  1007     iTextEdwin->SetCursorPosL(endIndex, ETrue);

  1008 

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

  1010 }

  1011 

  1012 // ---------------------------------------------------------------------------

  1013 // CMIDTextEditor::SelectionL

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

  1015 // ---------------------------------------------------------------------------

  1016 //

  1017 HBufC* CMIDTextEditor::SelectionL()

  1018 {

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

  1020 

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

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

  1023     HBufC* content = ContentL();

  1024     CleanupStack::PushL(content);

  1025 

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

  1027     // descriptor.

  1028     TCursorSelection selection = iTextEdwin->Selection();

  1029     TInt lowerPos = selection.LowerPos();

  1030     TInt length = selection.Length();

  1031 

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

  1033                lowerPos, length);

  1034 

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

  1036     TPtr retPtr = ret->Des();

  1037 

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

  1039     // descriptor.

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

  1041 

  1042     // Content is not needed anymore.

  1043     CleanupStack::PopAndDestroy(content);

  1044 

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

  1046 

  1047     return ret;

  1048 }

  1049 

  1050 // ---------------------------------------------------------------------------

  1051 // CMIDTextEditor::SetConstraintsL

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

  1053 // ---------------------------------------------------------------------------

  1054 //

  1055 void CMIDTextEditor::SetConstraintsL(TUint aConstraints)

  1056 {

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

  1058               aConstraints);

  1059 

  1060     HBufC* content = ContentL();

  1061     CleanupStack::PushL(content);

  1062 

  1063     TBool currentTextValid =

  1064         iEdwinUtils->ConstraintsValidForText(

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

  1066 

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

  1068     // for the current text.

  1069     if (!currentTextValid)

  1070     {

  1071         iTextEdwin->SetTextL(&KNullDesC);

  1072         iTextEdwin->SetCursorPosL(0, EFalse);

  1073         iTextEdwin->HandleTextChangedL();

  1074     }

  1075 

  1076     // Set constraints to the text editor window.

  1077     iTextEdwin->SetConstraintsL(aConstraints);

  1078     // Store constraints of this text editor.

  1079     iConstraints = aConstraints;

  1080 

  1081     if (currentTextValid)

  1082     {

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

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

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

  1086         // again.

  1087         if (iConstraints & MMIDTextField::EPassword  ||

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

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

  1090         {

  1091             TPtr ptr = content->Des();

  1092             iEdwinUtils->CropToSingleLine(ptr);

  1093         }

  1094 

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

  1096         // SetConstraintsL method.

  1097         SetContentL(*content);

  1098     }

  1099 

  1100     CleanupStack::PopAndDestroy(content);

  1101 

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

  1103 }

  1104 

  1105 // ---------------------------------------------------------------------------

  1106 // CMIDTextEditor::SetMultilineL

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

  1108 // ---------------------------------------------------------------------------

  1109 //

  1110 void CMIDTextEditor::SetMultilineL(TBool aMultiline)

  1111 {

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

  1113 

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

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

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

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

  1118             iConstraints & MMIDTextField::EPassword)

  1119     {

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

  1121 

  1122         return;

  1123     }

  1124 

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

  1126     if (!aMultiline)

  1127     {

  1128         HBufC* content = ContentL();

  1129         CleanupStack::PushL(content);

  1130 

  1131         // Crop line and paragraph breaks.

  1132         TPtr ptr = content->Des();

  1133         iEdwinUtils->CropToSingleLine(ptr);

  1134