44
|
1 |
/*
|
|
2 |
* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
|
|
3 |
* All rights reserved.
|
|
4 |
* This component and the accompanying materials are made available
|
|
5 |
* under the terms of "Eclipse Public License v1.0""
|
|
6 |
* which accompanies this distribution, and is available
|
|
7 |
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
|
|
8 |
*
|
|
9 |
* Initial Contributors:
|
|
10 |
* Nokia Corporation - initial contribution.
|
|
11 |
*
|
|
12 |
* Contributors:
|
|
13 |
*
|
|
14 |
* Description: Avkon implementation of non-focusing popup menu to show word candidates.
|
|
15 |
*
|
|
16 |
*/
|
|
17 |
|
|
18 |
|
|
19 |
|
|
20 |
|
|
21 |
|
|
22 |
|
|
23 |
|
|
24 |
|
|
25 |
|
|
26 |
|
|
27 |
|
|
28 |
|
|
29 |
|
|
30 |
#include <eikenv.h>
|
|
31 |
#include <eikappui.h>
|
|
32 |
#include <badesca.h>
|
|
33 |
#include <coemain.h>
|
|
34 |
#include <aknPopupHeadingPane.h>
|
|
35 |
#include <aknsfld.h>
|
|
36 |
#include <AknsFrameBackgroundControlContext.h>
|
|
37 |
#include <aknlists.h>
|
|
38 |
#include <aknmessagequerycontrol.h>
|
|
39 |
#include <skinlayout.cdl.h>
|
|
40 |
#include <AknLayout2ScalableDef.h>
|
|
41 |
#include <aknlayoutscalable_avkon.cdl.h>
|
|
42 |
#include <layoutmetadata.cdl.h>
|
|
43 |
#include <aknlayoutscalable_apps.cdl.h>
|
|
44 |
#include <AknFepInternalCRKeys.h>
|
|
45 |
#include <AvkonInternalCRKeys.h>
|
|
46 |
|
|
47 |
#include <aknfep.rsg>
|
|
48 |
#include <AknFepGlobalEnums.h>
|
|
49 |
#include <avkon.hrh>
|
|
50 |
#include "AknFepAvkonCandidatePopup.h"
|
|
51 |
#include "AknPriv.hrh"
|
|
52 |
const TInt KChrKeyTimeout = 250000;
|
|
53 |
const TInt KChrKeyRepeatDelay = 1000000;
|
|
54 |
|
|
55 |
const TInt KScreenWidthQHDLandscape = 640;
|
|
56 |
const TInt KScreenHeightQHDLandscape = 360;
|
|
57 |
const TInt KOffsetWidthForCandidatePopup = 32;
|
|
58 |
|
|
59 |
/**
|
|
60 |
* Creates the pop-up list
|
|
61 |
*
|
|
62 |
*/
|
|
63 |
CAknFepAvkonCandidatePopup* CAknFepAvkonCandidatePopup::NewL( MAknFepCandidatePopupCallback& aOwner )
|
|
64 |
{
|
|
65 |
CAknFepAvkonCandidatePopup* self = new(ELeave)CAknFepAvkonCandidatePopup( aOwner );
|
|
66 |
CleanupStack::PushL(self);
|
|
67 |
self->ConstructL();
|
|
68 |
CleanupStack::Pop(self);
|
|
69 |
return self;
|
|
70 |
}
|
|
71 |
|
|
72 |
|
|
73 |
/**
|
|
74 |
* C++ constructor
|
|
75 |
*
|
|
76 |
* @param aOwner The owner of the popup list. Provides the candidates and receives notification
|
|
77 |
* when candidate selected.
|
|
78 |
*
|
|
79 |
*/
|
|
80 |
CAknFepAvkonCandidatePopup::CAknFepAvkonCandidatePopup( MAknFepCandidatePopupCallback& aOwner )
|
|
81 |
: CAknPopupList()
|
|
82 |
, iOwner(aOwner)
|
|
83 |
, iKeyboard(EPtiKeyboardNone)
|
|
84 |
{
|
|
85 |
|
|
86 |
}
|
|
87 |
|
|
88 |
|
|
89 |
/**
|
|
90 |
* 2nd phase construction
|
|
91 |
*
|
|
92 |
*/
|
|
93 |
void CAknFepAvkonCandidatePopup::ConstructL()
|
|
94 |
{
|
|
95 |
// Construct the inner listbox and the base class
|
|
96 |
iList = new( ELeave ) CAknSinglePopupMenuStyleListBox;
|
|
97 |
TInt primaryCandidate = 0;
|
|
98 |
|
|
99 |
CRepository* aknFepRepository = NULL;
|
|
100 |
aknFepRepository = CRepository::NewL(KCRUidAknFep);
|
|
101 |
if(aknFepRepository)
|
|
102 |
{
|
|
103 |
aknFepRepository->Get(KAknFepPrimaryCandidateFlag, primaryCandidate);
|
|
104 |
delete aknFepRepository;
|
|
105 |
}
|
|
106 |
|
|
107 |
TInt keyboardLayout = 0;
|
|
108 |
RProperty::Get(KCRUidAvkon, KAknKeyBoardLayout, keyboardLayout);
|
|
109 |
TPtiKeyboardType layout = (TPtiKeyboardType)keyboardLayout;
|
|
110 |
|
|
111 |
// Not use embedded CBA, so new the CBA seperately
|
|
112 |
TInt cbaResource = 0;
|
|
113 |
if(primaryCandidate && layout != EPtiKeyboard12Key )
|
|
114 |
{
|
|
115 |
CAknPopupList::ConstructL( iList,R_AKNFEP_SOFTKEYS_OK_CANCEL_SELECT,
|
|
116 |
AknPopupLayouts::EMenuWindow );
|
|
117 |
cbaResource = R_AKNFEP_SOFTKEYS_OK_CANCEL_SELECT;
|
|
118 |
}
|
|
119 |
else
|
|
120 |
{
|
|
121 |
CAknPopupList::ConstructL( iList, R_AKNFEP_SOFTKEYS_SPELL_CANCEL_SELECT,
|
|
122 |
AknPopupLayouts::EMenuWindow );
|
|
123 |
cbaResource = R_AKNFEP_SOFTKEYS_SPELL_CANCEL_SELECT;
|
|
124 |
}
|
|
125 |
// To add new CBA, here set its flag as the base class,
|
|
126 |
// but just not set Embedded flag.
|
|
127 |
TUint flags = CEikButtonGroupContainer::EAddToStack;
|
|
128 |
if ( AknLayoutUtils::PenEnabled() )
|
|
129 |
{
|
|
130 |
flags |= CEikButtonGroupContainer::EDelayActivation;
|
|
131 |
}
|
|
132 |
// Destroy the CBA constructed in base class, and new its own CBA
|
|
133 |
delete iPopoutCba;
|
|
134 |
iPopoutCba = NULL;
|
|
135 |
iPopoutCba = CEikButtonGroupContainer::NewL(
|
|
136 |
CEikButtonGroupContainer::ECba,
|
|
137 |
CEikButtonGroupContainer::EHorizontal,
|
|
138 |
this, cbaResource, *this, flags );
|
|
139 |
|
|
140 |
iList->ConstructL( this, CEikListBox::ELeftDownInViewRect );
|
|
141 |
iList->CreateScrollBarFrameL( ETrue );
|
|
142 |
iList->ScrollBarFrame()->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff, //< horizontal
|
|
143 |
CEikScrollBarFrame::EAuto ); //< vertical
|
|
144 |
iList->SetNonFocusing();
|
|
145 |
|
|
146 |
|
|
147 |
// Construct the item array
|
|
148 |
iCandidates = new (ELeave) CDesCArrayFlat( KPredictiveListCandidateMax );
|
|
149 |
CTextListBoxModel* model = iList->Model();
|
|
150 |
model->SetItemTextArray( iCandidates );
|
|
151 |
model->SetOwnershipType( ELbmDoesNotOwnItemArray );
|
|
152 |
iChrKeypressMonitor = CPeriodic::NewL(CActive::EPriorityStandard);
|
|
153 |
SetNonFocusing();
|
|
154 |
MakeVisible(EFalse);
|
|
155 |
}
|
|
156 |
|
|
157 |
|
|
158 |
MAknFepCandidatePopup::~MAknFepCandidatePopup()
|
|
159 |
{
|
|
160 |
|
|
161 |
}
|
|
162 |
|
|
163 |
/**
|
|
164 |
* Destructor
|
|
165 |
*
|
|
166 |
*/
|
|
167 |
CAknFepAvkonCandidatePopup::~CAknFepAvkonCandidatePopup()
|
|
168 |
{
|
|
169 |
delete iList;
|
|
170 |
delete iCandidates;
|
|
171 |
if( iChrKeypressMonitor )
|
|
172 |
{
|
|
173 |
iChrKeypressMonitor->Cancel();
|
|
174 |
delete iChrKeypressMonitor;
|
|
175 |
iChrKeypressMonitor = NULL;
|
|
176 |
}
|
|
177 |
}
|
|
178 |
|
|
179 |
|
|
180 |
TPtrC CAknFepAvkonCandidatePopup::ActiveWord() const
|
|
181 |
{
|
|
182 |
if ( iCandidates->Count()>*iSelectedIdx && *iSelectedIdx>0 )
|
|
183 |
{
|
|
184 |
return (*iCandidates)[*iSelectedIdx];
|
|
185 |
}
|
|
186 |
else
|
|
187 |
{
|
|
188 |
return TPtrC( KNullDesC );
|
|
189 |
}
|
|
190 |
}
|
|
191 |
|
|
192 |
|
|
193 |
TPtrC CAknFepAvkonCandidatePopup::ExactWord() const
|
|
194 |
{
|
|
195 |
if ( iCandidates->Count() > 0 )
|
|
196 |
{
|
|
197 |
return (*iCandidates)[0];
|
|
198 |
}
|
|
199 |
else
|
|
200 |
{
|
|
201 |
return TPtrC( KNullDesC );
|
|
202 |
}
|
|
203 |
}
|
|
204 |
|
|
205 |
|
|
206 |
/**
|
|
207 |
* Makes the pop-up selection list visible.
|
|
208 |
*
|
|
209 |
* @param aInlineEditorRect Tells the place of the inline editor. If possible, the popup is opened
|
|
210 |
* so that it does not hide the inline editor.
|
|
211 |
*
|
|
212 |
* @param aSelectedIdx Input/output argument for the selected index. If legal index is given in,
|
|
213 |
* it will be used as default selection. Otherwise the default selection will
|
|
214 |
* be the currently active word. On succesful exit this variable contains
|
|
215 |
* the index selected by the user.
|
|
216 |
*
|
|
217 |
* @param aLastKeyEvent The last key event received by the popup. On return this is the event
|
|
218 |
* which closed the popup.
|
|
219 |
*
|
|
220 |
* @return The command id used to close the window. EAknFepSoftkeySpell, EAknSoftkeyCancel, or EAknSoftkeySelect
|
|
221 |
*/
|
|
222 |
TInt CAknFepAvkonCandidatePopup::ExecutePopupL( const TRect& aInlineEditorRect, TInt& aSelectedIdx,
|
|
223 |
TKeyEvent& aLastKeyEvent, TBool aRightToLeftLanguage,
|
|
224 |
TInt aKeyboard )
|
|
225 |
{
|
|
226 |
iSelectedIdx = &aSelectedIdx;
|
|
227 |
iLastKeyEvent = &aLastKeyEvent;
|
|
228 |
iKeyboard = (TPtiKeyboardType)aKeyboard;
|
|
229 |
//This is the inline text rectangle, this is needed in the event of a layout change
|
|
230 |
iInlineTextRect = aInlineEditorRect;
|
|
231 |
|
|
232 |
TInt requestedSelection = *iSelectedIdx;
|
|
233 |
iOwner.GetCandidatesL( *iCandidates, *iSelectedIdx );
|
|
234 |
if ( requestedSelection >= 0 && requestedSelection < iCandidates->Count() )
|
|
235 |
{
|
|
236 |
*iSelectedIdx = requestedSelection;
|
|
237 |
}
|
|
238 |
|
|
239 |
iListBox->SetCurrentItemIndex( *iSelectedIdx );
|
|
240 |
|
|
241 |
iRightToLeftCandidate = aRightToLeftLanguage;
|
|
242 |
|
|
243 |
const TSize screenSize = iAvkonAppUi->ApplicationRect().Size(); //TSize(AKN_LAYOUT_WINDOW_screen.iW,AKN_LAYOUT_WINDOW_screen.iH);
|
|
244 |
iPopoutCba->SetBoundingRect(TRect(screenSize));
|
|
245 |
|
|
246 |
SetupWindowLayout(iWindowType);
|
|
247 |
SetupWindowLocation( aInlineEditorRect );
|
|
248 |
|
|
249 |
iListBox->SetListBoxObserver(this);
|
|
250 |
|
|
251 |
iEikonEnv->RemoveFromStack(this);
|
|
252 |
iEikonEnv->EikAppUi()->AddToStackL(this,ECoeStackPriorityDialog/*ECoeStackPriorityFep*/);
|
|
253 |
|
|
254 |
|
|
255 |
ActivateL();
|
|
256 |
// this is required here to make code like
|
|
257 |
// iList->SetCurrentItemIndex( last item of the list );
|
|
258 |
// iPopupList->ExecuteLD();
|
|
259 |
// to work as it used to. Without this current item of the
|
|
260 |
// list would be topmost item, and there would be unused empty
|
|
261 |
// space below that.
|
|
262 |
iListBox->UpdateScrollBarsL();
|
|
263 |
|
|
264 |
// The main rule is to make the first index (the exact match) visible. However, the active index should never
|
|
265 |
// be hidden.
|
|
266 |
iListBox->ScrollToMakeItemVisible( 0 );
|
|
267 |
if ( iListBox->BottomItemIndex() < *iSelectedIdx )
|
|
268 |
{
|
|
269 |
iListBox->ScrollToMakeItemVisible( *iSelectedIdx );
|
|
270 |
}
|
|
271 |
|
|
272 |
// Ensure that the popup is on top. Without this the popup window is left in the background at least
|
|
273 |
// in the dialogs of the Phonebook application.
|
|
274 |
//Window().SetOrdinalPosition(0);
|
|
275 |
//iPopoutCba->SetContainerWindowL( Window() ); this didn't help
|
|
276 |
|
|
277 |
// Make the popup visible
|
|
278 |
iPopoutCba->MakeVisible(ETrue);
|
|
279 |
iListBox->MakeVisible(ETrue);
|
|
280 |
MakeVisible(ETrue);
|
|
281 |
SetFocus(ETrue);
|
|
282 |
FadeBehindPopup(EFalse);
|
|
283 |
TInt returnValue;
|
|
284 |
iReturn = &returnValue;
|
|
285 |
iLastCommandId = EAknSoftkeySelect;
|
|
286 |
iWait.Start();
|
|
287 |
return returnValue;
|
|
288 |
}
|
|
289 |
|
|
290 |
|
|
291 |
/**
|
|
292 |
* Called when the popup is closed. Unlike the base class, this class does not commit suicide on this situation.
|
|
293 |
*
|
|
294 |
* @return ETrue if the popup was accepted. EFalse if the popup was cancelled
|
|
295 |
*/
|
|
296 |
void CAknFepAvkonCandidatePopup::AttemptExitL(TBool aAccept)
|
|
297 |
{
|
|
298 |
*iSelectedIdx = iList->CurrentItemIndex();
|
|
299 |
|
|
300 |
if (iCoeEnv && iEikonEnv)
|
|
301 |
{
|
|
302 |
iEikonEnv->RemoveFromStack(this);
|
|
303 |
}
|
|
304 |
|
|
305 |
SetFocus(EFalse);
|
|
306 |
MakeVisible(EFalse);
|
|
307 |
ListBox()->MakeVisible(EFalse);
|
|
308 |
iPopoutCba->MakeVisible(EFalse);
|
|
309 |
|
|
310 |
if (iReturn) //Always not null unless ExecutePopupL leaves
|
|
311 |
{
|
|
312 |
if (!aAccept)
|
|
313 |
{
|
|
314 |
*iReturn = EAknSoftkeyCancel;
|
|
315 |
}
|
|
316 |
else
|
|
317 |
{
|
|
318 |
*iReturn = iLastCommandId;
|
|
319 |
}
|
|
320 |
}
|
|
321 |
if(iWait.IsStarted())
|
|
322 |
iWait.AsyncStop();
|
|
323 |
}
|
|
324 |
|
|
325 |
|
|
326 |
void CAknFepAvkonCandidatePopup::HandleResourceChange(TInt aType)
|
|
327 |
{
|
|
328 |
CAknPopupList::HandleResourceChange(aType);
|
|
329 |
//When there is a dynamic layout change, the candidate list position needs to be aligned with
|
|
330 |
//the new position of the inline text.
|
|
331 |
if(aType == KEikDynamicLayoutVariantSwitch)
|
|
332 |
{
|
|
333 |
// Move back candidate popup control priority.
|
|
334 |
iEikonEnv->RemoveFromStack(this);
|
|
335 |
TRAP_IGNORE( iEikonEnv->EikAppUi()->AddToStackL(this, ECoeStackPriorityDialog )) ;
|
|
336 |
// Get candidate update position based on layout.
|
|
337 |
TRAP_IGNORE(iOwner.GetUpdateCandidatePositionL(iInlineTextRect));
|
|
338 |
|
|
339 |
// Ensure that the popup is on top.
|
|
340 |
Window().SetOrdinalPosition(0);
|
|
341 |
|
|
342 |
SetupWindowLocation( iInlineTextRect);
|
|
343 |
DrawNow();
|
|
344 |
}
|
|
345 |
else if(aType == KAknMessageFocusLost)
|
|
346 |
FadeBehindPopup(ETrue);
|
|
347 |
|
|
348 |
}
|
|
349 |
|
|
350 |
|
|
351 |
void CAknFepAvkonCandidatePopup::UnFocus()
|
|
352 |
{
|
|
353 |
//Remove the candidate list from the control stack so that it does not receive any key event.
|
|
354 |
if (iCoeEnv && iEikonEnv)
|
|
355 |
{
|
|
356 |
iEikonEnv->RemoveFromStack(this);
|
|
357 |
}
|
|
358 |
//Un-Focus the candidate list
|
|
359 |
SetFocus(EFalse);
|
|
360 |
}
|
|
361 |
void CAknFepAvkonCandidatePopup::ShowAtNewPosition(TRect aRect)
|
|
362 |
{
|
|
363 |
if (iCoeEnv && iEikonEnv)
|
|
364 |
{
|
|
365 |
TRAP_IGNORE( iEikonEnv->EikAppUi()->AddToStackL(this,ECoeStackPriorityDialog/*ECoeStackPriorityFep*/ ));
|
|
366 |
}
|
|
367 |
SetFocus(ETrue);
|
|
368 |
iInlineTextRect = aRect;
|
|
369 |
SetupWindowLocation( iInlineTextRect);
|
|
370 |
DrawNow();
|
|
371 |
}
|
|
372 |
|
|
373 |
void CAknFepAvkonCandidatePopup::SetFocusAddStackReducePriorityL()
|
|
374 |
{
|
|
375 |
if (iCoeEnv && iEikonEnv)
|
|
376 |
{
|
|
377 |
iEikonEnv->EikAppUi()->AddToStackL(this, ECoeStackPriorityDefault-1/*ECoeStackPriorityDialog-1*/ );
|
|
378 |
}
|
|
379 |
SetFocus(ETrue);
|
|
380 |
}
|
|
381 |
|
|
382 |
TInt CAknFepAvkonCandidatePopup::HandleChrKeyMonitorCallback(TAny* aParam)
|
|
383 |
{
|
|
384 |
// the timer will be cancelled only when the key up event is received
|
|
385 |
// the down arrow key event is simulated now
|
|
386 |
TKeyEvent keyEvent;
|
|
387 |
keyEvent.iCode = EKeyDownArrow;
|
|
388 |
// TEventCode type = EEventKey;
|
|
389 |
TRAP_IGNORE( ((CAknFepAvkonCandidatePopup*)aParam)->ListBox()->OfferKeyEventL(keyEvent, EEventKey) );
|
|
390 |
// Prevent the screen saver
|
|
391 |
User::ResetInactivityTime();
|
|
392 |
return 1;
|
|
393 |
}
|
|
394 |
|
|
395 |
/**
|
|
396 |
* Modified from CAknPopupList::OfferKeyEventL().
|
|
397 |
*/
|
|
398 |
TKeyResponse CAknFepAvkonCandidatePopup::OfferKeyEventL(const TKeyEvent& aKeyEvent,
|
|
399 |
TEventCode aType)
|
|
400 |
{
|
|
401 |
*iLastKeyEvent = aKeyEvent;
|
|
402 |
|
|
403 |
// Selection key is substituted with the space key. Thus, selecting a candidate with the selection
|
|
404 |
// key auto-appends space character.
|
|
405 |
if ( aKeyEvent.iScanCode == EStdKeyDevice3 )
|
|
406 |
{
|
|
407 |
//iLastKeyEvent->iScanCode = EStdKeySpace;
|
|
408 |
iLastKeyEvent->iCode = EKeyOK;
|
|
409 |
}
|
|
410 |
// Asterisk is substituted with arrow down key to get same functionality in ITU-T keypads
|
|
411 |
// Emulator sends key event with scancode EStdKeyNkpAsterisk and hardware an event
|
|
412 |
// with code '*' so we check for both
|
|
413 |
else if ( ( (aKeyEvent.iScanCode == EStdKeyNkpAsterisk || aKeyEvent.iCode == '*' )
|
|
414 |
&& iKeyboard == EPtiKeyboard12Key ) )
|
|
415 |
{
|
|
416 |
iLastKeyEvent->iCode = EKeyDownArrow;
|
|
417 |
}
|
|
418 |
else if( aKeyEvent.iScanCode == EStdKeyLeftFunc
|
|
419 |
&& iKeyboard == EPtiKeyboardHalfQwerty )
|
|
420 |
{
|
|
421 |
if( aType == EEventKeyDown)
|
|
422 |
{
|
|
423 |
iLastKeyEvent->iCode = EKeyDownArrow;
|
|
424 |
// start the timer
|
|
425 |
if(iChrKeypressMonitor->IsActive())
|
|
426 |
{
|
|
427 |
iChrKeypressMonitor->Cancel();
|
|
428 |
}
|
|
429 |
iChrKeypressMonitor->Start( KChrKeyRepeatDelay, KChrKeyTimeout,
|
|
430 |
TCallBack(HandleChrKeyMonitorCallback, this));
|
|
431 |
|
|
432 |
aType = EEventKey;
|
|
433 |
}
|
|
434 |
else
|
|
435 |
{
|
|
436 |
iChrKeypressMonitor->Cancel();
|
|
437 |
return EKeyWasNotConsumed;
|
|
438 |
}
|
|
439 |
}
|
|
440 |
// this must be first check, since window will be faded when fast
|
|
441 |
// swap window is visible
|
|
442 |
if (aType==EEventKey && aKeyEvent.iCode == EKeyEscape)
|
|
443 |
{
|
|
444 |
AttemptExitL(EFalse);
|
|
445 |
return EKeyWasConsumed;
|
|
446 |
}
|
|
447 |
|
|
448 |
if ( Window().IsFaded() )
|
|
449 |
{
|
|
450 |
// this happens, when popuplist has a findbox, and user
|
|
451 |
// presses shift to launch fep menu. Fep menu has priority menu
|
|
452 |
// in control stack, but we have dialog priority. As result,
|
|
453 |
// keyevents will get here first. If we return
|
|
454 |
// EKeyWasNotConsumed, fep menu will catch those events
|
|
455 |
// next.
|
|
456 |
return EKeyWasNotConsumed;
|
|
457 |
}
|
|
458 |
|
|
459 |
TBool needRefresh = EFalse;
|
|
460 |
TKeyResponse res = AknFind::HandleFindOfferKeyEventL(aKeyEvent, aType, this,
|
|
461 |
ListBox(), FindBox(), EFalse, needRefresh);
|
|
462 |
|
|
463 |
if (needRefresh && FindBox())
|
|
464 |
{
|
|
465 |
DrawNow();
|
|
466 |
}
|
|
467 |
|
|
468 |
if ( res == EKeyWasConsumed )
|
|
469 |
{
|
|
470 |
return res;
|
|
471 |
}
|
|
472 |
|
|
473 |
if (aType==EEventKey)
|
|
474 |
{
|
|
475 |
// Handle arrow keys based on iScancode
|
|
476 |
TBool keyEventHandled = EFalse;
|
|
477 |
switch (iLastKeyEvent->iScanCode)
|
|
478 |
{
|
|
479 |
case EStdKeyUpArrow: //fall through
|
|
480 |
case EStdKeyDownArrow:
|
|
481 |
keyEventHandled = ETrue;
|
|
482 |
return iListBox->OfferKeyEventL(*iLastKeyEvent, aType);
|
|
483 |
|
|
484 |
case EStdKeyLeftArrow:
|
|
485 |
if(iRightToLeftCandidate)
|
|
486 |
// These keys confirm the selection and are then handled by AknFepManager
|
|
487 |
AttemptExitL(ETrue);
|
|
488 |
else
|
|
489 |
// These keys cancel the selection and are then handled by AknFepManager
|
|
490 |
AttemptExitL(EFalse);
|
|
491 |
keyEventHandled = ETrue;
|
|
492 |
return EKeyWasConsumed;
|
|
493 |
|
|
494 |
case EStdKeyRightArrow:
|
|
495 |
if(iRightToLeftCandidate)
|
|
496 |
// These keys cancel the selection and are then handled by AknFepManager
|
|
497 |
AttemptExitL(EFalse);
|
|
498 |
else
|
|
499 |
// These keys confirm the selection and are then handled by AknFepManager
|
|
500 |
AttemptExitL(ETrue);
|
|
501 |
keyEventHandled = ETrue;
|
|
502 |
return EKeyWasConsumed;
|
|
503 |
|
|
504 |
}
|
|
505 |
if (!keyEventHandled)
|
|
506 |
{
|
|
507 |
// Handle through iCode
|
|
508 |
switch (iLastKeyEvent->iCode)
|
|
509 |
{
|
|
510 |
|
|
511 |
case EKeyUpArrow: //fall through
|
|
512 |
case EKeyDownArrow:
|
|
513 |
return iListBox->OfferKeyEventL(*iLastKeyEvent, aType);
|
|
514 |
|
|
515 |
case EKeyLeftArrow:
|
|
516 |
if(iRightToLeftCandidate)
|
|
517 |
// These keys confirm the selection and are then handled by AknFepManager
|
|
518 |
AttemptExitL(ETrue);
|
|
519 |
else
|
|
520 |
// These keys cancel the selection and are then handled by AknFepManager
|
|
521 |
AttemptExitL(EFalse);
|
|
522 |
return EKeyWasConsumed;
|
|
523 |
|
|
524 |
case EKeyRightArrow:
|
|
525 |
if(iRightToLeftCandidate)
|
|
526 |
// These keys cancel the selection and are then handled by AknFepManager
|
|
527 |
AttemptExitL(EFalse);
|
|
528 |
else
|
|
529 |
// These keys confirm the selection and are then handled by AknFepManager
|
|
530 |
AttemptExitL(ETrue);
|
|
531 |
|
|
532 |
return EKeyWasConsumed;
|
|
533 |
|
|
534 |
|
|
535 |
case EKeyEnter:
|
|
536 |
case EKeyOK:
|
|
537 |
case EKeySpace:
|
|
538 |
case EKeyTab:
|
|
539 |
default:
|
|
540 |
// These keys confirm the selection and are then handled by AknFepManager
|
|
541 |
AttemptExitL(ETrue);
|
|
542 |
return EKeyWasConsumed;
|
|
543 |
case EKeyApplication:
|
|
544 |
case EKeyPhoneEnd:
|
|
545 |
// Flip open close event.
|
|
546 |
case EKeyFlipOpen:
|
|
547 |
case EKeyFlipClose:
|
|
548 |
AttemptExitL(EFalse);
|
|
549 |
return EKeyWasNotConsumed;
|
|
550 |
|
|
551 |
}
|
|
552 |
}
|
|
553 |
}
|
|
554 |
|
|
555 |
// For Layout switching
|
|
556 |
// If user switch the layout, means QWERTY to ITU-T and vice versa
|
|
557 |
// Keyboard layout going to cahnge, So, not need to open the candidate
|
|
558 |
// list as it is, becz its may predict differnt list of word.
|
|
559 |
if (aKeyEvent.iScanCode == EStdKeyApplicationE ||
|
|
560 |
aKeyEvent.iScanCode == EStdKeyApplication10 ||
|
|
561 |
aKeyEvent.iScanCode == EStdKeyDeviceF ||
|
|
562 |
aKeyEvent.iScanCode == EStdKeyDeviceA ||
|
|
563 |
aKeyEvent.iScanCode == EStdKeyApplication12 ||
|
|
564 |
aKeyEvent.iScanCode == EStdKeyApplication15 ||
|
|
565 |
aKeyEvent.iScanCode == EStdKeyApplication16 ||
|
|
566 |
aKeyEvent.iScanCode == EStdKeyDeviceB)
|
|
567 |
{
|
|
568 |
AttemptExitL(EFalse);
|
|
569 |
return EKeyWasConsumed;
|
|
570 |
}
|
|
571 |
|
|
572 |
return EKeyWasNotConsumed;
|
|
573 |
}
|
|
574 |
|
|
575 |
|
|
576 |
/**
|
|
577 |
* Process commands from CBA buttons.
|
|
578 |
* @param aCommandId The command to handle.
|
|
579 |
*/
|
|
580 |
void CAknFepAvkonCandidatePopup::ProcessCommandL(TInt aCommandId)
|
|
581 |
{
|
|
582 |
iLastCommandId = aCommandId;
|
|
583 |
if (aCommandId==EAknFepSoftkeySpell
|
|
584 |
|| aCommandId == EAknSoftkeyOk)
|
|
585 |
{
|
|
586 |
AttemptExitL(ETrue);
|
|
587 |
}
|
|
588 |
else
|
|
589 |
{
|
|
590 |
CAknPopupList::ProcessCommandL(aCommandId);
|
|
591 |
}
|
|
592 |
}
|
|
593 |
|
|
594 |
|
|
595 |
/**
|
|
596 |
* Calculates the position for the popup window and places it there
|
|
597 |
* @param aInlineEditorRect The placement of the inline editor is used as reference.
|
|
598 |
* The inline editor is not hidden if possible.
|
|
599 |
*/
|
|
600 |
void CAknFepAvkonCandidatePopup::SetupWindowLocation( const TRect& aInlineEditorRect )
|
|
601 |
{
|
|
602 |
TRect clientRect;
|
|
603 |
AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, clientRect);
|
|
604 |
|
|
605 |
TRect popupRect = Rect();
|
|
606 |
|
|
607 |
// 1. Is it possible to place the popup under the inline editor
|
|
608 |
if ( aInlineEditorRect.iBr.iY + popupRect.Height() < clientRect.iBr.iY )
|
|
609 |
{
|
|
610 |
SetPosition( TPoint(aInlineEditorRect.iTl.iX, aInlineEditorRect.iBr.iY) );
|
|
611 |
}
|
|
612 |
|
|
613 |
// 2. Is it possible to place the popup on the right side of the inline editor
|
|
614 |
else if ( aInlineEditorRect.iBr.iX + popupRect.Width() < clientRect.iBr.iX )
|
|
615 |
{
|
|
616 |
SetPosition( TPoint(aInlineEditorRect.iBr.iX, aInlineEditorRect.iTl.iY) );
|
|
617 |
}
|
|
618 |
|
|
619 |
// 3. Is it possible to place the popup above the inline editor
|
|
620 |
else if ( aInlineEditorRect.iTl.iY > popupRect.Height() )
|
|
621 |
{
|
|
622 |
SetPosition( aInlineEditorRect.iTl - TPoint(0, popupRect.Height()) );
|
|
623 |
}
|
|
624 |
|
|
625 |
// 4. Is it possible to place the popup on the left side of the inline editor
|
|
626 |
else if ( aInlineEditorRect.iTl.iX > popupRect.Width() )
|
|
627 |
{
|
|
628 |
SetPosition( aInlineEditorRect.iTl - TPoint(popupRect.Width(), 0) );
|
|
629 |
}
|
|
630 |
|
|
631 |
// 5. If everything else fails, place the popup in the center of the screen
|
|
632 |
else
|
|
633 |
{
|
|
634 |
TInt xMargins = clientRect.Width() - popupRect.Width();
|
|
635 |
TInt yMargins = clientRect.Height() - popupRect.Height();
|
|
636 |
SetPosition( TPoint(xMargins/2, yMargins/2) );
|
|
637 |
}
|
|
638 |
|
|
639 |
|
|
640 |
|
|
641 |
// Shift popup to left if necessary
|
|
642 |
if ( Position().iX + popupRect.Width() > clientRect.iBr.iX )
|
|
643 |
{
|
|
644 |
SetPosition( TPoint(clientRect.iBr.iX-popupRect.Width(), Position().iY) );
|
|
645 |
}
|
|
646 |
|
|
647 |
// Shift popup upwards if necessary
|
|
648 |
if ( Position().iY + popupRect.Height() > clientRect.iBr.iY )
|
|
649 |
{
|
|
650 |
SetPosition( TPoint(Position().iX, clientRect.iBr.iY-popupRect.Height()) );
|
|
651 |
}
|
|
652 |
}
|
|
653 |
|
|
654 |
|
|
655 |
/**
|
|
656 |
* Sets up the layout of the popup window.
|
|
657 |
* Modified from CAknPopupList::SetupWindowLayout()
|
|
658 |
*/
|
|
659 |
void CAknFepAvkonCandidatePopup::SetupWindowLayout(AknPopupLayouts::TAknPopupLayouts aType)
|
|
660 |
{
|
|
661 |
// A linked list for HandleSizeChanged().
|
|
662 |
TAknPopupLayoutsNode list = { 0, EListNode, ListBox() };
|
|
663 |
TAknPopupLayoutsNode heading = { &list, EHeadingNode, Heading() };
|
|
664 |
TAknPopupLayoutsNode windowOwning = { &heading, EWindowOwningNode, this };
|
|
665 |
TAknPopupLayoutsNode findPane = { &windowOwning, EFindBoxNode, FindBox() };
|
|
666 |
TAknPopupLayoutsNode *listBegin = &findPane;
|
|
667 |
|
|
668 |
HandleSizeChanged( Layout(), aType, listBegin );
|
|
669 |
|
|
670 |
// create skin context for popuplist (list itemdrawer uses normal list skinning)
|
|
671 |
TRect windowRect = Rect();
|
|
672 |
|
|
673 |
TAknLayoutRect topLeft;
|
|
674 |
topLeft.LayoutRect(windowRect,
|
|
675 |
SkinLayout::Popup_windows_skin_placing__frame_general__Line_2());
|
|
676 |
|
|
677 |
TAknLayoutRect bottomRight;
|
|
678 |
bottomRight.LayoutRect(windowRect,
|
|
679 |
SkinLayout::Popup_windows_skin_placing__frame_general__Line_5());
|
|
680 |
|
|
681 |
TRect outerRect = TRect(topLeft.Rect().iTl, bottomRight.Rect().iBr);
|
|
682 |
TRect innerRect = TRect(topLeft.Rect().iBr, bottomRight.Rect().iTl);
|
|
683 |
|
|
684 |
// we can safely use FormattedCellData only if normal popup layouts are in use
|
|
685 |
switch(iWindowType)
|
|
686 |
{
|
|
687 |
case AknPopupLayouts::EMenuUnknownColumnWindow:
|
|
688 |
case AknPopupLayouts::EMenuUnknownFormattedCellWindow:
|
|
689 |
break;
|
|
690 |
default:
|
|
691 |
{
|
|
692 |
CFormattedCellListBoxData *boxData =
|
|
693 |
((CEikFormattedCellListBox*)ListBox())->ItemDrawer()->FormattedCellData();
|
|
694 |
|
|
695 |
boxData->SetSkinPopupFrame(&KAknsIIDQsnFrPopup,&KAknsIIDQsnFrPopupCenter);
|
|
696 |
boxData->SetSkinPopupFramePosition(outerRect,innerRect);
|
|
697 |
}
|
|
698 |
break;
|
|
699 |
}
|
|
700 |
|
|
701 |
//CListItemDrawer::SetItemCellSize needs to be called to set the selection bar width
|
|
702 |
TSize cellSize = iList->ItemDrawer()->ItemCellSize();
|
|
703 |
cellSize.iWidth = iLayout.iListRect.Rect().Width();
|
|
704 |
iList->ItemDrawer()->SetItemCellSize( cellSize );
|
|
705 |
}
|
|
706 |
|
|
707 |
|
|
708 |
/**
|
|
709 |
* Calculates the width of the popup window based on the candidates available on the list.
|
|
710 |
* The with is always set to as small as possible without truncation.
|
|
711 |
* The client application area is used as reference to ensure that the popup is never wider
|
|
712 |
* than the application area.
|
|
713 |
*/
|
|
714 |
TInt CAknFepAvkonCandidatePopup::CalculateWindowWidth( const TRect& aClientRect )
|
|
715 |
{
|
|
716 |
// Fetch the font
|
|
717 |
const CFont* font = AknLayoutUtils::FontFromId(AKN_LAYOUT_TEXT_List_pane_texts__menu_single__Line_1(0).FontId());
|
|
718 |
|
|
719 |
TInt maxTextWidth = 0;
|
|
720 |
|
|
721 |
for (TInt i=0 ; i<iCandidates->Count() ; ++i)
|
|
722 |
{
|
|
723 |
TInt curTextWidth = font->TextWidthInPixels( (*iCandidates)[i] );
|
|
724 |
if ( curTextWidth > maxTextWidth )
|
|
725 |
{
|
|
726 |
maxTextWidth = curTextWidth;
|
|
727 |
}
|
|
728 |
}
|
|
729 |
|
|
730 |
TInt popupWidth = maxTextWidth + ( 2 * font->MaxCharWidthInPixels() );
|
|
731 |
|
|
732 |
// Modified as per Avkon team's suggestions
|
|
733 |
// From Avkon:-
|
|
734 |
// Layout data of listscroll_menu_pane are changed for CR 417-35260.
|
|
735 |
// The change is just for QHD landscape model.
|
|
736 |
// The CR makes listscroll_menu_pane's ir or il bigger than normal,
|
|
737 |
// so that width of list item is smaller than needs. Then, first cell
|
|
738 |
// of list item can not be drawn on proper position.
|
|
739 |
// Adjustment of layout is a solution for this problem. This is not a perfect idea, but
|
|
740 |
// creating a new layout for popuplist is too complex to do that. Adjustment is a must.
|
|
741 |
|
|
742 |
if ( Layout_Meta_Data::IsLandscapeOrientation() )
|
|
743 |
{
|
|
744 |
const TSize screenSize = iAvkonAppUi->ApplicationRect().Size();
|
|
745 |
|
|
746 |
if( KScreenWidthQHDLandscape == screenSize.iWidth &&
|
|
747 |
KScreenHeightQHDLandscape == screenSize.iHeight )
|
|
748 |
{
|
|
749 |
popupWidth += KOffsetWidthForCandidatePopup;
|
|
750 |
}
|
|
751 |
}
|
|
752 |
|
|
753 |
if ( popupWidth > aClientRect.Width() )
|
|
754 |
{
|
|
755 |
popupWidth = aClientRect.Width();
|
|
756 |
}
|
|
757 |
|
|
758 |
return popupWidth;
|
|
759 |
}
|
|
760 |
|
|
761 |
|
|
762 |
/**
|
|
763 |
* Utility function copied from aknpopuplayout.cpp
|
|
764 |
*/
|
|
765 |
static CCoeControl *FindControl(TAknPopupLayoutsNode *aNode, TInt aId)
|
|
766 |
{
|
|
767 |
while(aNode)
|
|
768 |
{
|
|
769 |
if (aId == aNode->iId)
|
|
770 |
{
|
|
771 |
return aNode->iControl;
|
|
772 |
}
|
|
773 |
aNode = aNode -> iNext;
|
|
774 |
}
|
|
775 |
return NULL;
|
|
776 |
}
|
|
777 |
|
|
778 |
/**
|
|
779 |
* Utility function copied from aknpopuplayout.cpp
|
|
780 |
*/
|
|
781 |
static TInt GetMaxListHeight()
|
|
782 |
{
|
|
783 |
TAknLayoutRect temp, layout;
|
|
784 |
|
|
785 |
TRect mainPane;
|
|
786 |
TRect statusPane;
|
|
787 |
TRect controlPane;
|
|
788 |
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, mainPane );
|
|
789 |
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EStatusPane, statusPane );
|
|
790 |
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EControlPane, controlPane );
|
|
791 |
|
|
792 |
// in landscape orientation popuplist can't go on top of statuspane
|
|
793 |
if ( !Layout_Meta_Data::IsLandscapeOrientation() )
|
|
794 |
{
|
|
795 |
mainPane.iTl.iY -= statusPane.Height();
|
|
796 |
}
|
|
797 |
|
|
798 |
|
|
799 |
// treat mainpane+statuspane area as popup window
|
|
800 |
// too bad we can't use this, because e.g. QVGA landscape has border-size 7
|
|
801 |
// in avkon layout and border-size 9 in skin drawing...
|
|
802 |
/*temp.LayoutRect( mainPane, AknLayoutScalable_Avkon::listscroll_menu_pane(0));
|
|
803 |
layout.LayoutRect( temp.Rect(), AknLayoutScalable_Avkon::list_menu_pane(0));
|
|
804 |
return layout.Rect().Height();*/
|
|
805 |
|
|
806 |
// shadow
|
|
807 |
TInt varietyIndex = Layout_Meta_Data::IsLandscapeOrientation();
|
|
808 |
|
|
809 |
TAknLayoutRect insideArea;
|
|
810 |
insideArea.LayoutRect(
|
|
811 |
mainPane,
|
|
812 |
AknLayoutScalable_Avkon::bg_popup_window_pane_g1(varietyIndex) );
|
|
813 |
|
|
814 |
return insideArea.Rect().Height();
|
|
815 |
}
|
|
816 |
|
|
817 |
/**
|
|
818 |
* Modified from AknPopupLayouts::HandleSizeChanged()
|
|
819 |
*/
|
|
820 |
void CAknFepAvkonCandidatePopup::HandleSizeChanged( TAknPopupWindowLayoutDef &aDef,
|
|
821 |
AknPopupLayouts::TAknPopupLayouts /*aLayout_1*/,
|
|
822 |
TAknPopupLayoutsNode *aNode)
|
|
823 |
{
|
|
824 |
CAknPopupHeadingPane *heading = (CAknPopupHeadingPane*)FindControl(aNode, EHeadingNode);
|
|
825 |
CEikListBox *listBox = (CEikListBox*)FindControl(aNode, EListNode);
|
|
826 |
CCoeControl *windowOwningControl = FindControl(aNode, EWindowOwningNode);
|
|
827 |
//CAknMessageQueryControl *msgQueryCtrl = (CAknMessageQueryControl*)FindControl(aNode, EMessageBoxNode);
|
|
828 |
|
|
829 |
//TInt layout = aLayout_1;
|
|
830 |
TInt numofitems = listBox->Model()->NumberOfItems();
|
|
831 |
|
|
832 |
TRAP_IGNORE( listBox->View()->ItemDrawer()->SetSkinEnabledL(ETrue) );
|
|
833 |
|
|
834 |
TInt maxListHeight = GetMaxListHeight();
|
|
835 |
|
|
836 |
// position popup window's bottom correctly
|
|
837 |
TRect clientRect;
|
|
838 |
AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, clientRect);
|
|
839 |
// set windowrect to minimum size - this will be adjusted later
|
|
840 |
TAknLayoutRect windowRect;
|
|
841 |
windowRect.LayoutRect( clientRect, AknLayoutScalable_Avkon::popup_menu_window(8));
|
|
842 |
|
|
843 |
aDef.iWindowRect = windowRect.Rect();
|
|
844 |
aDef.iWindowRect.SetWidth( CalculateWindowWidth(clientRect) );
|
|
845 |
TRAP_IGNORE( listBox->View()->ItemDrawer()->SetSkinEnabledL(ETrue) );
|
|
846 |
|
|
847 |
TInt minItems = 1;
|
|
848 |
|
|
849 |
TAknWindowLineLayout listLayout;
|
|
850 |
TAknLayoutScalableParameterLimits listLimits;
|
|
851 |
|
|
852 |
listLayout = AknLayoutScalable_Avkon::list_single_pane_cp2(0);
|
|
853 |
listLimits = AknLayoutScalable_Avkon::list_single_pane_cp2_ParamLimits();
|
|
854 |
|
|
855 |
TInt maxLayoutItems = listLimits.LastRow() + 1; // last row is a zero based index, we need num items which is 1 based
|
|
856 |
|
|
857 |
TAknLayoutRect listItemRect;
|
|
858 |
listItemRect.LayoutRect( aDef.iWindowRect, listLayout);
|
|
859 |
TInt listItemHeight = listItemRect.Rect().Height();
|
|
860 |
TInt maxItems = maxListHeight / listItemHeight;
|
|
861 |
// minItems == 1 only if the popuplist is dynamically changeable
|
|
862 |
if ( (numofitems > 1) && (minItems == 1) )
|
|
863 |
{
|
|
864 |
minItems = numofitems;
|
|
865 |
}
|
|
866 |
if (minItems > maxItems)
|
|
867 |
{
|
|
868 |
minItems = maxItems;
|
|
869 |
}
|
|
870 |
// maxItems might be greater than max items from layout -> use layout's maximum
|
|
871 |
if (minItems > maxLayoutItems)
|
|
872 |
{
|
|
873 |
minItems = maxLayoutItems;
|
|
874 |
}
|
|
875 |
|
|
876 |
TRect window_rect = AknPopupLayouts::MenuRect(aDef);
|
|
877 |
|
|
878 |
TAknLayoutRect temp, layout;
|
|
879 |
temp.LayoutRect( window_rect, AknLayoutScalable_Avkon::listscroll_menu_pane(0));
|
|
880 |
layout.LayoutRect( temp.Rect(), AknLayoutScalable_Avkon::list_menu_pane(0));
|
|
881 |
|
|
882 |
|
|
883 |
TRect tempListRect = layout.Rect(); // this is list's rect for the whole window
|
|
884 |
|
|
885 |
// We really don't want parent relative list layout here because findbox will be overwritten.
|
|
886 |
// Just calculate list height and use that.
|
|
887 |
TRect nullRect(0,0,0,0);
|
|
888 |
listLayout.iH = (TInt16)(minItems * listItemHeight);
|
|
889 |
listLayout.ib = ELayoutEmpty;
|
|
890 |
|
|
891 |
aDef.iListRect.LayoutRect(tempListRect,
|
|
892 |
listLayout);
|
|
893 |
|
|
894 |
// we have to scale iWindowRect to list rect - layout is not (yet) correct
|
|
895 |
TInt usedHeight = aDef.iListRect.Rect().Height();
|
|
896 |
|
|
897 |
// popupwindow's inside area
|
|
898 |
TInt varietyIndex = Layout_Meta_Data::IsLandscapeOrientation();
|
|
899 |
|
|
900 |
TAknLayoutRect insideArea;
|
|
901 |
insideArea.LayoutRect(
|
|
902 |
window_rect,
|
|
903 |
AknLayoutScalable_Avkon::bg_popup_window_pane_g1(varietyIndex) );
|
|
904 |
|
|
905 |
if (layout.Rect().Height() < usedHeight)
|
|
906 |
{
|
|
907 |
aDef.iWindowRect.iTl.iY -= (usedHeight - layout.Rect().Height());
|
|
908 |
}
|
|
909 |
|
|
910 |
|
|
911 |
// now we finally know the window rect
|
|
912 |
AknPopupLayouts::MenuPopupWindowGraphics(aDef);
|
|
913 |
|
|
914 |
TAknWindowLineLayout line = AknLayoutScalable_Avkon::listscroll_menu_pane(0).LayoutLine();
|
|
915 |
|
|
916 |
layout.LayoutRect(AknPopupLayouts::MenuRect(aDef), line);
|
|
917 |
TRect scrollBarClientRect(layout.Rect());
|
|
918 |
|
|
919 |
varietyIndex = 0;
|
|
920 |
AknLayoutUtils::LayoutVerticalScrollBar(
|
|
921 |
listBox->ScrollBarFrame(),
|
|
922 |
scrollBarClientRect,
|
|
923 |
AknLayoutScalable_Avkon::scroll_pane_cp25(varietyIndex).LayoutLine() ) ;
|
|
924 |
|
|
925 |
windowOwningControl->SetRect(AknPopupLayouts::WindowRect(aDef));
|
|
926 |
AknPopupLayouts::HandleSizeAndPositionOfComponents(aDef, listBox, heading);
|
|
927 |
|
|
928 |
window_rect = AknPopupLayouts::WindowRect(aDef);
|
|
929 |
MAknsControlContext *cc = AknsDrawUtils::ControlContext( listBox );
|
|
930 |
TBool defaultContext = EFalse;
|
|
931 |
if (!cc)
|
|
932 |
{
|
|
933 |
cc = listBox->View()->ItemDrawer()->SkinBackgroundControlContext();
|
|
934 |
defaultContext = ETrue;
|
|
935 |
}
|
|
936 |
if (cc)
|
|
937 |
{
|
|
938 |
CAknsBasicBackgroundControlContext *bcc = (CAknsBasicBackgroundControlContext*)cc;
|
|
939 |
TAknLayoutRect popupBgRect;
|
|
940 |
popupBgRect.LayoutRect(window_rect,
|
|
941 |
SkinLayout::Popup_windows_skin_placing__background_slice__Line_1(window_rect));
|
|
942 |
|
|
943 |
bcc->SetBitmap(KAknsIIDQsnFrPopupCenter);
|
|
944 |
if (defaultContext) bcc->SetRect(popupBgRect.Rect());
|
|
945 |
bcc->SetParentPos(windowOwningControl->PositionRelativeToScreen());
|
|
946 |
if (defaultContext)
|
|
947 |
bcc->SetParentPos(TPoint(0,0));
|
|
948 |
}
|
|
949 |
}
|
|
950 |
|
|
951 |
// end of file
|