2 // Open Service Platform
3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
5 // Licensed under the Flora License, Version 1.0 (the License);
6 // you may not use this file except in compliance with the License.
7 // You may obtain a copy of the License at
9 // http://floralicense.org/license/
11 // Unless required by applicable law or agreed to in writing, software
12 // distributed under the License is distributed on an AS IS BASIS,
13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 // See the License for the specific language governing permissions and
15 // limitations under the License.
19 * @file FGrp_TextTextObject.cpp
20 * @brief This is the implementation file for TextObject class.
24 #include <FGrpBitmap.h>
25 #include <FBaseSysLog.h>
26 #include "FGrp_FontImpl.h"
27 #include "../FGrp_Font.h"
28 #include "../FGrp_Canvas.h"
29 #include "../FGrp_ResUtil.h"
30 #include "FGrp_TextTextObject.h"
31 #include "FGrp_TextTextElement.h"
32 #include "FGrp_TextTextSimple.h"
33 #include "FGrp_TextTextImage.h"
34 #include "FGrp_TextTextCutLink.h"
35 #include "FGrp_TextTextComposite.h"
36 #include "FGrp_TextTextLine.h"
37 #include "FGrp_TextTextColumn.h"
38 #include "FGrp_TextTextUtility.h"
39 #include "FGrp_TextTextWidthManager.h"
40 #include "FGrp_Screen.h"
42 #define IF_NOT_CONSTRUCTED(code) if (this->__pCompositeText == null || this->__pTextColumn == null) \
47 using namespace Tizen::Base::Utility;
48 using namespace Tizen::Base;
50 namespace Tizen { namespace Graphics
56 TextObject::TextObject(void)
58 __action = TEXT_OBJECT_ACTION_TYPE_NONE;
59 __align = (TextObjectAlignment)(TEXT_OBJECT_ALIGNMENT_LEFT | TEXT_OBJECT_ALIGNMENT_TOP);
60 __wrap = TEXT_OBJECT_WRAP_TYPE_NONE;
63 __pCompositeText = null;
64 __pDefaultFont = null;
65 __defaultForegroundColor = Color::GetColor(COLOR_ID_BLACK);
66 __defaultBackgroundColor = Color::GetColor(COLOR_ID_WHITE);
67 __defaultOutlineColor = Color::GetColor(COLOR_ID_WHITE);
68 __isAlternateLookEnabled = false;
70 __textObjectEllipsisType = TEXT_OBJECT_ELLIPSIS_TYPE_TAIL;
71 __isFirstDisplayPositionYChanged = false;
82 __pTextWidthManager = null;
83 __linkViewModeEnabled = false;
84 __isUrlLinkColorDefined = false;
85 __isEmailLinkColorDefined = false;
86 __isPhoneNumberLinkColorDefined = false;
87 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_URL_NORMAL] = Color::GetColor(COLOR_ID_BLUE);
88 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_URL_SELECT] = Color::GetColor(COLOR_ID_BLUE);
89 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_EMAIL_NORMAL] = Color::GetColor(COLOR_ID_BLUE);
90 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_EMAIL_SELECT] = Color::GetColor(COLOR_ID_BLUE);
91 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_PHONE_NUMBER_NORMAL] = Color::GetColor(COLOR_ID_BLUE);
92 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_PHONE_NUMBER_SELECT] = Color::GetColor(COLOR_ID_BLUE);
94 __sweepInfo.isValid = false;
95 __sweepInfo.sweepType = TEXT_OBJECT_SWEEP_TYPE_NONE;
96 __sweepInfo.sweepEventType = TEXT_OBJECT_SWEEP_EVENT_INSERT;
97 __sweepInfo.anchorTextIndex = 0;
98 __sweepInfo.anchorLineIndex = 0;
99 __sweepInfo.prevAnchorLineIndex = 0;
100 __sweepInfo.sweepRegionStartLineIndex = 0;
101 __sweepInfo.sweepRegionLineCount = 0;
102 __sweepInfo.insertedLineCount = 0;
103 __sweepInfo.deletedLineCount = 0;
104 __sweepInfo.widthChanged = 0;
107 TextObject::~TextObject(void)
109 if (__pCompositeText)
111 delete __pCompositeText;
112 __pCompositeText = null;
117 delete __pTextColumn;
118 __pTextColumn = null;
121 if (__pTextWidthManager)
123 delete __pTextWidthManager;
124 __pTextWidthManager = null;
129 delete __pDefaultFont;
130 __pDefaultFont = null;
135 TextObject::Construct(void)
137 result r = E_SUCCESS;
139 __action = TEXT_OBJECT_ACTION_TYPE_NONE;
140 __align = (TextObjectAlignment)(TEXT_OBJECT_ALIGNMENT_LEFT | TEXT_OBJECT_ALIGNMENT_TOP);
141 __wrap = TEXT_OBJECT_WRAP_TYPE_WORD;
142 __isActionOn = false;
144 __defaultForegroundColor = Color::GetColor(COLOR_ID_BLACK);
145 __defaultBackgroundColor = Color::GetColor(COLOR_ID_WHITE);
146 __defaultOutlineColor = Color::GetColor(COLOR_ID_WHITE);
148 __isAlternateLookEnabled = false;
149 __linkViewModeEnabled = false;
150 __pTextWidthManager = null;
152 __pCompositeText = new (std::nothrow)TextComposite();
155 , r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
157 __pTextColumn = new (std::nothrow)TextColumn(__pCompositeText);
160 , r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
162 __pDefaultFont = new (std::nothrow)Font();
165 , r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
167 r = __pDefaultFont->Construct(FONT_STYLE_PLAIN, 20);
170 , , E_SYSTEM, "[E_SYSTEM] Fail to set font.");
172 __pCompositeText->SetWrap(__wrap);
173 __pCompositeText->SetTextSweepInfo(&__sweepInfo);
180 delete __pDefaultFont;
181 __pDefaultFont = null;
184 if (__pCompositeText)
186 delete __pCompositeText;
187 __pCompositeText = null;
192 delete __pTextColumn;
193 __pTextColumn = null;
196 if (__pTextWidthManager)
198 delete __pTextWidthManager;
199 __pTextWidthManager = null;
206 TextObject::Construct(const Rectangle& rect)
208 result r = E_SUCCESS;
210 __action = TEXT_OBJECT_ACTION_TYPE_NONE;
211 __align = (TextObjectAlignment)(TEXT_OBJECT_ALIGNMENT_LEFT | TEXT_OBJECT_ALIGNMENT_TOP);
212 __wrap = TEXT_OBJECT_WRAP_TYPE_WORD;
213 __isActionOn = false;
215 __defaultForegroundColor = Color::GetColor(COLOR_ID_BLACK);
216 __defaultBackgroundColor = Color::GetColor(COLOR_ID_WHITE);
217 __defaultOutlineColor = Color::GetColor(COLOR_ID_WHITE);
219 __isAlternateLookEnabled = false;
220 __linkViewModeEnabled = false;
221 __pTextWidthManager = null;
223 __pcRect.x = _ResUtil::ConvertToPhyCoord(rect.x);
224 __pcRect.y = _ResUtil::ConvertToPhyCoord(rect.y);
225 __pcRect.width = _ResUtil::ConvertToPhyCoordWidth(rect.width);
226 __pcRect.height = _ResUtil::ConvertToPhyCoordHeight(rect.height);
228 __pCompositeText = new (std::nothrow)TextComposite();
231 , r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
233 __pTextColumn = new (std::nothrow)TextColumn(__pCompositeText);
236 , r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
238 __pDefaultFont = new (std::nothrow)Font();
241 , r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
243 r = __pDefaultFont->Construct(FONT_STYLE_PLAIN, 20);
246 , , E_SYSTEM, "[E_SYSTEM] Fail to set font.");
248 __pCompositeText->SetWrap(__wrap);
249 __pCompositeText->SetTextSweepInfo(&__sweepInfo);
256 delete __pDefaultFont;
257 __pDefaultFont = null;
260 if (__pCompositeText)
262 delete __pCompositeText;
263 __pCompositeText = null;
268 delete __pTextColumn;
269 __pTextColumn = null;
272 if (__pTextWidthManager)
274 delete __pTextWidthManager;
275 __pTextWidthManager = null;
282 TextObject::CloneN(void)
284 IF_NOT_CONSTRUCTED(return null);
286 result r = E_SUCCESS;
287 TextObject* pTextObject = null;
288 TextElement* pTextElement = null;
289 TextElement* pCloneTextElement = null;
290 int count = __pCompositeText->GetElementCount();
292 pTextObject = new (std::nothrow)TextObject();
295 , null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
297 r = pTextObject->Construct();
300 , , r, "[%s] Propagating.", GetErrorMessage(r));
302 for (int i=0; i < count; i++)
304 pTextElement = __pCompositeText->GetElementAtElementIndex(i);
307 , , E_SYSTEM, "[E_SYSTEM] Fail to get text element.");
309 pCloneTextElement = pTextElement->CloneN(SET_ALLVALUE_CLONE,0);
310 pTextObject->AppendElement(*pCloneTextElement);
313 SetLastResult(E_SUCCESS);
325 TextObject::Draw(_CanvasImpl& canvasImpl)
327 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
329 if (__pcRect.width == 0 || __pcRect.height == 0)
334 result r = E_SUCCESS;
335 TextLine* pTextLine = null;
337 Rectangle lineBounds;
338 Rectangle targetBounds;
340 int slidingWidth = 0;
343 , __pcRect.width > 0 && __pcRect.height > 0
344 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] This instance is not constructed yet. (width = %d, height = %d)", __pcRect.width, __pcRect.height);
346 _Canvas* pCanvas = _Canvas::GetInstance(canvasImpl);
349 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
354 , r, r, "[%s] Propagating.", GetErrorMessage(r));
356 if (__pTextColumn->GetTotalLineCount() <= 1)
358 __pTextColumn->SetFirstDisplayLineIndex(0);
359 __pTextColumn->SetFirstDisplayPositionY(0);
362 targetBounds = __pcRect;
364 if (__action == TEXT_OBJECT_ACTION_TYPE_SLIDE_LEFT)
366 if (__pTextColumn->GetTotalLineCount() == 0)
371 totalHeight = TextUtility::GetFontMaxHeight(__pDefaultFont);
375 totalHeight = __pTextColumn->GetTotalHeight();
378 if (totalHeight == 0)
383 if (totalHeight < targetBounds.height)
385 switch (__align & TEXT_ALIGNMASK_VERT)
387 case TEXT_OBJECT_ALIGNMENT_TOP:
392 case TEXT_OBJECT_ALIGNMENT_MIDDLE:
393 targetBounds.y += (targetBounds.height - totalHeight) / 2;
396 case TEXT_OBJECT_ALIGNMENT_BOTTOM:
397 targetBounds.y += targetBounds.height - totalHeight;
403 if (targetBounds.height < totalHeight)
405 if (__action == TEXT_OBJECT_ACTION_TYPE_ABBREV)
408 int lineCount = __pTextColumn->GetTotalLineCount();
412 totalHeight = targetBounds.height;
416 int lineHeight = __pTextColumn->GetLineHeightAt(0);
418 if (targetBounds.height < lineHeight)
420 totalHeight = targetBounds.height;
426 for (i = 0; i < lineCount; i++)
428 lineHeight += __pTextColumn->GetLineHeightAt(i);
429 if (targetBounds.height < lineHeight)
431 lineHeight -= __pTextColumn->GetLineHeightAt(i);
435 totalHeight = lineHeight;
449 switch (__align & TEXT_ALIGNMASK_VERT)
451 case TEXT_OBJECT_ALIGNMENT_TOP:
456 case TEXT_OBJECT_ALIGNMENT_MIDDLE:
457 targetBounds.y += (targetBounds.height - totalHeight) / 2;
460 case TEXT_OBJECT_ALIGNMENT_BOTTOM:
461 targetBounds.y += targetBounds.height - totalHeight;
464 targetBounds.height = totalHeight;
468 Rectangle finalClipRect;
469 clipRect = pCanvas->GetClipBounds();
471 finalClipRect.x = Math::Max(clipRect.x, targetBounds.x);
472 finalClipRect.y = Math::Max(clipRect.y, targetBounds.y);
473 finalClipRect.width = Math::Min(clipRect.x + clipRect.width, targetBounds.x + targetBounds.width) - finalClipRect.x;
474 finalClipRect.height = Math::Min(clipRect.y + clipRect.height, targetBounds.y + targetBounds.height) - finalClipRect.y;
477 , 0 <= finalClipRect.width && 0 <= finalClipRect.height
478 , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get clip rectangle.");
480 pCanvas->SetClipBounds(finalClipRect);
484 case TEXT_OBJECT_ACTION_TYPE_SLIDE_LEFT:
485 pTextLine = __pTextColumn->GetTextLine(0);
488 , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
490 lineBounds = pTextLine->GetBounds();
491 __pTextColumn->SetDisplayLineCount(1);
492 __pTextColumn->SetDisplayHeight(lineBounds.height);
494 slidingWidth = Math::Max(__pTextColumn->GetSlidingDimension().width, __pcRect.width);
498 Rectangle slidingRect;
500 targetBounds.width = lineBounds.width;
501 targetBounds.height = lineBounds.height;
503 pCanvas->SetClipBounds(targetBounds);
505 slidingRect = targetBounds;
507 slidingRect.x += __pTextColumn->GetSlidingPosition();
508 Dimension slidingDim = __pTextColumn->GetSlidingDimension();
509 slidingRect.width = slidingDim.width;
510 slidingRect.height = slidingDim.height;
512 __pCompositeText->Draw(canvasImpl, slidingRect, 0, __pCompositeText->GetTextLength(),
513 (TextObjectAlignment)(__align & TEXT_ALIGNMASK_HORIZ), TEXT_OBJECT_ACTION_TYPE_NONE);
515 slidingRect.x += slidingDim.width + __slidingGap;
516 if (slidingRect.x < targetBounds.x + targetBounds.width)
518 slidingRect.width = targetBounds.x + targetBounds.width - slidingRect.x;
520 __pCompositeText->Draw(canvasImpl, slidingRect, 0, __pCompositeText->GetTextLength(),
521 (TextObjectAlignment)(__align & TEXT_ALIGNMASK_HORIZ), TEXT_OBJECT_ACTION_TYPE_NONE);
526 pTextLine->Draw(canvasImpl, targetBounds, 0, pTextLine->GetTextLength(),
527 (TextObjectAlignment)(__align & TEXT_ALIGNMASK_HORIZ), TEXT_OBJECT_ACTION_TYPE_NONE);
531 case TEXT_OBJECT_ACTION_TYPE_SLIDE_UP:
533 Rectangle slidingRect = targetBounds;
534 slidingRect.y += __pTextColumn->GetSlidingPosition();
536 int lineCount = __pTextColumn->GetTotalLineCount();
537 for (int i = 0; i < lineCount; i++)
539 pTextLine = __pTextColumn->GetTextLine(i);
540 if (pTextLine != null)
542 lineBounds = pTextLine->GetBounds();
543 slidingRect.height = lineBounds.height;
544 if ((slidingRect.y + slidingRect.height >= targetBounds.y) &&
545 (slidingRect.y < targetBounds.y + targetBounds.height))
547 pTextLine->Draw(canvasImpl, slidingRect, 0, pTextLine->GetTextLength(),
548 (TextObjectAlignment)(__align & TEXT_ALIGNMASK_HORIZ), TEXT_OBJECT_ACTION_TYPE_NONE);
551 slidingRect.y += slidingRect.height;
556 case TEXT_OBJECT_ACTION_TYPE_ABBREV:
557 if (__pCompositeText->IsTextAbbreviationEnabled())
559 __pCompositeText->DrawAbbrev(canvasImpl, targetBounds, __align);
563 DrawByLine(canvasImpl, targetBounds);
567 case TEXT_OBJECT_ACTION_TYPE_NONE:
570 DrawByLine(canvasImpl, targetBounds);
574 pCanvas->SetClipBounds(clipRect);
580 TextObject::GetChangedLineRange(int& startChangedLineIndex, int& endChangedLineIndex)
582 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
584 result r = E_SUCCESS;
589 , r, r, "[%s] Propagating.", GetErrorMessage(r));
591 startChangedLineIndex = __sweepInfo.sweepRegionStartLineIndex;
592 endChangedLineIndex = __sweepInfo.sweepRegionStartLineIndex + __sweepInfo.sweepRegionLineCount - 1;
598 TextObject::DrawLine(_CanvasImpl& canvasImpl, int lineIndex)
600 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
604 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid. (lineIndex = %d)", lineIndex);
606 result r = E_SUCCESS;
607 TextLine* pTextLine = null;
608 Rectangle lineBounds;
609 int firstDisplayY = __pTextColumn->GetFirstDisplayPositionY();
614 , r, r, "[%s] Propagating.", GetErrorMessage(r));
616 pTextLine = __pTextColumn->GetTextLine(lineIndex);
617 if (pTextLine == null)
619 SysLog(NID_GRP, "[E_INVALID_ARG] The argument is invalid. (lineIndex = %d, total line count = %d)"
620 , lineIndex, __pTextColumn->GetTotalLineCount());
622 return E_INVALID_ARG;
625 lineBounds = pTextLine->GetBounds();
626 lineBounds.y = lineBounds.y - firstDisplayY + __rect.y;
628 int length = pTextLine->GetTextLength();
629 pTextLine->Draw(canvasImpl, lineBounds, 0, length, __align, TEXT_OBJECT_ACTION_TYPE_NONE);
635 TextObject::DrawWithOffset(_CanvasImpl& canvasImpl)
637 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
641 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] Action is off.");
643 int slidingStartIndex = __pTextColumn->GetSlidingPosition();
644 Dimension slidingDim = __pTextColumn->GetSlidingDimension();
648 case TEXT_OBJECT_ACTION_TYPE_SLIDE_LEFT:
649 if (__pcRect.width < slidingDim.width)
651 slidingDim.width = Math::Max(slidingDim.width, __pcRect.width);
653 if (__slidingStep < slidingStartIndex + slidingDim.width + __slidingGap)
655 slidingStartIndex -= __slidingStep;
659 slidingStartIndex += slidingDim.width + __slidingGap;
664 if (0 < slidingStartIndex + slidingDim.width)
666 slidingStartIndex -= __slidingStep;
670 slidingStartIndex = __pcRect.width + __slidingGap + slidingStartIndex;
673 __pTextColumn->SetSlidingPosition(slidingStartIndex);
676 case TEXT_OBJECT_ACTION_TYPE_SLIDE_UP:
677 if (slidingStartIndex + slidingDim.height >= 0)
679 slidingStartIndex -= __slidingStep;
683 slidingStartIndex = __pcRect.height;
685 __pTextColumn->SetSlidingPosition(slidingStartIndex);
688 case TEXT_OBJECT_ACTION_TYPE_ABBREV:
690 case TEXT_OBJECT_ACTION_TYPE_NONE:
696 return Draw(canvasImpl);
700 TextObject::UpdateChangedInfo(int startTextIndex, int textLength, bool initTextWidthManager)
702 result r = E_SUCCESS;
704 if (startTextIndex >= 0)
706 r = __pTextColumn->SetChangeAction(TextColumn::TEXT_CHANGE_UNKONWN, startTextIndex, 0);
709 , r, r, "[%s] Propagating.", GetErrorMessage(r));
711 if (__pCompositeText->IsWidthManagerEnabled() && __pTextWidthManager && initTextWidthManager)
713 __pTextWidthManager->Finalize();
714 if (__wrap == TEXT_OBJECT_WRAP_TYPE_WORD)
716 __pTextWidthManager->Initialize(__pCompositeText->GetTextLength());
723 if (IsPartialComposingModeEnabled())
725 __pCompositeText->InitPartialComposeMode();
732 TextObject::IsChanged(void) const
734 IF_NOT_CONSTRUCTED(return false);
740 TextObject::SetPartialComposingModeEnabled(bool enable)
742 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
744 __pCompositeText->SetPartialComposingModeEnabled(enable);
750 TextObject::IsPartialComposingModeEnabled(void) const
752 IF_NOT_CONSTRUCTED(return false);
754 return __pCompositeText->IsPartialComposingModeEnabled();
758 TextObject::Compose(void)
760 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
764 Rectangle lineBounds;
767 , __pcRect.width >= 0 && __pcRect.height >= 0
768 , E_INVALID_STATE, E_INVALID_STATE, "[E_INVALID_STATE] This instance is not constructed yet.");
772 if (__pCompositeText->IsPartialComposingModeEnabled())
774 if (__pCompositeText->IsComposeDone() || !__isFirstDisplayPositionYChanged)
776 if (GetTotalLineCount() != 0)
784 if (!__isChanged || __pTextColumn->GetChangeActionEventCount() == 0)
790 __isActionOn = false;
792 if (__pTextColumn->GetTotalLineCount() == 0)
794 __pTextColumn->SetChangeAction(TextColumn::TEXT_CHANGE_UNKONWN, 0, 0);
795 __pTextColumn->SetFirstDisplayLineIndex(0);
796 __pTextColumn->SetFirstDisplayPositionY(0);
800 lineCount = __pCompositeText->Compose(rect, __pTextColumn);
804 case TEXT_OBJECT_ACTION_TYPE_SLIDE_LEFT:
806 TextLine* pTextLine = __pTextColumn->GetTextLine(0);
807 if (pTextLine != null)
809 int lineLength = pTextLine->GetTextLength();
810 int totalLength = __pCompositeText->GetTextLength();
812 if (lineLength < totalLength)
815 __pTextColumn->SetSlidingPosition(0);
817 Dimension slidingDim;
818 Dimension lineTextSize;
820 __pCompositeText->GetRegion(0, totalLength, slidingDim.width, slidingDim.height);
821 pTextLine->GetRegion(0, lineLength, lineTextSize.width, lineTextSize.height);
822 lineBounds = pTextLine->GetBounds();
824 __pTextColumn->SetSlidingDimension(slidingDim);
826 lineBounds.height = slidingDim.height;
827 lineTextSize.width = lineBounds.width;
829 pTextLine->SetBounds(lineBounds);
830 pTextLine->SetRegion(lineTextSize.width, lineTextSize.height);
836 case TEXT_OBJECT_ACTION_TYPE_SLIDE_UP:
838 __pTextColumn->SetSlidingPosition(0);
840 int totalHeight = __pTextColumn->GetTotalHeight();
841 Dimension slidingDim;
842 slidingDim.width = __pcRect.width;
843 slidingDim.height = totalHeight;
845 __pTextColumn->SetSlidingDimension(slidingDim);
847 if (__pcRect.height < totalHeight)
854 case TEXT_OBJECT_ACTION_TYPE_ABBREV:
856 case TEXT_OBJECT_ACTION_TYPE_NONE:
868 TextObject::GetText(wchar_t* pCopiedText, int textLength) const
870 IF_NOT_CONSTRUCTED(return -1);
874 , -1, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
878 , -1, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
880 int textElementCount = 0;
882 int outLength = textLength;
883 int copiedLength = 0;
884 TextElement* pTextElement = null;
885 wchar_t* pSrcText = null;
886 wchar_t* pDstText = null;
888 textElementCount = __pCompositeText->GetElementCount();
889 pDstText = pCopiedText;
891 for (int i = 0; i < textElementCount && totalLength < outLength; i++)
893 pTextElement = __pCompositeText->GetElementAtElementIndex(i);
894 if (pTextElement == null)
899 TextElementType objectType = pTextElement->GetType();
900 if (objectType == TEXT_ELEMENT_TYPE_TEXT || objectType == TEXT_ELEMENT_TYPE_CUTLINK)
902 int elementTextLength = pTextElement->GetTextLength();
903 TextSimple* pSimpleText = dynamic_cast < TextSimple* >(pTextElement);
904 if (pSimpleText != null)
906 copiedLength = (elementTextLength > outLength - totalLength) ? outLength - totalLength : elementTextLength;
909 , -1, E_SYSTEM, "[E_SYSTEM] Fail to string copy.");
911 pSrcText = (wchar_t*)pSimpleText->GetText();
913 result r = TextUtility::CopyText(pDstText, pSrcText, copiedLength);
916 , -1, r, "[%s] Propagating.", GetErrorMessage(r));
918 pDstText += copiedLength;
919 totalLength += copiedLength;
924 SetLastResult(E_SUCCESS);
930 TextObject::SetFirstDisplayLineIndex(int lineIndex)
932 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
934 result r = E_SUCCESS;
935 Rectangle lineBounds;
936 TextLine* pTextLine = null;
937 int firstDisplayPositionY = 0;
938 int rollbackFirstDisplayPositionY = 0;
939 int rollbackFirstDisplayLineIndex = 0;
941 rollbackFirstDisplayPositionY = __pTextColumn->GetFirstDisplayPositionY();
942 rollbackFirstDisplayLineIndex = __pTextColumn->GetFirstDisplayLineIndex();
944 __pTextColumn->SetFirstDisplayLineIndex(lineIndex);
946 pTextLine = __pTextColumn->GetTextLine(lineIndex);
949 , r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get text element.");
951 lineBounds = pTextLine->GetBounds();
952 firstDisplayPositionY = lineBounds.y;
954 __pTextColumn->SetFirstDisplayPositionY(firstDisplayPositionY);
959 __pTextColumn->SetFirstDisplayLineIndex(rollbackFirstDisplayLineIndex);
960 __pTextColumn->SetFirstDisplayPositionY(rollbackFirstDisplayPositionY);
966 TextObject::SetFirstDisplayPositionY(int lcY)
968 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
970 result r = E_SUCCESS;
972 int pcY = _ResUtil::ConvertToPhyCoord(lcY);
973 if (IsPartialComposingModeEnabled())
975 __isFirstDisplayPositionYChanged = true;
977 if (__pCompositeText->GetTotalComposedHeight() <= (pcY + __pcRect.height))
979 __pCompositeText->SetComposePartialLimitHeight(pcY + __pcRect.height - GetTotalComposedHeight());
984 , , r, "[%s] Propagating.", GetErrorMessage(r));
988 __isFirstDisplayPositionYChanged = false;
989 __pTextColumn->SetFirstDisplayPositionY(pcY);
994 __isFirstDisplayPositionYChanged = false;
999 TextObject::GetMaxLineHeight(void) const
1001 IF_NOT_CONSTRUCTED(return -1);
1003 int pcMaxHeight = __pCompositeText->GetMaxLineHeight();
1004 pcMaxHeight = Math::Max(pcMaxHeight, TextUtility::GetFontMaxHeight(__pDefaultFont));
1005 int lcMaxHeight = _ResUtil::ConvertToVirCoord(pcMaxHeight);
1011 TextObject::IsDisplayedAtStartPosition(void) const
1013 IF_NOT_CONSTRUCTED(return false);
1015 int firstDisplayPositionY = __pTextColumn->GetFirstDisplayPositionY();
1016 if (firstDisplayPositionY == 0)
1027 TextObject::IsDisplayedAtEndPosition(void) const
1029 IF_NOT_CONSTRUCTED(return false);
1031 int totalHeight = 0;
1032 int firstDisplayPositionY = 0;
1034 firstDisplayPositionY = __pTextColumn->GetFirstDisplayPositionY();
1035 totalHeight = __pTextColumn->GetTotalHeight();
1037 if ((totalHeight - firstDisplayPositionY) <= __pcRect.height)
1048 TextObject::SetAction(TextObjectActionType action)
1050 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1052 SysTryReturn(NID_GRP
1053 , TEXT_OBJECT_ACTION_TYPE_NONE <= action && action < TEXT_OBJECT_ACTION_TYPE_MAX
1054 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1056 if (__action != action)
1058 if ((__action == TEXT_OBJECT_ACTION_TYPE_NONE && action == TEXT_OBJECT_ACTION_TYPE_ABBREV) ||
1059 (__action == TEXT_OBJECT_ACTION_TYPE_ABBREV && action == TEXT_OBJECT_ACTION_TYPE_NONE))
1062 UpdateChangedInfo(0, 0);
1067 UpdateChangedInfo(0, 0);
1070 if (__action == TEXT_OBJECT_ACTION_TYPE_ABBREV)
1072 __pCompositeText->SetTextAbbreviationEnabled(true);
1076 __pCompositeText->SetTextAbbreviationEnabled(false);
1083 TextObject::SetAlignment(TextObjectAlignment alignment)
1085 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1087 SysTryReturn(NID_GRP
1088 , TEXT_OBJECT_ALIGNMENT_LEFT <= alignment && alignment < TEXT_OBJECT_ALIGNMENT_INVALID
1089 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid. alignment(%d)", alignment);
1091 if (__align != alignment)
1093 __align = alignment;
1094 UpdateChangedInfo(0, 0);
1101 TextObject::SetBounds(const Rectangle& lcRect)
1103 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1105 SysTryReturn(NID_GRP
1106 , (lcRect.width >= 0) && (lcRect.height >= 0)
1107 , E_OUT_OF_RANGE, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] The given rectangle(width:%d,height:%d) is out of range.\n", lcRect.width, lcRect.height);
1109 if (__rect.width != lcRect.width)
1111 UpdateChangedInfo(0, 0, false);
1116 if (_ResUtil::NeedToConvertCoord())
1118 __pcRect.x = _ResUtil::ConvertToPhyCoord(__rect.x);
1119 __pcRect.y = _ResUtil::ConvertToPhyCoord(__rect.y);
1120 __pcRect.width = _ResUtil::ConvertToPhyCoordWidth(__rect.width);
1122 // temporary code for tizen 2.0
1123 if (_Screen::GetWidth() == 600)
1128 __pcRect.height = _ResUtil::ConvertToPhyCoordHeight(__rect.height);
1139 TextObject::SetLineSpace(int lcLineSpacing)
1141 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1143 SysTryReturn(NID_GRP
1144 , lcLineSpacing >= 0
1145 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1147 int pcLineSpacing = _ResUtil::ConvertToPhyCoord(lcLineSpacing);
1149 if (__pCompositeText->GetLineSpace() != pcLineSpacing)
1151 __pCompositeText->SetLineSpace(pcLineSpacing);
1159 TextObject::SetElementVerticalAlignment(TextObjectAlignment alignment)
1161 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1163 SysTryReturn(NID_GRP
1164 , (alignment & TEXT_OBJECT_ALIGNMENT_TOP) || (alignment & TEXT_OBJECT_ALIGNMENT_MIDDLE) || (alignment & TEXT_OBJECT_ALIGNMENT_BOTTOM) || (alignment & TEXT_OBJECT_ALIGNMENT_BASELINE)
1165 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid. alignment(%d)", alignment);
1167 if (__pCompositeText->GetElementVerticalAlignment() == alignment)
1172 __pCompositeText->SetElementVerticalAlignment(alignment);
1179 TextObject::GetTextExtent(int startTextIndex, int textLength) const
1181 IF_NOT_CONSTRUCTED(return Dimension(-1, -1));
1183 Dimension pcTextSize;
1184 result r = __pCompositeText->GetRegion(startTextIndex, textLength, pcTextSize.width, pcTextSize.height);
1185 SysTryReturn(NID_GRP
1187 , Dimension(-1, -1), r, "[%s] Propagating.", GetErrorMessage(r));
1189 Dimension lcTextSize;
1190 lcTextSize.width = _ResUtil::ConvertToVirCoord(pcTextSize.width);
1191 lcTextSize.height = _ResUtil::ConvertToVirCoord(pcTextSize.height);
1193 SetLastResult(E_SUCCESS);
1199 TextObject::AppendElement(TextElement& textElement)
1201 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1203 result r = E_SUCCESS;
1204 TextElementType objecType = textElement.GetType();
1205 if (objecType == TEXT_ELEMENT_TYPE_CUTLINK)
1207 TextCutLink* pLinkText = dynamic_cast < TextCutLink* >(&textElement);
1208 if (pLinkText != null)
1210 switch (pLinkText->GetCutLinkType())
1213 if (__isUrlLinkColorDefined)
1215 pLinkText->SetUserColor(__linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_URL_NORMAL], __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_URL_SELECT]);
1219 case LINK_TYPE_EMAIL:
1220 if (__isEmailLinkColorDefined)
1222 pLinkText->SetUserColor(__linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_EMAIL_NORMAL], __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_EMAIL_SELECT]);
1226 case LINK_TYPE_TEL_NUM:
1227 if (__isPhoneNumberLinkColorDefined)
1229 pLinkText->SetUserColor(__linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_PHONE_NUMBER_NORMAL],
1230 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_PHONE_NUMBER_SELECT]);
1240 int textIndex = __pCompositeText->GetTextLength();
1241 int elementTextLength = textElement.GetTextLength();
1243 r = __pCompositeText->AppendElement(textElement);
1244 SysTryReturn(NID_GRP
1246 , r, r, "[%s] Propagating.", GetErrorMessage(r));
1248 int elementCount = __pCompositeText->GetElementCount();
1249 if (elementCount > 0)
1251 __pCompositeText->Optimize(elementCount-1, elementCount-1);
1254 if (__wrap == TEXT_OBJECT_WRAP_TYPE_NONE)
1256 UpdateChangedInfo(0, 0);
1260 NotifyTextAdded(textIndex, elementTextLength);
1267 TextObject::InsertElementAt(int textIndex, TextElement& textElement)
1269 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1271 result r = E_SUCCESS;
1272 TextElementType objecType = textElement.GetType();
1274 if (objecType == TEXT_ELEMENT_TYPE_CUTLINK)
1276 TextCutLink* pLinkText = dynamic_cast < TextCutLink* >(&textElement);
1277 if (pLinkText != null)
1279 switch (pLinkText->GetCutLinkType())
1282 if (__isUrlLinkColorDefined)
1284 pLinkText->SetUserColor(__linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_URL_NORMAL],
1285 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_URL_SELECT]);
1289 case LINK_TYPE_EMAIL:
1290 if (__isEmailLinkColorDefined)
1292 pLinkText->SetUserColor(__linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_EMAIL_NORMAL],
1293 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_EMAIL_SELECT]);
1297 case LINK_TYPE_TEL_NUM:
1298 if (__isPhoneNumberLinkColorDefined)
1300 pLinkText->SetUserColor(__linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_PHONE_NUMBER_NORMAL],
1301 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_PHONE_NUMBER_SELECT]);
1311 r = __pCompositeText->InsertElementAt(textElement, textIndex);
1312 SysTryReturn(NID_GRP
1314 , r, r, "[%s] Fail to insert element.", GetErrorMessage(r));
1316 int elementIndex = __pCompositeText->GetElementIndexOf(textElement);
1317 if (elementIndex != -1)
1319 __pCompositeText->Optimize(elementIndex, elementIndex);
1322 if (__wrap == TEXT_OBJECT_WRAP_TYPE_NONE)
1324 UpdateChangedInfo(0, 0);
1328 NotifyTextAdded(textIndex, textElement.GetTextLength());
1335 TextObject::RemoveAll(bool deallocate)
1337 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1339 result r = __pTextColumn->RemoveAllLines();
1340 SysTryReturn(NID_GRP
1342 , r, r, "[%s] Propagating.", GetErrorMessage(r));
1344 r = __pCompositeText->RemoveAllElements(deallocate);
1345 SysTryReturn(NID_GRP
1347 , r, r, "[%s] Propagating.", GetErrorMessage(r));
1349 UpdateChangedInfo(0);
1351 __isActionOn = false;
1357 TextObject::RemoveElement(TextElement& textElement, bool deallocate)
1359 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1361 result r = E_SUCCESS;
1362 int elementIndex = 0;
1364 int elementTextLength = 0;
1365 TextElement* pCurrentTextElement = null;
1367 elementIndex = __pCompositeText->GetElementIndexOf(textElement);
1368 SysTryReturn(NID_GRP
1370 , E_INVALID_ARG, E_INVALID_ARG, "[E_SYSTEM] The argument is invalid.");
1372 for (int i = 0; i < elementIndex; i++)
1374 pCurrentTextElement = __pCompositeText->GetElementAtElementIndex(i);
1375 if (pCurrentTextElement != null)
1377 textIndex += pCurrentTextElement->GetTextLength();
1381 elementTextLength = textElement.GetTextLength();
1383 r = __pCompositeText->RemoveElementAt(elementIndex, deallocate);
1384 SysTryReturn(NID_GRP
1386 , r, r, "[%s] Propagating.", GetErrorMessage(r));
1388 NotifyTextDeleted(textIndex, elementTextLength);
1390 if (__pCompositeText->GetElementCount() == 0 || GetTextLength() == 0)
1392 __pTextColumn->RemoveAllLines();
1399 TextObject::GetElementAtTextIndex(int textIndex) const
1401 IF_NOT_CONSTRUCTED(return null);
1403 TextElement* pTextElement = null;
1404 int elementTextLength = 0;
1405 int textIndexFromElementOffset = 0;
1406 int elementIndex = 0;
1407 int elementOffset = 0;
1409 pTextElement = __pCompositeText->GetElementAtTextIndex(textIndex, elementOffset, elementIndex, elementTextLength,
1410 textIndexFromElementOffset);
1413 , , E_SYSTEM, "[E_SYSTEM] Fail to get text element.");
1415 SetLastResult(E_SUCCESS);
1416 return pTextElement;
1425 TextObject::SetFont(Font* pFont, int startTextIndex, int textLength)
1427 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1429 SysTryReturn(NID_GRP
1431 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1433 SysTryReturn(NID_GRP
1434 , startTextIndex >= 0
1435 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1437 result r = E_SUCCESS;
1438 Font* pTmpFont = null;
1440 pTmpFont = _FontImpl::CloneN(const_cast < Font& >(*pFont));
1441 r = GetLastResult();
1442 SysTryReturn(NID_GRP
1444 , r, r, "[%s] Propagating.", GetErrorMessage(r));
1448 delete __pDefaultFont;
1449 __pDefaultFont = null;
1451 __pDefaultFont = pTmpFont;
1453 __pCompositeText->SetRange(startTextIndex, textLength);
1454 r = __pCompositeText->SetFont(pFont);
1455 SysTryReturn(NID_GRP
1457 , r, r, "[%s] Propagating.", GetErrorMessage(r));
1459 UpdateChangedInfo(__pCompositeText->GetWorkStart(), 0);
1465 TextObject::GetFont(int textIndex) const
1467 IF_NOT_CONSTRUCTED(return null);
1469 Font* pFont = __pCompositeText->GetFont(textIndex);
1472 pFont = __pDefaultFont;
1475 SetLastResult(E_SUCCESS);
1480 TextObject::SetForegroundColor(const Color& color, int startTextIndex, int textLength)
1482 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1484 SysTryReturn(NID_GRP
1485 , startTextIndex >= 0
1486 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1488 __defaultForegroundColor = color;
1490 __pCompositeText->SetRange(startTextIndex, textLength);
1491 __pCompositeText->SetForegroundColor(color);
1497 TextObject::GetForegroundColor(int textIndex) const
1499 IF_NOT_CONSTRUCTED(return Color::GetColor(COLOR_ID_BLACK));
1501 SysTryReturn(NID_GRP
1503 , __defaultForegroundColor, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1505 return __pCompositeText->GetForegroundColor(textIndex);
1509 TextObject::SetBackgroundColor(const Color& color, int startTextIndex, int textLength)
1511 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1513 SysTryReturn(NID_GRP
1514 , startTextIndex >= 0
1515 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1517 __defaultBackgroundColor = color;
1519 __pCompositeText->SetRange(startTextIndex, textLength);
1520 __pCompositeText->SetBackgroundColor(color);
1526 TextObject::GetBackgroundColor(int textIndex) const
1528 IF_NOT_CONSTRUCTED(return Color::GetColor(COLOR_ID_BLACK));
1530 SysTryReturn(NID_GRP
1532 , __defaultBackgroundColor, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1534 return __pCompositeText->GetBackgroundColor(textIndex);
1538 TextObject::SetOutlineColor(const Color& color, int startTextIndex, int textLength)
1540 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1542 SysTryReturn(NID_GRP
1543 , startTextIndex >= 0
1544 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1546 __defaultOutlineColor = color;
1548 __pCompositeText->SetRange(startTextIndex, textLength);
1549 __pCompositeText->SetOutlineColor(color);
1555 TextObject::GetOutlineColor(int textIndex) const
1557 IF_NOT_CONSTRUCTED(return Color::GetColor(COLOR_ID_BLACK));
1559 SysTryReturn(NID_GRP
1561 , __defaultOutlineColor, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
1563 return __pCompositeText->GetOutlineColor(textIndex);
1567 TextObject::SetBlockColor(const Color& color)
1569 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1571 __pCompositeText->SetBlockColor(color);
1577 TextObject::GetBlockColor(void) const
1579 IF_NOT_CONSTRUCTED(return Color::GetColor(COLOR_ID_BLACK));
1581 return __pCompositeText->GetBlockColor();
1585 TextObject::SetWrap(TextObjectWrapType wrap)
1587 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1589 result r = E_SUCCESS;
1596 r = __pCompositeText->SetWrap(wrap);
1597 SysTryReturn(NID_GRP
1599 , r, r, "[%s] Propagating.", GetErrorMessage(r));
1602 UpdateChangedInfo(0, 0);
1608 TextObject::InsertElementAt(int textIndex, Bitmap& bitmap, TextElementSourceType sourceType)
1610 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1612 TextImage* pImageText = null;
1613 int addedTextLength = 0;
1614 int startTextIndex = 0;
1616 pImageText = new (std::nothrow)TextImage(bitmap, sourceType, null, (TextObjectAlignment)(TEXT_OBJECT_ALIGNMENT_LEFT | TEXT_OBJECT_ALIGNMENT_TOP));
1617 SysTryReturn(NID_GRP
1619 , E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
1621 addedTextLength = pImageText->GetTextLength();
1622 __pCompositeText->InsertElementAt(*pImageText, textIndex);
1623 startTextIndex = __pCompositeText->GetWorkStart();
1624 NotifyTextAdded(startTextIndex, addedTextLength);
1630 TextObject::AppendElement(Bitmap& bitmap, TextElementSourceType sourceType)
1632 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1634 result r = E_SUCCESS;
1635 TextImage* pImageText = null;
1637 pImageText = new (std::nothrow)TextImage(bitmap, sourceType, null, (TextObjectAlignment)(TEXT_OBJECT_ALIGNMENT_LEFT | TEXT_OBJECT_ALIGNMENT_TOP));
1638 SysTryReturn(NID_GRP
1640 , E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
1642 r = __pCompositeText->AppendElement(*pImageText);
1643 SysTryReturn(NID_GRP
1645 , r, r, "[%s] Propagating.", GetErrorMessage(r));
1647 int startTextIndex = __pCompositeText->GetWorkStart();
1648 int elementTextLength = pImageText->GetTextLength();
1650 NotifyTextAdded(startTextIndex, elementTextLength);
1656 TextObject::SetAlternateLookEnabled(bool enable)
1658 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1660 int elementCount = 0;
1661 TextElement* pTextElement = null;
1663 __isAlternateLookEnabled = enable;
1664 elementCount = __pCompositeText->GetElementCount();
1666 for (int i = 0; i < elementCount; i++)
1668 pTextElement = __pCompositeText->GetElementAtElementIndex(i);
1669 if (pTextElement != null)
1671 pTextElement->SetAlternateLookEnabled(enable);
1679 TextObject::SetAlternativeForegroundColor(const Color& color)
1681 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1683 int elementCount = 0;
1684 TextElement* pTextElement = null;
1686 elementCount = __pCompositeText->GetElementCount();
1688 for (int i = 0; i < elementCount; i++)
1690 pTextElement = __pCompositeText->GetElementAtElementIndex(i);
1691 SysTryReturn(NID_GRP
1693 , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get text element.");
1695 pTextElement->SetAlternativeForegroundColor(color);
1702 TextObject::ChangeTextOffset(wchar_t* pText, int textIndex, int gap)
1704 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1706 result r = E_SUCCESS;
1707 int elementStartTextIndex = 0;
1708 int elementIndex = 0;
1709 int elementTextLength = 0;
1710 int textIndexFromElementOffset = 0;
1712 TextElement* pTextElement = __pCompositeText->GetElementAtTextIndex(textIndex, elementStartTextIndex,
1713 elementIndex, elementTextLength, textIndexFromElementOffset);
1715 SysTryReturn(NID_GRP
1717 , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get text element.");
1719 r = __pCompositeText->ChangeTextOffset(pText, elementIndex, gap);
1720 SysTryReturn(NID_GRP
1722 , r, r, "[%s] Propagating.", GetErrorMessage(r));
1728 TextObject::NotifyTextChanged(wchar_t* pText, int textOffset, int textLength, int gap)
1730 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1732 result r = E_SUCCESS;
1733 int startTextIndex = 0;
1735 r = __pCompositeText->NotifyTextChanged(pText, textOffset, textLength, gap, __pDefaultFont,
1736 __defaultForegroundColor, __defaultBackgroundColor, __defaultOutlineColor);
1740 , , E_SYSTEM, "[E_SYSTEM] Fail to update change information.");
1742 startTextIndex = __pCompositeText->GetWorkStart();
1744 if (__wrap != TEXT_OBJECT_WRAP_TYPE_NONE)
1748 NotifyTextAdded(startTextIndex, gap);
1751 InputText(startTextIndex);
1756 NotifyTextDeleted(startTextIndex, -gap);
1760 RemoveText(startTextIndex);
1765 UpdateChangedInfo(startTextIndex, 0);
1767 ChangeText(startTextIndex);
1772 UpdateChangedInfo(startTextIndex, 0);
1778 if (__pCompositeText->GetElementCount() == 0)
1781 TextSimple* pSimpleText = new (std::nothrow)TextSimple(pText, textLength, TEXT_ELEMENT_SOURCE_TYPE_EXTERNAL);
1782 AppendElement(*pSimpleText);
1785 UpdateChangedInfo(0, 0);
1792 TextObject::GetTextIndexFromPosition(int lcX, int lcY, bool cursorMode) const
1794 IF_NOT_CONSTRUCTED(return -1);
1796 int lineCount = __pTextColumn->GetTotalLineCount();
1802 int pcX = _ResUtil::ConvertToPhyCoord(lcX);
1803 int pcY = _ResUtil::ConvertToPhyCoord(lcY);
1805 if (__wrap == TEXT_OBJECT_WRAP_TYPE_NONE)
1807 return GetTextIndexFromPositionInNoneWrap(pcX, pcY, !cursorMode);
1811 return GetTextIndexFromPositionInWrap(pcX, pcY, !cursorMode);
1816 TextObject::GetTextIndexFromPositionAtLine(int lineIndex, int lcX, bool cursorMode) const
1818 IF_NOT_CONSTRUCTED(return -1);
1820 SysTryReturn(NID_GRP
1822 , -1, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid. (lineIndex = %d)", lineIndex);
1824 TextLine* pTextLine = __pTextColumn->GetTextLine(lineIndex);
1825 SysTryReturn(NID_GRP
1827 , -1, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
1829 int pcX = _ResUtil::ConvertToPhyCoord(lcX);
1830 int lineOffset = pTextLine->GetTextOffset();
1831 int lineLength = pTextLine->GetTextLength();
1833 TextElementType objectType;
1834 Rectangle lineBounds = pTextLine->GetBounds();
1835 Dimension lineTextSize;
1836 pTextLine->GetRegion(0, lineLength, lineTextSize.width, lineTextSize.height);
1838 switch (__align & TEXT_ALIGNMASK_HORIZ)
1840 case TEXT_OBJECT_ALIGNMENT_LEFT:
1843 case TEXT_OBJECT_ALIGNMENT_CENTER:
1844 pcX -= (lineBounds.width - lineTextSize.width) / 2;
1847 case TEXT_OBJECT_ALIGNMENT_RIGHT:
1848 pcX -= (lineBounds.width - lineTextSize.width);
1857 __pCompositeText->SetWrap(TEXT_OBJECT_WRAP_TYPE_NONE);
1863 __pCompositeText->ForwardAnalyzeWithFocusedObjectType(lineOffset, lineLength, pcX, length, objectType);
1867 endType = __pCompositeText->ForwardAnalyzeInNoneCursorMode(lineOffset, lineLength, pcX, length);
1870 __pCompositeText->SetWrap(__wrap);
1880 int index = pTextLine->GetTextOffset() + length;
1881 if (pTextLine->GetEndType() == TEXT_RETBY_LINEFEED && lineLength == length && pTextLine->GetTextOffset() < index)
1886 if (index != GetTextLength() && index == lineOffset + lineLength)
1888 TextElement* pTextElement = GetElementAtTextIndex(index-1);
1889 if (pTextElement != null)
1891 const TextSimple* pSimpleText = dynamic_cast <const TextSimple*>(pTextElement);
1892 if (pSimpleText != null)
1894 const wchar_t* pText = pSimpleText->GetText();
1895 SysTryReturn(NID_GRP
1897 , -1, E_SYSTEM, "[E_SYSTEM] Fail to get text.");
1899 int i = index - 1 - pSimpleText->GetTextOffset();
1900 SysTryReturn(NID_GRP
1901 , i >= 0 && i < pSimpleText->GetTextLength()
1902 , -1, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] text index(%d) must greater than 0 and must be less than total string length(%d)",i, pSimpleText->GetTextLength());
1904 if (pText[i] == L' ')
1912 SetLastResult(E_SUCCESS);
1918 TextObject::SetFirstDisplayLineIndexFromTextIndex(int textIndex)
1920 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1922 if (__wrap == TEXT_OBJECT_WRAP_TYPE_NONE)
1924 return SetFirstDisplayLineIndexFromTextIndexInNoneWrap(textIndex);
1928 return SetFirstDisplayLineIndexFromTextIndexInWrap(textIndex);
1933 TextObject::SetCutLinkViewMode(bool enable)
1935 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
1937 if (__linkViewModeEnabled == enable)
1942 __linkViewModeEnabled = enable;
1947 TextObject::GetCutLinkIndexFromPositionData(int lcX, int lcY) const
1949 IF_NOT_CONSTRUCTED(return -1);
1951 result r = E_SUCCESS;
1952 int lineCount = __pTextColumn->GetTotalLineCount();
1959 int pcX = _ResUtil::ConvertToPhyCoord(lcX);
1960 int pcY = _ResUtil::ConvertToPhyCoord(lcY);
1962 if (__wrap == TEXT_OBJECT_WRAP_TYPE_NONE)
1964 textIndex = GetTextIndexFromPositionInNoneWrap(pcX, pcY, false);
1968 textIndex = GetTextIndexFromPositionInWrap(pcX, pcY, false);
1980 if (__wrap == TEXT_OBJECT_WRAP_TYPE_NONE)
1982 r = GetTextPositionInfoInNoneWrapAt(textIndex, width, height, absPoint.x, absPoint.y, relPoint.x, relPoint.y);
1986 r = GetTextPositionInfoInWrapAt(textIndex, width, height, absPoint.x, absPoint.y, relPoint.x, relPoint.y);
1988 SysTryReturn(NID_GRP
1990 , -1, r, "[%s] Propagating.", GetErrorMessage(r));
1992 SysTryReturn(NID_GRP
1993 , pcY + __pcRect.y >= relPoint.y
1994 , -1, E_SYSTEM, "[E_SYSTEM] Fail to get text position information");
1996 return __pCompositeText->GetCutLinkElementIndexAt(textIndex);
2000 TextObject::GetCutLinkElementAtCutLinkElementIndex(int linkIndex) const
2002 IF_NOT_CONSTRUCTED(return null);
2004 return __pCompositeText->GetCutLinkElementAtCutLinkElementIndex(linkIndex);
2008 TextObject::SetCutLinkColor(LinkType linkType, const Color& color, const Color& colorInSelect)
2010 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
2012 SysTryReturn(NID_GRP
2013 , LINK_TYPE_NONE < linkType && linkType < LINK_TYPE_MAX
2014 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
2019 __isUrlLinkColorDefined = true;
2020 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_URL_NORMAL] = color;
2021 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_URL_SELECT] = colorInSelect;
2024 case LINK_TYPE_EMAIL:
2025 __isEmailLinkColorDefined = true;
2026 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_EMAIL_NORMAL] = color;
2027 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_EMAIL_SELECT] = colorInSelect;
2030 case LINK_TYPE_TEL_NUM:
2031 __isPhoneNumberLinkColorDefined = true;
2032 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_PHONE_NUMBER_NORMAL] = color;
2033 __linkColor[TEXT_OBJECT_LINK_COLOR_TYPE_PHONE_NUMBER_SELECT] = colorInSelect;
2040 int totalCutlinkTextCount = __pCompositeText->GetCutLinkElementCount();
2041 for (int i = 0; i < totalCutlinkTextCount; i++)
2043 TextCutLink* pCutlinkText = dynamic_cast < TextCutLink* >(__pCompositeText->GetCutLinkElementAtCutLinkElementIndex(i));
2044 SysTryReturn(NID_GRP
2046 , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to convert to cutlink element.");
2048 if (pCutlinkText->GetCutLinkType() == linkType)
2050 pCutlinkText->SetUserColor(color, colorInSelect);
2058 TextObject::ResetCutLinkColor(LinkType linkType)
2060 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
2062 SysTryReturn(NID_GRP
2063 , LINK_TYPE_NONE < linkType && linkType < LINK_TYPE_MAX
2064 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
2069 __isUrlLinkColorDefined = false;
2072 case LINK_TYPE_EMAIL:
2073 __isEmailLinkColorDefined = false;
2076 case LINK_TYPE_TEL_NUM:
2077 __isPhoneNumberLinkColorDefined = false;
2084 int totalCutlinkTextCount = __pCompositeText->GetCutLinkElementCount();
2085 for (int i = 0; i < totalCutlinkTextCount; i++)
2087 TextCutLink* pCutlinkText = dynamic_cast < TextCutLink* >(__pCompositeText->GetCutLinkElementAtCutLinkElementIndex(i));
2088 SysTryReturn(NID_GRP
2090 , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to convert to cutlink element.");
2092 if (pCutlinkText->GetCutLinkType() == linkType)
2094 pCutlinkText->ResetUserColor();
2102 TextObject::GetCutLinkBounds(int cutLinkIndex, Point& startPoint, Point& endPoint) const
2104 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
2106 result r = E_SUCCESS;
2113 r = __pCompositeText->GetCutLinkObjectInfo(cutLinkIndex, textIndex, textLength);
2116 , , r, "[%s] Propagating.", GetErrorMessage(r));
2118 if (__wrap == TEXT_OBJECT_WRAP_TYPE_NONE)
2120 r = GetTextPositionInfoInNoneWrapAt(textIndex, width, heigth, tempPoint.x, tempPoint.y, startPoint.x, startPoint.y);
2123 , , r, "[%s] Propagating.", GetErrorMessage(r));
2125 r = GetTextPositionInfoInNoneWrapAt(textIndex + textLength - 1, width, heigth, tempPoint.x, tempPoint.y, endPoint.x, endPoint.y);
2128 , , r, "[%s] Propagating.", GetErrorMessage(r));
2132 r = GetTextPositionInfoInWrapAt(textIndex, width, heigth, tempPoint.x, tempPoint.y, startPoint.x, startPoint.y);
2135 , , r, "[%s] Propagating.", GetErrorMessage(r));
2137 r = GetTextPositionInfoInWrapAt(textIndex + textLength - 1, width, heigth, tempPoint.x, tempPoint.y, endPoint.x, endPoint.y);
2140 , , r, "[%s] Propagating.", GetErrorMessage(r));
2143 endPoint.x = endPoint.x + width;
2144 endPoint.y = endPoint.y + heigth;
2146 if (_ResUtil::NeedToConvertCoord())
2148 startPoint.x = _ResUtil::ConvertToVirCoord(startPoint.x);
2149 startPoint.y = _ResUtil::ConvertToVirCoord(startPoint.y);
2150 endPoint.x = _ResUtil::ConvertToVirCoord(endPoint.x);
2151 endPoint.y = _ResUtil::ConvertToVirCoord(endPoint.y);
2166 TextObject::GetTextPositionInfoAt(int textIndex, int& width, int& height, int& absX, int& absY, int& logicalX, int& logicalY) const
2168 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
2170 result r = E_SUCCESS;
2171 int lineCount = __pTextColumn->GetTotalLineCount();
2175 _Font* pFont = _Font::GetInstance(*_FontImpl::GetInstance(*__pDefaultFont));
2176 SysTryReturn(NID_GRP
2178 , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get native font instance.");
2179 int maxHeight = TextUtility::GetFontMaxHeight(pFont);
2186 if (__wrap == TEXT_OBJECT_WRAP_TYPE_NONE)
2188 switch (__align & TEXT_ALIGNMASK_VERT)
2190 case TEXT_OBJECT_ALIGNMENT_TOP:
2193 case TEXT_OBJECT_ALIGNMENT_MIDDLE:
2194 posY += (__pcRect.height - maxHeight) / 2;
2197 case TEXT_OBJECT_ALIGNMENT_BOTTOM:
2198 posY += (__pcRect.height - maxHeight);
2201 logicalY = __pcRect.y + posY;
2203 switch (__align & TEXT_ALIGNMASK_HORIZ)
2205 case TEXT_OBJECT_ALIGNMENT_LEFT:
2208 case TEXT_OBJECT_ALIGNMENT_CENTER:
2209 posX += __pcRect.width / 2;
2212 case TEXT_OBJECT_ALIGNMENT_RIGHT:
2213 posX += __pcRect.width;
2216 logicalX = __pcRect.x + posX;
2220 int lineHeight = maxHeight + __pCompositeText->GetLineSpace();
2221 TextObjectAlignment alignment = __pCompositeText->GetElementVerticalAlignment();
2222 switch (alignment & TEXT_ALIGNMASK_VERT)
2224 case TEXT_OBJECT_ALIGNMENT_TOP:
2229 case TEXT_OBJECT_ALIGNMENT_MIDDLE:
2230 posY += (lineHeight - maxHeight) / 2;
2233 case TEXT_OBJECT_ALIGNMENT_BOTTOM:
2234 posY += lineHeight - maxHeight;
2238 logicalX = __pcRect.x;
2239 logicalY = posY + __pcRect.y;
2249 if (__wrap == TEXT_OBJECT_WRAP_TYPE_NONE)
2251 r = GetTextPositionInfoInNoneWrapAt(textIndex, width, height, absX, absY, logicalX, logicalY);
2255 r = GetTextPositionInfoInWrapAt(textIndex, width, height, absX, absY, logicalX, logicalY);
2258 SysTryReturn(NID_GRP
2260 , r, r, "[%s] Propagating.", GetErrorMessage(r));
2263 if (_ResUtil::NeedToConvertCoord())
2265 width = _ResUtil::ConvertToVirCoord(width);
2266 height = _ResUtil::ConvertToVirCoord(height);
2267 absX = _ResUtil::ConvertToVirCoord(absX);
2268 absY = _ResUtil::ConvertToVirCoord(absY);
2269 logicalX = _ResUtil::ConvertToVirCoord(logicalX);
2270 logicalY = _ResUtil::ConvertToVirCoord(logicalY);
2277 TextObject::SetTextObjectEllipsisType(TextObjectEllipsisType type)
2279 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
2281 SysTryReturn(NID_GRP
2282 , TEXT_OBJECT_ELLIPSIS_TYPE_INVALID < type && type < TEXT_OBJECT_ELLIPSIS_TYPE_MAX
2283 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
2285 __textObjectEllipsisType = type;
2286 __pCompositeText->SetTextObjectEllipsisType(type);
2292 TextObject::NotifyTextAdded(int textIndex, int textLength)
2294 result r = E_SUCCESS;
2296 r = __pTextColumn->SetChangeAction(TextColumn::TEXT_CHANGE_INSERT, textIndex, textLength);
2297 SysTryReturn(NID_GRP
2299 , r, r, "[%s] Propagating.", GetErrorMessage(r));
2301 if ((__pCompositeText->IsWidthManagerEnabled() == true) && (__wrap == TEXT_OBJECT_WRAP_TYPE_WORD))
2303 __pTextWidthManager->InformTextInsert(textIndex, textLength);
2312 TextObject::NotifyTextDeleted(int textIndex, int textLength)
2314 result r = E_SUCCESS;
2316 r = __pTextColumn->SetChangeAction(TextColumn::TEXT_CHANGE_REMOVE, textIndex, textLength);
2317 SysTryReturn(NID_GRP
2319 , r, r, "[%s] Propagating.", GetErrorMessage(r));
2321 if ((__pCompositeText->IsWidthManagerEnabled() == true) && (__wrap == TEXT_OBJECT_WRAP_TYPE_WORD))
2323 if (__wrap == TEXT_OBJECT_WRAP_TYPE_WORD)
2325 __pTextWidthManager->InformTextRemove(textIndex, textLength);
2334 TextObject::DrawByLine(_CanvasImpl& canvasImpl, const Rectangle& displayRect)
2336 Rectangle targetBounds = displayRect;
2338 return __pTextColumn->Draw(canvasImpl, targetBounds, 0, __pTextColumn->GetTextLength(), __align, __action);
2342 TextObject::GetTextIndexFromPositionInWrap(int pcX, int pcY, bool cursorMode) const
2344 TextLine* pTextLine = null;
2345 Rectangle lineBounds;
2346 int firstDisplayLineIndex = __pTextColumn->GetFirstDisplayLineIndex();
2347 int firstDisplayPositionY = __pTextColumn->GetFirstDisplayPositionY();
2348 int lineCount = __pTextColumn->GetTotalLineCount();
2350 TextElementType objectType;
2352 int totalHeight = __pTextColumn->GetTotalHeight();
2354 switch (__align & TEXT_ALIGNMASK_VERT)
2356 case TEXT_OBJECT_ALIGNMENT_TOP:
2359 case TEXT_OBJECT_ALIGNMENT_MIDDLE:
2360 pcY -= (__pcRect.height - totalHeight) / 2;
2363 case TEXT_OBJECT_ALIGNMENT_BOTTOM:
2364 pcY -= (__pcRect.height - totalHeight);
2368 for (lineIndex = firstDisplayLineIndex; lineIndex < lineCount; lineIndex++)
2370 pTextLine = __pTextColumn->GetTextLine(lineIndex);
2371 SysTryReturn(NID_GRP
2373 , -1, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
2375 lineBounds = pTextLine->GetBounds();
2377 if (lineIndex == firstDisplayLineIndex)
2379 if (pcY < lineBounds.y - firstDisplayPositionY)
2385 if ((lineBounds.y - firstDisplayPositionY <= pcY) && (pcY < lineBounds.y + lineBounds.height - firstDisplayPositionY))
2390 if (lineIndex == lineCount - 1)
2394 return pTextLine->GetTextLength() + pTextLine->GetTextOffset();
2403 SysTryReturn(NID_GRP
2405 , -1, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
2407 int lineOffset = pTextLine->GetTextOffset();
2408 int lineLength = pTextLine->GetTextLength();
2410 Dimension lineTextSize;
2411 pTextLine->GetRegion(0, lineLength, lineTextSize.width, lineTextSize.height);
2413 switch (__align & TEXT_ALIGNMASK_HORIZ)
2415 case TEXT_OBJECT_ALIGNMENT_LEFT:
2418 case TEXT_OBJECT_ALIGNMENT_CENTER:
2419 pcX -= (lineBounds.width - lineTextSize.width) / 2;
2422 case TEXT_OBJECT_ALIGNMENT_RIGHT:
2423 pcX -= (lineBounds.width - lineTextSize.width);
2432 __pCompositeText->SetWrap(TEXT_OBJECT_WRAP_TYPE_NONE);
2438 __pCompositeText->ForwardAnalyzeWithFocusedObjectType(lineOffset, lineLength, pcX, length, objectType);
2442 endType = __pCompositeText->ForwardAnalyzeInNoneCursorMode(lineOffset, lineLength, pcX, length);
2445 __pCompositeText->SetWrap(__wrap);
2455 int index = pTextLine->GetTextOffset() + length;
2456 if (pTextLine->GetEndType() == TEXT_RETBY_LINEFEED && lineLength == length && pTextLine->GetTextOffset() < index)
2461 if (index != GetTextLength() && index == lineOffset + lineLength)
2463 TextElement* pTextElement = GetElementAtTextIndex(index-1);
2464 if (pTextElement != null)
2466 const TextSimple* pSimpleText = dynamic_cast <const TextSimple*>(pTextElement);
2467 if (pSimpleText != null)
2469 const wchar_t* pText = pSimpleText->GetText();
2470 SysTryReturn(NID_GRP
2472 , -1, E_SYSTEM, "[E_SYSTEM] Fail to get text.");
2474 int i = index - 1 - pSimpleText->GetTextOffset();
2475 SysTryReturn(NID_GRP
2476 , i >= 0 && i < pSimpleText->GetTextLength()
2477 , -1, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] text index(%d) must greater than 0 and must be less than total string length(%d)",i, pSimpleText->GetTextLength());
2479 if (pText[i] == L' ')
2487 SetLastResult(E_SUCCESS);
2493 TextObject::GetTextIndexFromPositionInNoneWrap(int x, int y, bool cursorMode) const
2495 Dimension lineTextSize;
2496 Rectangle lineBounds;
2499 TextLine* pTextLine = null;
2501 pTextLine = __pTextColumn->GetTextLine(0);
2502 SysTryReturn(NID_GRP
2504 , -1, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
2506 lineOffset = pTextLine->GetTextOffset();
2507 lineLength = pTextLine->GetTextLength();
2508 lineBounds = pTextLine->GetBounds();
2509 pTextLine->GetRegion(0, lineLength, lineTextSize.width, lineTextSize.height);
2511 switch (__align & TEXT_ALIGNMASK_HORIZ)
2513 case TEXT_OBJECT_ALIGNMENT_LEFT:
2516 case TEXT_OBJECT_ALIGNMENT_CENTER:
2517 x -= (lineBounds.width - lineTextSize.width) / 2;
2520 case TEXT_OBJECT_ALIGNMENT_RIGHT:
2521 x -= (lineBounds.width - lineTextSize.width);
2525 switch (__align & TEXT_ALIGNMASK_VERT)
2527 case TEXT_OBJECT_ALIGNMENT_TOP:
2530 case TEXT_OBJECT_ALIGNMENT_MIDDLE:
2531 y -= (__pcRect.height - lineTextSize.height) / 2;
2534 case TEXT_OBJECT_ALIGNMENT_BOTTOM:
2535 y -= (__pcRect.height - lineTextSize.height);
2545 TextElementType objectType = TEXT_ELEMENT_TYPE_TEXT;
2551 __pCompositeText->ForwardAnalyzeWithFocusedObjectType(lineOffset, lineLength, x, length, objectType);
2555 endType = __pCompositeText->ForwardAnalyzeInNoneCursorMode(lineOffset, lineLength, x, length);
2566 lineOffset = length + pTextLine->GetTextOffset();
2568 SetLastResult(E_SUCCESS);
2573 TextObject::SetFirstDisplayLineIndexFromTextIndexInWrap(int textIndex)
2575 result r = E_SUCCESS;
2576 Rectangle lineBounds;
2577 int firstDisplayPositionY = 0;
2578 int currentTextIndex = textIndex;
2579 int firstDisplayLineIndex = 0;
2582 int remainingHeight = 0;
2583 TextLine* pTextLine = null;
2584 bool isChanged = false;
2586 lineCount = __pTextColumn->GetTotalLineCount();
2587 lineIndex = __pTextColumn->GetLineIndexAtTextIndex(currentTextIndex);
2588 firstDisplayLineIndex = __pTextColumn->GetFirstDisplayLineIndex();
2590 if (lineIndex == -1 && 0 < currentTextIndex && currentTextIndex == __pCompositeText->GetTextLength())
2593 lineIndex = __pTextColumn->GetLineIndexAtTextIndex(currentTextIndex);
2596 pTextLine = __pTextColumn->GetTextLine(lineIndex);
2597 SysTryReturn(NID_GRP
2599 , r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
2601 lineBounds = pTextLine->GetBounds();
2603 if (firstDisplayLineIndex < lineIndex)
2605 TextLine* pTextLine = null;
2606 int currentLineIndex = 0;
2607 int displayLineCount = 0;
2609 currentLineIndex = firstDisplayLineIndex;
2610 pTextLine = __pTextColumn->GetTextLine(currentLineIndex);
2611 SysTryReturn(NID_GRP
2613 , r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
2615 remainingHeight = __pcRect.height;
2617 while ((remainingHeight != 0) && firstDisplayLineIndex < lineCount)
2619 if (remainingHeight < 0)
2624 lineBounds = pTextLine->GetBounds();
2626 remainingHeight -= lineBounds.height;
2631 pTextLine = __pTextColumn->GetTextLine(currentLineIndex);
2632 if (pTextLine == null)
2638 if (lineIndex < firstDisplayLineIndex + displayLineCount)
2640 if (0 < remainingHeight && 0 < firstDisplayLineIndex)
2642 pTextLine = __pTextColumn->GetTextLine(firstDisplayLineIndex - 1);
2643 SysTryReturn(NID_GRP
2645 , r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
2647 while (remainingHeight && pTextLine)
2649 lineBounds = pTextLine->GetBounds();
2650 remainingHeight -= lineBounds.height;
2652 if (remainingHeight < 0)
2654 firstDisplayPositionY = lineBounds.y + remainingHeight;
2656 firstDisplayLineIndex--;
2661 firstDisplayPositionY = lineBounds.y;
2665 firstDisplayLineIndex--;
2667 pTextLine = __pTextColumn->GetTextLine(firstDisplayLineIndex - 1);
2672 else if (remainingHeight < 0 && (lineIndex == firstDisplayLineIndex + displayLineCount - 1))
2674 pTextLine = __pTextColumn->GetTextLine(lineIndex);
2675 SysTryReturn(NID_GRP
2677 , r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
2679 lineBounds = pTextLine->GetBounds();
2680 remainingHeight = __pcRect.height;
2682 firstDisplayLineIndex = lineIndex;
2683 firstDisplayPositionY = lineBounds.y;
2684 remainingHeight -= lineBounds.height;
2686 int currentLineIndex = lineIndex - 1;
2687 pTextLine = __pTextColumn->GetTextLine(currentLineIndex);
2689 while ((pTextLine != null) && 0 < firstDisplayLineIndex && 0 < remainingHeight)
2691 lineBounds = pTextLine->GetBounds();
2693 if (remainingHeight < lineBounds.height)
2695 firstDisplayLineIndex--;
2696 firstDisplayPositionY = lineBounds.y + (lineBounds.height - remainingHeight);
2701 remainingHeight -= lineBounds.height;
2702 firstDisplayLineIndex--;
2703 firstDisplayPositionY = lineBounds.y;
2705 pTextLine = __pTextColumn->GetTextLine(currentLineIndex);
2713 pTextLine = __pTextColumn->GetTextLine(lineIndex);
2714 SysTryReturn(NID_GRP
2716 , r = E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
2718 lineBounds = pTextLine->GetBounds();
2720 remainingHeight = __pcRect.height;
2722 firstDisplayLineIndex = lineIndex;
2723 firstDisplayPositionY = lineBounds.y;
2724 remainingHeight -= lineBounds.height;
2726 int currentLineIndex = lineIndex - 1;
2727 pTextLine = __pTextColumn->GetTextLine(currentLineIndex);
2729 while (pTextLine && 0 < firstDisplayLineIndex && 0 < remainingHeight)
2731 lineBounds = pTextLine->GetBounds();
2733 if (remainingHeight < lineBounds.height)
2735 firstDisplayLineIndex--;
2736 firstDisplayPositionY = lineBounds.y + (lineBounds.height - remainingHeight);
2741 remainingHeight -= lineBounds.height;
2742 firstDisplayLineIndex--;
2743 firstDisplayPositionY = lineBounds.y;
2745 pTextLine = __pTextColumn->GetTextLine(currentLineIndex);
2753 lineBounds = pTextLine->GetBounds();
2754 firstDisplayLineIndex = lineIndex;
2755 firstDisplayPositionY = lineBounds.y;
2759 if (isChanged == true)
2761 __pTextColumn->SetFirstDisplayLineIndex(firstDisplayLineIndex);
2762 __pTextColumn->SetFirstDisplayPositionY(firstDisplayPositionY);
2769 TextObject::SetFirstDisplayLineIndexFromTextIndexInNoneWrap(int textIndex)
2771 result r = E_SUCCESS;
2772 int currentTextIndex = textIndex;
2774 int lineEndIndex = 0;
2776 Rectangle lineBounds;
2777 Dimension lineTextSize;
2779 _Font* pFont = _Font::GetInstance(*_FontImpl::GetInstance(*__pDefaultFont));
2780 SysTryReturn(NID_GRP
2782 , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get native font instance.");
2784 TextLine* pTextLine = __pTextColumn->GetTextLine(0);
2785 SysTryReturn(NID_GRP
2787 , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
2789 lineOffset = pTextLine->GetTextOffset();
2790 lineLength = pTextLine->GetTextLength();
2791 lineEndIndex = pTextLine->GetTextOffset() + pTextLine->GetTextLength();
2793 lineBounds = pTextLine->GetBounds();
2794 pTextLine->GetRegion(0, lineLength, lineTextSize.width, lineTextSize.height);
2796 if (currentTextIndex < pTextLine->GetTextOffset() + 1)
2798 lineOffset = currentTextIndex;
2799 pTextLine->SetTextOffset(lineOffset);
2800 lineOffset = pTextLine->GetTextOffset();
2804 pTextLine->SetTextOffset(lineOffset);
2807 __pCompositeText->ForwardAnalyze(lineOffset, __pCompositeText->GetTextLength() - lineOffset, lineBounds.width,
2808 __wrap, lineLength, lineTextSize.width, lineTextSize.height);
2810 lineBounds.height = Math::Max(lineBounds.height, lineTextSize.height);
2811 if (lineBounds.height == 0)
2813 lineBounds.height = TextUtility::GetFontMaxHeight(pFont);
2816 pTextLine->SetBounds(lineBounds);
2817 pTextLine->SetRegion(lineTextSize.width, lineTextSize.height);
2818 pTextLine->SetTextLength(lineLength);
2821 else if (lineEndIndex <= currentTextIndex)
2828 r = __pCompositeText->GetRegion(lineEndIndex, currentTextIndex - lineEndIndex, gapWidth, gapHeight);
2829 SysTryReturn(NID_GRP
2831 , r, r, "[%s] Propagating.", GetErrorMessage(r));
2833 gapWidth -= lineBounds.width - lineTextSize.width;
2835 __pCompositeText->ForwardAnalyze(lineOffset, __pCompositeText->GetTextLength() - lineOffset, gapWidth, __wrap,
2836 textCount, tempWidth, gapHeight);
2838 if (tempWidth < gapWidth)
2840 lineOffset += (textCount + 1);
2844 lineOffset += textCount;
2847 __pCompositeText->ForwardAnalyze(lineOffset, __pCompositeText->GetTextLength() - lineOffset, lineBounds.width,
2848 __wrap, lineLength, lineTextSize.width, lineTextSize.height);
2850 lineBounds.height = Math::Max(lineBounds.height, lineTextSize.height);
2851 if (lineBounds.height == 0)
2853 lineBounds.height = TextUtility::GetFontMaxHeight(pFont);
2856 pTextLine->SetBounds(lineBounds);
2857 pTextLine->SetRegion(lineTextSize.width, lineTextSize.height);
2858 pTextLine->SetTextOffset(lineOffset);
2859 pTextLine->SetTextLength(lineLength);
2862 __pTextColumn->SetFirstDisplayLineIndex(0);
2863 __pTextColumn->SetFirstDisplayPositionY(0);
2869 TextObject::GetTextPositionInfoInWrapAt(int textIndex, int& width, int& height, int& absX, int& absY,
2870 int& logicalX, int& logicalY) const
2872 TextLine* pTextLine = null;
2873 Rectangle lineBounds;
2875 int firstDisplayPositionY = __pTextColumn->GetFirstDisplayPositionY();
2876 int lineCount = __pTextColumn->GetTotalLineCount();
2880 int textIndexFromLineOffset = 0;
2885 _Font* pFont = _Font::GetInstance(*_FontImpl::GetInstance(*__pDefaultFont));
2886 SysTryReturn(NID_GRP
2888 , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get native font instance.");
2890 for (lineIndex = 0; lineIndex < lineCount; lineIndex++)
2892 pTextLine = __pTextColumn->GetTextLine(lineIndex);
2893 SysTryReturn(NID_GRP
2895 , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
2897 lineBounds = pTextLine->GetBounds();
2898 lineOffset = pTextLine->GetTextOffset();
2899 lineLength = pTextLine->GetTextLength();
2901 if (lineOffset <= textIndex && textIndex < lineOffset + lineLength)
2906 if (lineIndex + 1 < lineCount)
2908 lineY += lineBounds.height;
2912 SysTryReturn(NID_GRP
2914 , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
2916 if (lineIndex == lineCount)
2918 textIndexFromLineOffset = lineLength;
2922 textIndexFromLineOffset = textIndex - lineOffset;
2925 Dimension lineTextSize;
2926 pTextLine->GetRegion(0, lineLength, lineTextSize.width, lineTextSize.height);
2928 if (lineTextSize.height == 0)
2930 lineTextSize.height = TextUtility::GetFontMaxHeight(pFont);
2933 switch (__align & TEXT_ALIGNMASK_HORIZ)
2935 case TEXT_OBJECT_ALIGNMENT_LEFT:
2938 case TEXT_OBJECT_ALIGNMENT_CENTER:
2939 posX += (lineBounds.width - lineTextSize.width) / 2;
2942 case TEXT_OBJECT_ALIGNMENT_RIGHT:
2943 posX += (lineBounds.width - lineTextSize.width);
2947 switch (__align & TEXT_ALIGNMASK_VERT)
2949 case TEXT_OBJECT_ALIGNMENT_TOP:
2952 case TEXT_OBJECT_ALIGNMENT_MIDDLE:
2953 posY += (__pcRect.height - __pTextColumn->GetDisplayHeight()) / 2;
2956 case TEXT_OBJECT_ALIGNMENT_BOTTOM:
2957 posY += (__pcRect.height - __pTextColumn->GetDisplayHeight());
2975 __pCompositeText->SetWrap(TEXT_OBJECT_WRAP_TYPE_NONE);
2977 if (0 < textIndexFromLineOffset)
2979 __pCompositeText->ForwardAnalyze(lineOffset, textIndexFromLineOffset, lineTextSize.width, TEXT_OBJECT_WRAP_TYPE_NONE,
2980 length, tempWidth, tempHeight);
2987 Font* pTextFont = __pCompositeText->GetFont(textIndex - 1);
2988 tempHeight = TextUtility::GetFontMaxHeight(pTextFont);
2991 if (lineIndex == lineCount)
2996 __pCompositeText->SetWrap(__wrap);
2998 if (tempHeight == 0)
3000 tempHeight = TextUtility::GetFontMaxHeight(pFont);
3003 TextObjectAlignment alignment = __pCompositeText->GetElementVerticalAlignment();
3004 switch (alignment & TEXT_ALIGNMASK_VERT)
3006 case TEXT_OBJECT_ALIGNMENT_TOP:
3011 case TEXT_OBJECT_ALIGNMENT_MIDDLE:
3012 lineY = lineY + (lineBounds.height - tempHeight) / 2;
3015 case TEXT_OBJECT_ALIGNMENT_BOTTOM:
3016 lineY = lineY + (lineBounds.height - tempHeight);
3021 height = tempHeight;
3024 logicalY = lineY - firstDisplayPositionY + __pcRect.y + posY;
3025 logicalX = posX + __pcRect.x;
3031 TextObject::GetTextPositionInfoInNoneWrapAt(int textIndex, int& width, int& height, int& absX, int& absY,
3032 int& logicalX, int& logicalY) const
3034 TextLine* pTextLine = null;
3035 pTextLine = __pTextColumn->GetTextLine(0);
3036 SysTryReturn(NID_GRP
3038 , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
3040 int lineOffset = pTextLine->GetTextOffset();
3041 int lineLength = pTextLine->GetTextLength();
3044 int displaposYX = 0;
3049 _Font* pFont = _Font::GetInstance(*_FontImpl::GetInstance(*__pDefaultFont));
3050 SysTryReturn(NID_GRP
3052 , E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Fail to get native font instance.");
3054 Dimension lineTextSize;
3055 Rectangle lineBounds;
3056 lineBounds = pTextLine->GetBounds();
3057 pTextLine->GetRegion(0, lineLength, lineTextSize.width, lineTextSize.height);
3059 if (lineTextSize.height == 0 || pTextLine->GetTextLength() == 0)
3061 lineTextSize.height = TextUtility::GetFontMaxHeight(pFont);
3064 switch (__align & TEXT_ALIGNMASK_HORIZ)
3066 case TEXT_OBJECT_ALIGNMENT_LEFT:
3069 case TEXT_OBJECT_ALIGNMENT_CENTER:
3070 posX += (lineBounds.width - lineTextSize.width) / 2;
3073 case TEXT_OBJECT_ALIGNMENT_RIGHT:
3074 posX += (lineBounds.width - lineTextSize.width);
3078 switch (__align & TEXT_ALIGNMASK_VERT)
3080 case TEXT_OBJECT_ALIGNMENT_TOP:
3083 case TEXT_OBJECT_ALIGNMENT_MIDDLE:
3084 posY += (__pcRect.height - lineTextSize.height) / 2;
3087 case TEXT_OBJECT_ALIGNMENT_BOTTOM:
3088 posY += (__pcRect.height - lineTextSize.height);
3104 __pCompositeText->ForwardAnalyze(0, lineOffset, Integer::VALUE_MAX, __wrap, length, displaposYX, tempHeight);
3111 if (textIndex >= __pCompositeText->GetTextLength())
3113 __pCompositeText->ForwardAnalyze(0, __pCompositeText->GetTextLength(), 0x00ffffff, __wrap, length, tempWidth, tempHeight);
3116 logicalX = tempWidth - displaposYX + __pcRect.x + posX;
3118 __pCompositeText->ForwardAnalyze(textIndex - 1, 1, 0x00ffffff, __wrap, length, tempWidth, tempHeight);
3120 TextObjectAlignment alignment = __pCompositeText->GetElementVerticalAlignment();
3121 switch (alignment & TEXT_ALIGNMASK_VERT)
3123 case TEXT_OBJECT_ALIGNMENT_TOP:
3128 case TEXT_OBJECT_ALIGNMENT_MIDDLE:
3129 posY = posY + (lineBounds.height - tempHeight) / 2;
3132 case TEXT_OBJECT_ALIGNMENT_BOTTOM:
3133 posY = posY + (lineBounds.height - tempHeight);
3138 height = tempHeight;
3140 logicalY = __pcRect.y + posY;
3144 __pCompositeText->ForwardAnalyze(0, textIndex, 0x00ffffff, __wrap, length, tempWidth, tempHeight);
3148 logicalX = tempWidth - displaposYX + __pcRect.x + posX;
3150 __pCompositeText->ForwardAnalyze(textIndex - 1, 1, 0x00ffffff, __wrap, length, tempWidth, tempHeight);
3152 if (textIndex == __pCompositeText->GetTextLength())
3157 if (tempHeight == 0)
3159 tempHeight = TextUtility::GetFontMaxHeight(pFont);
3162 TextObjectAlignment alignment = __pCompositeText->GetElementVerticalAlignment();
3163 switch (alignment & TEXT_ALIGNMASK_VERT)
3165 case TEXT_OBJECT_ALIGNMENT_TOP:
3170 case TEXT_OBJECT_ALIGNMENT_MIDDLE:
3171 posY = posY + (lineBounds.height - tempHeight) / 2;
3174 case TEXT_OBJECT_ALIGNMENT_BOTTOM:
3175 posY = posY + (lineBounds.height - tempHeight);
3179 logicalY = __pcRect.y + posY;
3181 height = tempHeight;
3188 TextObject::GetTotalComposedHeight(void) const
3190 return __pCompositeText->GetTotalComposedHeight();
3194 TextObject::GetLineWidthAt(int lineIndex) const
3196 IF_NOT_CONSTRUCTED(return -1);
3198 result r = E_SUCCESS;
3199 TextLine* pTextLine = null;
3200 Dimension lineTextSize;
3205 pTextLine = __pTextColumn->GetTextLine(lineIndex);
3208 , , E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
3210 lineLength = pTextLine->GetTextLength();
3211 r = pTextLine->GetRegion(0, lineLength, lineTextSize.width, lineTextSize.height);
3212 SysTryReturn(NID_GRP
3214 , r, r, "[%s] Propagating.", GetErrorMessage(r));
3216 pcWidth = lineTextSize.width;
3217 lcWidth = _ResUtil::ConvertToVirCoord(pcWidth);
3219 SetLastResult(E_SUCCESS);
3227 TextObject::GetTotalHeight(void) const
3229 IF_NOT_CONSTRUCTED(return -1);
3232 if (IsPartialComposingModeEnabled())
3234 pcHeight = __pCompositeText->GetAnalysedTotalHeight();
3238 pcHeight = __pTextColumn->GetTotalHeight();
3241 int lcHeight = _ResUtil::ConvertToVirCoord(pcHeight);
3247 TextObject::GetElementIndexOf(TextElement& textElement) const
3249 IF_NOT_CONSTRUCTED(return -1);
3251 return __pCompositeText->GetElementIndexOf(textElement);
3255 TextObject::RemoveElementAt(int elementIndex, bool deallocate)
3257 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3259 return __pCompositeText->RemoveElementAt(elementIndex, deallocate);
3263 TextObject::HideFrontSpace(TextObjectSpaceHideType mode)
3265 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3267 __pCompositeText->HideFrontSpace(mode);
3273 TextObject::HideRearSpace(TextObjectSpaceHideType mode)
3275 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3277 __pCompositeText->HideRearSpace(mode);
3283 TextObject::GetSlidingStep(void) const
3285 IF_NOT_CONSTRUCTED(return -1);
3287 int lcSlidingStep = _ResUtil::ConvertToVirCoord(__slidingStep);
3289 return lcSlidingStep;
3293 TextObject::SetSlidingStep(int lcSlidingStep)
3295 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3297 int pcSlidingStep = _ResUtil::ConvertToPhyCoord(lcSlidingStep);
3299 __slidingStep = pcSlidingStep;
3305 TextObject::GetTotalLineCount(void) const
3307 IF_NOT_CONSTRUCTED(return -1);
3309 return __pTextColumn->GetTotalLineCount();
3313 TextObject::GetLineIndexAtTextIndex(int textIndex) const
3315 IF_NOT_CONSTRUCTED(return -1);
3317 return __pTextColumn->GetLineIndexAtTextIndex(textIndex);
3321 TextObject::GetLineHeightAt(int lineIndex) const
3323 IF_NOT_CONSTRUCTED(return -1);
3325 SysTryReturn(NID_GRP
3327 , -1, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid. (lineIndex = %d)", lineIndex);
3329 int pcHeight = __pTextColumn->GetLineHeightAt(lineIndex);
3330 int lcHeight = _ResUtil::ConvertToVirCoord(pcHeight);
3336 TextObject::GetDisplayLineCount(void) const
3338 IF_NOT_CONSTRUCTED(return -1);
3340 return __pTextColumn->GetDisplayLineCount();
3344 TextObject::GetFirstDisplayLineIndex(void) const
3346 IF_NOT_CONSTRUCTED(return -1);
3348 return __pTextColumn->GetFirstDisplayLineIndex();
3352 TextObject::GetFirstDisplayPositionY(void) const
3354 IF_NOT_CONSTRUCTED(return -1);
3356 int pcFirstDisplayPositionY = __pTextColumn->GetFirstDisplayPositionY();
3357 int lcFirstDisplayPositionY = _ResUtil::ConvertToVirCoord(pcFirstDisplayPositionY);
3359 return lcFirstDisplayPositionY;
3363 TextObject::GetLineIndexAtPositionY(int lcY) const
3365 IF_NOT_CONSTRUCTED(return -1);
3367 int pcY = _ResUtil::ConvertToPhyCoord(lcY);
3369 return __pTextColumn->GetLineIndexAtPositionY(pcY);
3373 TextObject::GetFirstTextIndexAt(int lineIndex) const
3375 IF_NOT_CONSTRUCTED(return -1);
3377 SysTryReturn(NID_GRP
3379 , -1, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid. (lineIndex = %d)", lineIndex);
3381 return __pTextColumn->GetFirstTextIndexAt(lineIndex);
3385 TextObject::GetTextLengthAt(int lineIndex) const
3387 IF_NOT_CONSTRUCTED(return -1);
3389 SysTryReturn(NID_GRP
3391 , -1, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid. (lineIndex = %d)", lineIndex);
3393 return __pTextColumn->GetTextLengthAt(lineIndex);
3397 TextObject::GetBounds(void) const
3399 IF_NOT_CONSTRUCTED(return Rectangle(0,0,0,0));
3405 TextObject::GetLineSpace(void) const
3407 IF_NOT_CONSTRUCTED(return -1);
3409 int pcLineSpacing = __pCompositeText->GetLineSpace();
3410 int lcLineSpacing = _ResUtil::ConvertToVirCoord(pcLineSpacing);
3412 return lcLineSpacing;
3416 TextObject::GetTextLength(void) const
3418 IF_NOT_CONSTRUCTED(return -1);
3420 return __pCompositeText->GetTextLength();
3424 TextObject::GetElementVerticalAlignment(void) const
3426 IF_NOT_CONSTRUCTED(return TEXT_OBJECT_ALIGNMENT_INVALID);
3428 return __pCompositeText->GetElementVerticalAlignment();
3431 TextObjectActionType
3432 TextObject::GetAction(void) const
3434 IF_NOT_CONSTRUCTED(return TEXT_OBJECT_ACTION_TYPE_NONE);
3440 TextObject::GetAlignment(void) const
3442 IF_NOT_CONSTRUCTED(return TEXT_OBJECT_ALIGNMENT_INVALID);
3448 TextObject::GetElementCount(void) const
3450 IF_NOT_CONSTRUCTED(return -1);
3452 return __pCompositeText->GetElementCount();
3456 TextObject::GetElementAtElementIndex(int elementIndex) const
3458 IF_NOT_CONSTRUCTED(return null);
3460 return __pCompositeText->GetElementAtElementIndex(elementIndex);
3464 TextObject::SetRange(int startTextIndex, int textLength)
3466 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3468 return __pCompositeText->SetRange(startTextIndex, textLength);
3472 TextObject::GetRange(int& startTextIndex, int& textLength) const
3474 IF_NOT_CONSTRUCTED(return);
3476 return __pCompositeText->GetRange(startTextIndex, textLength);
3480 TextObject::GetWrap(void) const
3482 IF_NOT_CONSTRUCTED(return TEXT_OBJECT_WRAP_TYPE_NONE);
3488 TextObject::SetCursorIndex(int cursorIndex)
3490 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3492 SysTryReturn(NID_GRP
3494 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid.");
3496 __pCompositeText->SetCursorIndex(cursorIndex);
3502 TextObject::GetCursorIndex(void) const
3504 IF_NOT_CONSTRUCTED(return -1);
3506 return __pCompositeText->GetCursorIndex();
3510 TextObject::SetBlock(bool enable)
3512 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3514 __pCompositeText->SetBlock(enable);
3520 TextObject::GetBlock(void) const
3522 IF_NOT_CONSTRUCTED(return false);
3524 return __pCompositeText->GetBlock();
3528 TextObject::SetBlockRange(int startTextIndex, int textLength)
3530 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3532 result r = E_SUCCESS;
3533 r = __pCompositeText->SetRange(startTextIndex, textLength);
3534 SysTryReturn(NID_GRP
3536 , r, r, "[%s] Propagating.", GetErrorMessage(r));
3542 TextObject::GetBlockRange(int& startTextIndex, int& textLength)
3544 IF_NOT_CONSTRUCTED(return);
3546 __pCompositeText->GetRange(startTextIndex, textLength);
3550 TextObject::IsAlternateLookEnabled(void) const
3552 IF_NOT_CONSTRUCTED(return false);
3554 return __isAlternateLookEnabled;
3558 TextObject::GetTotalCutLinkElementCount(void) const
3560 IF_NOT_CONSTRUCTED(return -1);
3562 return __pCompositeText->GetCutLinkElementCount();
3566 TextObject::ChangeCutLinkState(int linkIndex, bool select)
3568 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3570 return __pCompositeText->ChangeCutLinkState(linkIndex, select);
3574 TextObject::ResetAllCutLinkElementsState(void)
3576 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3578 return __pCompositeText->ResetAllCutLinkElementsState();
3582 TextObject::IsActionOn(void) const
3584 IF_NOT_CONSTRUCTED(return false);
3586 return __isActionOn;
3589 TextObjectEllipsisType
3590 TextObject::GetTextObjectEllipsisType(void) const
3592 IF_NOT_CONSTRUCTED(return TEXT_OBJECT_ELLIPSIS_TYPE_INVALID);
3594 return __textObjectEllipsisType;
3598 TextObject::SetWidthManagerEnabled(bool enable)
3600 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3602 if (__pCompositeText->IsWidthManagerEnabled() == enable)
3609 __pTextWidthManager = new (std::nothrow)TextWidthManager(__pCompositeText);
3610 SysTryReturn(NID_GRP
3611 , __pTextWidthManager
3612 , E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] Insufficient memory.");
3614 __pCompositeText->SetTextWidthManager(__pTextWidthManager);
3615 __pTextWidthManager->Initialize(__pCompositeText->GetTextLength());
3619 if (__pTextWidthManager)
3621 delete __pTextWidthManager;
3622 __pTextWidthManager = null;
3626 __pCompositeText->SetWidthManagerEnabled(enable);
3632 TextObject::IsWidthManagerEnabled(void) const
3634 IF_NOT_CONSTRUCTED(return false);
3636 return __pCompositeText->IsWidthManagerEnabled();
3640 TextObject::ChangeText(int textIndex)
3642 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3644 if (__sweepInfo.isValid)
3646 __sweepInfo.isValid = false;
3647 return E_INVALID_STATE;
3650 __sweepInfo.isValid = true;
3651 __sweepInfo.sweepType = TEXT_OBJECT_SWEEP_TYPE_REPLACE;
3652 __sweepInfo.sweepEventType = TEXT_OBJECT_SWEEP_EVENT_INSERT;
3653 __sweepInfo.anchorTextIndex = textIndex;
3654 __sweepInfo.sweepRegionStartLineIndex = GetLineIndexAtTextIndex(textIndex);
3655 __sweepInfo.sweepRegionLineCount = 1;
3656 __sweepInfo.anchorLineIndex = __sweepInfo.sweepRegionStartLineIndex;
3657 __sweepInfo.widthChanged = 0;
3659 __pCompositeText->SetTextSweepInfo(&__sweepInfo);
3665 TextObject::InputText(int textIndex)
3667 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3669 if (__sweepInfo.isValid == true)
3671 __sweepInfo.isValid = false;
3672 return E_INVALID_STATE;
3675 __sweepInfo.isValid = true;
3676 __sweepInfo.sweepType = TEXT_OBJECT_SWEEP_TYPE_KEYINPUT;
3677 __sweepInfo.sweepEventType = TEXT_OBJECT_SWEEP_EVENT_INSERT;
3678 __sweepInfo.anchorTextIndex = textIndex;
3679 __sweepInfo.prevAnchorLineIndex = GetLineIndexAtTextIndex(textIndex);
3681 if (__sweepInfo.prevAnchorLineIndex == -1)
3683 __sweepInfo.prevAnchorLineIndex = __pTextColumn->GetTotalLineCount()-1;
3686 __pCompositeText->SetTextSweepInfo(&__sweepInfo);
3692 TextObject::RemoveText(int textIndex)
3694 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3696 if (__sweepInfo.isValid == true)
3698 __sweepInfo.isValid = false;
3699 return E_INVALID_STATE;
3702 __sweepInfo.isValid = true;
3703 __sweepInfo.sweepEventType = TEXT_OBJECT_SWEEP_EVENT_REMOVE;
3704 __sweepInfo.anchorTextIndex = textIndex;
3705 __sweepInfo.prevAnchorLineIndex = GetLineIndexAtTextIndex(textIndex);
3707 if (__sweepInfo.prevAnchorLineIndex == -1)
3709 __sweepInfo.prevAnchorLineIndex = __pTextColumn->GetTotalLineCount()-1;
3712 __pCompositeText->SetTextSweepInfo(&__sweepInfo);
3718 TextObject::ResetSweepInfo(void)
3720 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3722 __sweepInfo.isValid = false;
3728 TextObject::GetSweepInfo(void) const
3730 TextObjectSweepInfo textSweepInfo;
3731 textSweepInfo.isValid = false;
3732 textSweepInfo.sweepType = TEXT_OBJECT_SWEEP_TYPE_NONE;
3733 textSweepInfo.sweepEventType = TEXT_OBJECT_SWEEP_EVENT_NONE;
3734 textSweepInfo.anchorTextIndex = -1;
3735 textSweepInfo.anchorLineIndex = -1;
3736 textSweepInfo.prevAnchorLineIndex = -1;
3737 textSweepInfo.sweepRegionStartLineIndex = -1;
3738 textSweepInfo.sweepRegionLineCount = -1;
3739 textSweepInfo.insertedLineCount = -1;
3740 textSweepInfo.deletedLineCount = -1;
3741 textSweepInfo.widthChanged = -1;
3743 IF_NOT_CONSTRUCTED(return textSweepInfo);
3745 textSweepInfo.isValid = __sweepInfo.isValid;
3746 textSweepInfo.sweepType = __sweepInfo.sweepType;
3747 textSweepInfo.sweepEventType = __sweepInfo.sweepEventType;
3748 textSweepInfo.anchorTextIndex = __sweepInfo.anchorTextIndex;
3749 textSweepInfo.anchorLineIndex = __sweepInfo.anchorLineIndex;
3750 textSweepInfo.prevAnchorLineIndex = __sweepInfo.prevAnchorLineIndex;
3751 textSweepInfo.sweepRegionStartLineIndex = __sweepInfo.sweepRegionStartLineIndex;
3752 textSweepInfo.sweepRegionLineCount = __sweepInfo.sweepRegionLineCount;
3753 textSweepInfo.insertedLineCount = __sweepInfo.insertedLineCount;
3754 textSweepInfo.deletedLineCount = __sweepInfo.deletedLineCount;
3755 textSweepInfo.widthChanged = __sweepInfo.widthChanged;
3757 return textSweepInfo;
3761 TextObject::GetSweepComposeLineInfo(int lineIndex, TextObjectSweepComposeLineInfo& textSweepComposeLineInfo) const
3763 IF_NOT_CONSTRUCTED(return E_INVALID_STATE);
3765 SysTryReturn(NID_GRP
3767 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid. (lineIndex = %d)", lineIndex);
3769 TextLine* pTextLine = __pTextColumn->GetTextLine(lineIndex);
3770 SysTryReturn(NID_GRP
3772 , E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid. (lineIndex = %d)", lineIndex);
3774 textSweepComposeLineInfo = pTextLine->GetSweepComposeInfo();
3780 TextObject::GetTextOffsetAtLine(int lineIndex) const
3782 IF_NOT_CONSTRUCTED(return -1);
3784 SysTryReturn(NID_GRP
3786 , -1, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid. (lineIndex = %d)", lineIndex);
3788 TextLine* pTextLine = __pTextColumn->GetTextLine(lineIndex);
3789 SysTryReturn(NID_GRP
3791 , -1, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
3793 return pTextLine->GetTextOffset();
3797 TextObject::GetTextLengthAtLine(int lineIndex) const
3799 IF_NOT_CONSTRUCTED(return -1);
3801 SysTryReturn(NID_GRP
3803 , -1, E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid. (lineIndex = %d)", lineIndex);
3805 TextLine* pTextLine = __pTextColumn->GetTextLine(lineIndex);
3806 SysTryReturn(NID_GRP
3808 , -1, E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
3810 return pTextLine->GetTextLength();
3814 TextObject::GetBoundsAtLine(int lineIndex) const
3816 IF_NOT_CONSTRUCTED(return Rectangle(-1, -1, -1, -1));
3818 SysTryReturn(NID_GRP
3820 , Rectangle(-1, -1, -1, -1), E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid. (lineIndex = %d)", lineIndex);
3822 TextLine* pTextLine = __pTextColumn->GetTextLine(lineIndex);
3823 SysTryReturn(NID_GRP
3825 , Rectangle(-1, -1, -1, -1), E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
3827 Rectangle lineBounds = pTextLine->GetBounds();
3833 TextObject::GetDisplayPositionAtLine(int lineIndex, int textIndexFromLineOffset)
3835 IF_NOT_CONSTRUCTED(return Point(-1, -1));
3837 SysTryReturn(NID_GRP
3839 , Point(-1, -1), E_INVALID_ARG, "[E_INVALID_ARG] The argument is invalid. (lineIndex = %d)", lineIndex);
3841 TextLine* pTextLine = __pTextColumn->GetTextLine(lineIndex);
3842 SysTryReturn(NID_GRP
3844 , Point(-1, -1), E_SYSTEM, "[E_SYSTEM] Fail to get text line.");
3846 int lineOffset = pTextLine->GetTextOffset();
3847 int lineLength = pTextLine->GetTextLength();
3848 Dimension lineTextSize;
3849 Dimension extentDim;
3851 Rectangle lineBounds;
3853 pTextLine->GetRegion(0, lineLength, lineTextSize.width, lineTextSize.height);
3854 lineBounds = pTextLine->GetBounds();
3856 __pCompositeText->ForwardAnalyze(lineOffset, textIndexFromLineOffset, lineTextSize.width,
3857 __wrap, textCount, extentDim.width, extentDim.height);
3859 switch (__align & TEXT_ALIGNMASK_HORIZ)
3861 case TEXT_OBJECT_ALIGNMENT_LEFT:
3864 case TEXT_OBJECT_ALIGNMENT_CENTER:
3865 extentDim.width += (lineBounds.width - lineTextSize.width) / 2;
3868 case TEXT_OBJECT_ALIGNMENT_RIGHT:
3869 extentDim.width += (lineBounds.width - lineTextSize.width);
3873 if (extentDim.width < 0)
3875 extentDim.width = 0;
3878 return Point(extentDim.width + __rect.x, lineBounds.y - __pTextColumn->GetFirstDisplayPositionY() + __rect.y);
3881 }}} // Tizen::Graphics::_Text