MercurialSymaptic / file revision
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | raw | help
os/graphics/windowing/windowserver/nga/SERVER/TCURSOR.CPP
author sl
Tue, 10 Jun 2014 14:32:02 +0200
changeset 1 260cb5ec6c19
permissions -rw-r--r--
Update contrib. 
     1 // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

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

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // The text cursor

    15 // 

    16 //

    17 

    18 #include <e32std.h>

    19 #include <graphics/wscursor.h>

    20 #include "server.h"

    21 #include "tcursor.h"

    22 #include "windowgroup.h"

    23 #include "wstop.h"

    24 #include "panics.h"

    25 #include "EVENT.H"

    26 #include "graphics/windowserverconstants.h"

    27 

    28 static const TInt64 KFlashRate(500000); // duration cursor is ON or OFF

    29 

    30 void RWsTextCursor::ConstructL(CWsWindowGroup *aGroupWin)

    31 	{

    32 	iInternalFlags = 0;

    33 	iGroupWin=aGroupWin;

    34 	iCustomTextCursor = NULL;

    35 	}

    36 

    37 void RWsTextCursor::Close()

    38 	{

    39 	iDrawRegion.Close();

    40 	Cancel();

    41 	}

    42 

    43 void RWsTextCursor::SetL(const TWsWinCmdSetTextCursor &aSet, TBool aClipped)

    44 	{

    45 	if (aSet.cursor.iType < TTextCursor::ETypeFirst ||

    46 	        (aSet.cursor.iType > TTextCursor::ETypeLast &&

    47 		 aSet.cursor.iType <= TTextCursor::ETypeLastBasic) ||

    48 		(aSet.cursor.iFlags&static_cast<TUint>(ETextCursorPrivateFlags)))

    49 		{

    50 		Cancel();

    51 		iGroupWin->OwnerPanic(EWservPanicInvalidTextCursor);

    52 		}

    53 	else

    54 		{

    55 		CWsClientWindow* win = NULL;

    56 		iGroupWin->WsOwner()->HandleToClientWindow(aSet.window, &win);

    57 

    58 		// Check window is a child of the group window

    59 		CWsWindowBase* searchWin = NULL;

    60 		for(searchWin=win; searchWin->WinType()!=EWinTypeGroup; searchWin=searchWin->BaseParent())

    61 			{}

    62 		if (iGroupWin != searchWin)

    63 			{

    64 			Cancel();

    65 			iGroupWin->OwnerPanic(EWservPanicWindow);

    66 			}

    67 

    68 		TPoint pos(aSet.pos.iX, aSet.pos.iY-aSet.cursor.iAscent);

    69 		TSize size(aSet.cursor.iWidth, aSet.cursor.iHeight);

    70 		TUint flags = aSet.cursor.iFlags;

    71 		TInt type = aSet.cursor.iType;

    72 		TRect clipRect = iClipRect;

    73 		TRgb color = aSet.cursor.iColor;

    74 		CWsCustomTextCursor* customTextCursor = iCustomTextCursor;

    75 		TBool changed = EFalse;

    76 

    77 		TPoint clipOrigo;

    78 		TSize clipSize;

    79 

    80 		if (type > TTextCursor::ETypeLastBasic)

    81 			{

    82 			changed = ETrue;

    83 

    84 			customTextCursor = CWsClient::FindCustomTextCursor(type);

    85 			if (!customTextCursor)

    86 				{

    87 				Cancel();

    88 				iGroupWin->OwnerPanic(EWservPanicNoCustomTextCursor);

    89 				return;

    90 				}

    91 			

    92 			if( !customTextCursor->HasSpriteMember() )

    93 				{

    94 				iGroupWin->OwnerPanic(EWservPanicNoSpriteMember);

    95 				return;

    96 				}

    97 			

    98 			TInt yAdjust=0;

    99 			switch (customTextCursor->Alignment())

   100 				{

   101 				case RWsSession::ECustomTextCursorAlignTop:

   102 					break;

   103 				case RWsSession::ECustomTextCursorAlignBaseline:

   104 					yAdjust = aSet.cursor.iAscent-1;

   105 					break;

   106 				case RWsSession::ECustomTextCursorAlignBottom:

   107 					yAdjust = aSet.cursor.iHeight-1;

   108 					break;

   109 				default:

   110 					Cancel();

   111 					iGroupWin->OwnerPanic(EWservPanicCustomTextCursorAlign);

   112 					return;

   113 				}

   114 			pos.iY += yAdjust;

   115 			// Start with a clipping rect to be the whole window

   116 			// relative cursor pos and shrink down to what we want

   117 			clipOrigo = -pos;

   118 			clipSize = win->Size();

   119 			if (flags & TTextCursor::EFlagClipHorizontal)

   120 				{

   121 				clipOrigo.iX = 0;

   122 				clipSize.iWidth = size.iWidth;

   123 				}

   124 			if (flags & TTextCursor::EFlagClipVertical)

   125 				{

   126 				clipOrigo.iY = -yAdjust;

   127 				clipSize.iHeight = aSet.cursor.iHeight;

   128 				}

   129 			}

   130 		else

   131 			{

   132 			customTextCursor = NULL;

   133 			}

   134 

   135 		if (aClipped)

   136 			{

   137 			flags|=ETextCursorFlagClipped;

   138 			clipRect=aSet.rect;

   139 			}

   140 

   141 		TPoint absPos(pos.iX,pos.iY);

   142 		absPos=absPos+win->Origin();

   143 		if (pos != iPos || absPos != iAbsPos || size != iSize || iType != type ||

   144 			flags != iFlags || clipRect != iClipRect || color != iColor ||

   145 			customTextCursor != iCustomTextCursor || win != iWin)

   146 			{

   147 			// There is a change in the cursor.

   148 			changed = ETrue;

   149 			}

   150 

   151 		if (iInternalFlags&EHasFocus && changed)

   152 			{

   153 			if ((win != iWin && !iCustomTextCursor) || (customTextCursor && !iCustomTextCursor))

   154 				ReleaseNode();

   155 			TCursorSprite::Hide();

   156 			}

   157 

   158 		UpdateAttributes(pos, absPos, size, type, flags, clipRect, color, customTextCursor, win);

   159 

   160 		if (customTextCursor && iInternalFlags&EHasFocus)

   161 			{

   162 			customTextCursor->CompleteL(win, !(flags&TTextCursor::EFlagNoFlash), flags & (TTextCursor::EFlagClipHorizontal | TTextCursor::EFlagClipVertical), clipOrigo, clipSize);

   163 			customTextCursor->SetPositionNoRedraw(pos);

   164 			}

   165 

   166 		if (iInternalFlags&EHasFocus && changed)

   167 			{

   168 			TCursorSprite::SetCurrentCursor(this, win);

   169 			}

   170 		}

   171 	}

   172 void RWsTextCursor::UpdateAttributes(TPoint aPos, TPoint aAbsPos, TSize aSize, TInt aType, TUint aFlags, TRect aClipRect, TRgb aColor, CWsCustomTextCursor* aCustomTextCursor, CWsClientWindow* aWin)

   173 	{

   174 	if (aPos != iPos || aSize != iSize || aAbsPos != iAbsPos)

   175 		{

   176 		iPos = aPos;

   177         iAbsPos = aAbsPos;

   178 		iSize = aSize;

   179 		WS_ASSERT_DEBUG(iGroupWin->Screen(),EWsPanicNoScreen);

   180 		MWsWindowTreeObserver* const windowTreeObserver = iGroupWin->Screen()->WindowTreeObserver();

   181 		if (windowTreeObserver && iInternalFlags&EHasFocus && iInternalFlags&EActiveNode)

   182 			windowTreeObserver->NodeExtentChanged(*this, RectRelativeToScreen());

   183 		}

   184 

   185 	if (aType != iType)

   186 		{

   187 		iType = aType;

   188 		NotifyObserver(MWsWindowTreeObserver::ECursorType);

   189 		}

   190 

   191 	if (aClipRect != iClipRect)

   192 		{

   193 		iClipRect = aClipRect; // must update clip rect before sending clip rect set/unset notification

   194 		if ((aFlags&ETextCursorFlagClipped) && (iFlags&ETextCursorFlagClipped))

   195 			NotifyObserver(MWsWindowTreeObserver::ECursorClipRect); // clip rect changed

   196 		}

   197 

   198 	if (aFlags != iFlags)

   199 		{

   200 		TBool sendFlagChanged = EFalse;

   201 		if ((aFlags&ETextCursorFlagClipped) != (iFlags&ETextCursorFlagClipped))

   202 			{

   203 			if (iInternalFlags&EHasFocus && iInternalFlags&EActiveNode)

   204 				{

   205 				// We can't send flag changed till iFlags has been updated, as otherwise plugins responding to

   206 				// the flag changed notification by calling ClipRect() may get the wrong rect

   207 				sendFlagChanged = ETrue;

   208 				}

   209 			}

   210 		const TBool userFlagsChanged((aFlags&ETextCursorUserFlags) != (iFlags&ETextCursorUserFlags)); 

   211 		iFlags = aFlags;

   212 		if (userFlagsChanged)

   213 			NotifyObserver(MWsWindowTreeObserver::ECursorFlags);

   214 		if (sendFlagChanged)

   215 			{

   216 			WS_ASSERT_DEBUG(iGroupWin->Screen(),EWsPanicNoScreen);

   217 			MWsWindowTreeObserver* const windowTreeObserver = iGroupWin->Screen()->WindowTreeObserver();

   218 			if (windowTreeObserver)

   219 				windowTreeObserver->FlagChanged(*this, MWsWindowTreeObserver::ECursorClipRectSet, !!(iFlags&ETextCursorFlagClipped)); // clip rect set/unset

   220 			}

   221 		}

   222 

   223 	if (aColor != iColor)

   224 		{

   225 		iColor = aColor;

   226 		NotifyObserver(MWsWindowTreeObserver::ECursorColor);

   227 		}

   228 	iCustomTextCursor = aCustomTextCursor;

   229 	iWin = aWin;

   230 	}

   231 

   232 void RWsTextCursor::NotifyObserver(MWsWindowTreeObserver::TAttributes aAttribute) const

   233 	{

   234 	if (iInternalFlags&EHasFocus && iInternalFlags&EActiveNode)

   235 		{

   236 		WS_ASSERT_DEBUG(iGroupWin->Screen(),EWsPanicNoScreen);

   237 		MWsWindowTreeObserver* const windowTreeObserver = iGroupWin->Screen()->WindowTreeObserver();

   238 		if (windowTreeObserver)

   239 			windowTreeObserver->AttributeChanged(*this, aAttribute);

   240 		}

   241 	}

   242 

   243 void RWsTextCursor::CreateNode()

   244 	{

   245 	WS_ASSERT_DEBUG(iGroupWin->Screen(),EWsPanicNoScreen);

   246 	MWsWindowTreeObserver* const windowTreeObserver = iGroupWin->Screen()->WindowTreeObserver();

   247 	if (windowTreeObserver && !(iInternalFlags&EActiveNode))

   248 		{

   249 		iInternalFlags |= EActiveNode;

   250 		windowTreeObserver->NodeCreated(*this, iWin);

   251 		windowTreeObserver->NodeExtentChanged(*this, RectRelativeToScreen());

   252 		if (iFlags&ETextCursorFlagClipped)

   253 			windowTreeObserver->FlagChanged(*this, MWsWindowTreeObserver::ECursorClipRectSet, ETrue);

   254 		windowTreeObserver->NodeActivated(*this);

   255 		}

   256 	}

   257 

   258 void RWsTextCursor::ReleaseNode()

   259 	{

   260 	if (iInternalFlags&EActiveNode)

   261 		{

   262 		WS_ASSERT_DEBUG(iGroupWin->Screen(),EWsPanicNoScreen);

   263 		MWsWindowTreeObserver* const windowTreeObserver = iGroupWin->Screen()->WindowTreeObserver();

   264 		if (windowTreeObserver)

   265 			{

   266 			windowTreeObserver->NodeReleased(*this);

   267 			iInternalFlags &= ~EActiveNode;

   268 			}

   269 		}

   270 	}

   271 

   272 void RWsTextCursor::SendState(MWsWindowTreeObserver& aWindowTreeObserver) const

   273 	{

   274 	if (iInternalFlags & EActiveNode)

   275 		{

   276 		aWindowTreeObserver.NodeCreated(*this, iWin);

   277 		aWindowTreeObserver.NodeExtentChanged(*this, RectRelativeToScreen());

   278 		if (iFlags&ETextCursorFlagClipped)

   279 			aWindowTreeObserver.FlagChanged(*this, MWsWindowTreeObserver::ECursorClipRectSet, ETrue);

   280 		aWindowTreeObserver.NodeActivated(*this);

   281 		}

   282 	}

   283 

   284 void RWsTextCursor::Cancel()

   285 	{

   286 	if (iType!=TTextCursor::ETypeNone)

   287 		{

   288 		if (iInternalFlags&EHasFocus)

   289 			TCursorSprite::SetFocus(NULL);

   290 		iType=TTextCursor::ETypeNone;

   291 		iWin=NULL;

   292 		}

   293 	}

   294 

   295 void RWsTextCursor::Disable()

   296 	{

   297 	if (iWin)

   298 		{

   299 		TCursorSprite::Hide();

   300 		}

   301 	}

   302 

   303 void RWsTextCursor::Enable()

   304 	{

   305 	if (iWin)

   306 		{

   307 		TCursorSprite::Reveal();

   308 		}

   309 	}

   310 

   311 void RWsTextCursor::LostFocus()

   312 	{

   313 	TCursorSprite::SetFocus(NULL);

   314 	iInternalFlags &= ~EHasFocus;

   315 	}

   316 

   317 void RWsTextCursor::ReceivedFocus()

   318 	{

   319 	iInternalFlags |= EHasFocus;

   320 	if (iType!=TTextCursor::ETypeNone && iWin)

   321 		{

   322 		TCursorSprite::SetFocus(this,iWin);

   323 		if (iCustomTextCursor)

   324 			{

   325 			iCustomTextCursor->SetPositionNoRedraw(iPos);

   326 			}

   327 		}

   328 	}

   329 

   330 TRect RWsTextCursor::RectRelativeToScreen() const

   331 	{

   332 	TRect rect;

   333 	rect.iTl=iPos+iWin->Origin();

   334 	rect.iBr=rect.iTl+iSize;

   335 	return(rect);

   336 	}

   337 

   338 TRect RWsTextCursor::RectRelativeToWindow() const

   339 	{

   340 	TRect rect;

   341 	rect.iTl=iPos;

   342 	rect.iBr=rect.iTl+iSize;

   343 	return rect;

   344 	}

   345 

   346 void RWsTextCursor::doDraw(const TRegion& aRegion)

   347 	{

   348 	TRegionFix<1> fallbackClipRegion;

   349 	const TRegion *clipRegion= &aRegion;

   350 	if (aRegion.CheckError())

   351 		{

   352 		fallbackClipRegion.AddRect(iWin->AbsRect());

   353 		clipRegion= &fallbackClipRegion;

   354 		}

   355 

   356 	if(!clipRegion->IsEmpty())

   357 		{

   358 		MWsTextCursor::TTextCursorInfo renderStageCursorInfo(

   359 			RectRelativeToWindow(),

   360 			*clipRegion,

   361 			iType, static_cast<MWsWindow *>(Win()), iColor

   362 			);

   363 		

   364 		MWsTextCursor* textCursor = iWin->Screen()->RenderStageTextCursor();

   365 

   366 		textCursor->DrawTextCursor(renderStageCursorInfo);

   367 

   368 		TWindowServerEvent::NotifyScreenDrawingEvent(clipRegion);

   369 		}

   370 	}

   371 

   372 void RWsTextCursor::Draw(const TRegion& aRegion)

   373 	{

   374 	iDrawRegion.Copy(iWin->VisibleRegion());

   375 	if (iFlags&ETextCursorFlagClipped)

   376 		{

   377 		TRect rect(iClipRect);

   378 		rect.Move(iWin->Origin());

   379 		iDrawRegion.ClipRect(rect);

   380 		}

   381 

   382 	// Need to clip against a possible recent screen size change.

   383 	iDrawRegion.ClipRect(iWin->Screen()->SizeInPixels());

   384 

   385 	RWsRegion tmpRegion;

   386 	tmpRegion.Intersection(iDrawRegion, aRegion);

   387 	if (tmpRegion.CheckError())

   388 		doDraw(iDrawRegion);

   389 	else

   390 		{

   391 		if (!tmpRegion.IsEmpty())

   392 			{

   393 			doDraw(tmpRegion);

   394 			}

   395 		}

   396 	tmpRegion.Close();

   397 	}

   398 

   399 void RWsTextCursor::WindowDisconnected(CWsWindow *aWindow)

   400 	{

   401 	if (iWin==aWindow)

   402 		Cancel();

   403 	}

   404 

   405 TBool RWsTextCursor::IsStandardCursorActive()

   406 	{

   407 	return TCursorSprite::IsStandardCursorActive();

   408 	}

   409 

   410 TBool RWsTextCursor::IsFlashing() const

   411 	{

   412 	return !(iFlags&TTextCursor::EFlagNoFlash);

   413 	}

   414 

   415 void RWsTextCursor::ScheduleReDrawNow()

   416 	{

   417 	if (!iGroupWin->Screen()->ChangeTracking())

   418 		iGroupWin->Screen()->ScheduleAnimation(ETextCursor, RectRelativeToScreen(), 0, 0, 0, iWin);

   419 	}

   420 

   421 /** @see MWsWindowTreeNode */

   422 MWsWindowTreeNode::TType RWsTextCursor::NodeType() const

   423 	{

   424 	return MWsWindowTreeNode::EWinTreeNodeStandardTextCursor; 

   425 	}

   426 

   427 /** @see MWsWindowTreeNode */

   428 const MWsWindow* RWsTextCursor::Window() const

   429 	{

   430 	return NULL;

   431 	}

   432 

   433 /** @see MWsWindowTreeNode */

   434 const MWsSprite* RWsTextCursor::Sprite() const

   435 	{

   436 	return NULL;

   437 	}

   438 

   439 /** @see MWsWindowTreeNode */

   440 const MWsStandardTextCursor* RWsTextCursor::StandardTextCursor() const

   441 	{

   442 	return this;

   443 	}

   444 

   445 /** @see MWsWindowTreeNode */

   446 const MWsWindowGroup* RWsTextCursor::WindowGroup() const

   447 	{

   448 	return static_cast<MWsWindowGroup*>(iGroupWin);

   449 	}

   450 

   451 /** @see MWsWindowTreeNode */

   452 const MWsWindowTreeNode* RWsTextCursor::ParentNode() const

   453 	{

   454 	return iWin;

   455 	}

   456 

   457 /** @see MWsStandardTextCursor */

   458 TInt RWsTextCursor::Type() const

   459 	{

   460 	return iType;

   461 	}

   462 

   463 /** @see MWsStandardTextCursor */

   464 TRect RWsTextCursor::Rect() const

   465 	{

   466 	return RectRelativeToScreen();

   467 	}

   468 

   469 /** @see MWsStandardTextCursor */

   470 TRect RWsTextCursor::ClipRect() const

   471 	{

   472 	if (iFlags&ETextCursorFlagClipped)

   473 		{

   474 		TRect clipRectRelativeToScreen(iClipRect);

   475 		clipRectRelativeToScreen.Move(iWin->Origin());

   476 		return clipRectRelativeToScreen;

   477 		}

   478 	else

   479 		{

   480 		return Rect();

   481 		}

   482 	}

   483 

   484 /** @see MWsStandardTextCursor */

   485 TUint RWsTextCursor::Flags() const

   486 	{

   487 	return iFlags&ETextCursorUserFlags;

   488 	}

   489 

   490 /** @see MWsStandardTextCursor */

   491 TRgb RWsTextCursor::Color() const

   492 	{

   493 	return iColor;

   494 	}

   495 

   496 /** @see MWsStandardTextCursor */

   497 TTimeIntervalMicroSeconds32 RWsTextCursor::FlashInterval() const

   498 	{

   499 	return iFlags&TTextCursor::EFlagNoFlash ? 0 : KFlashRate;

   500 	}

   501 

   502 TFlashState RWsTextCursor::CurrentCursorFlashState() const

   503 	{

   504 	if (IsFlashing())

   505 		{

   506 		return (CWsTop::CurrentFocusScreen()->Now().DateTime().MicroSecond()<KFlashRate)?EFlashOn:EFlashOff;

   507 		}

   508 	else

   509 		{

   510 		return EFlashOn;

   511 		}

   512 	}

   513 

   514 

   515 // Cursor sprite handling

   516 

   517 TBool TCursorSprite::iHidden=ETrue;

   518 RWsTextCursor *TCursorSprite::iCurrentCursor=NULL;

   519 

   520 //

   521 

   522 // Hide / Reveal text cursors.

   523 void TCursorSprite::Hide()

   524 	{

   525 	if (!iHidden && iCurrentCursor)

   526 		{

   527 		iHidden=ETrue;

   528 		if (iCurrentCursor->iCustomTextCursor)

   529 			{

   530 			iCurrentCursor->iCustomTextCursor->Deactivate();

   531 			}

   532 		else

   533 			{

   534 			iCurrentCursor->ScheduleReDrawNow();

   535 			}

   536 		}

   537 	}

   538 	

   539 void TCursorSprite::Reveal()

   540 	{

   541 	if(iHidden && iCurrentCursor)

   542 		{

   543 		iHidden=EFalse;

   544 		if (iCurrentCursor->iCustomTextCursor)

   545 			{

   546 			iCurrentCursor->iCustomTextCursor->Activate();

   547 			}

   548 		else

   549 			{

   550 			iCurrentCursor->ScheduleReDrawNow();

   551 			}

   552 		}

   553 	}

   554 

   555 void TCursorSprite::SetFocus(RWsTextCursor* aFocus,CWsClientWindow* aWin/*=NULL*/)

   556 	{

   557 	if (iCurrentCursor!=aFocus)

   558 		{

   559 		if (iCurrentCursor)

   560 			iCurrentCursor->ReleaseNode();

   561 		Hide();

   562 		SetCurrentCursor(aFocus, aWin);

   563 		}

   564 	}

   565 

   566 void TCursorSprite::SetCurrentCursor(RWsTextCursor* aFocus, CWsClientWindow* aWin)

   567 	{

   568 	if (aFocus && !aFocus->iCustomTextCursor)

   569 		aFocus->CreateNode();

   570 	iCurrentCursor = aFocus;

   571 	if (aWin && iCurrentCursor && iCurrentCursor->iCustomTextCursor)

   572 		{

   573 		iCurrentCursor->iCustomTextCursor->SetWindow(aWin);

   574 		}

   575 	Reveal();

   576 	}

   577 

   578 TBool TCursorSprite::IsStandardCursorActive()

   579 	{

   580 	return iCurrentCursor && !iCurrentCursor->iCustomTextCursor && !iHidden;

   581 	}

   582
Symaptic