branch | RCL_3 |
changeset 19 | aecbbf00d063 |
parent 15 | c52421ed5f07 |
child 20 | d48ab3b357f1 |
18:fcdfafb36fe7 | 19:aecbbf00d063 |
---|---|
1 /* |
1 /* |
2 * Copyright (c) 2006-2010 Nokia Corporation and/or its subsidiary(-ies). |
2 * Copyright (c) 2006, 2007 Nokia Corporation and/or its subsidiary(-ies). |
3 * All rights reserved. |
3 * All rights reserved. |
4 * This component and the accompanying materials are made available |
4 * This component and the accompanying materials are made available |
5 * under the terms of "Eclipse Public License v1.0" |
5 * under the terms of "Eclipse Public License v1.0" |
6 * which accompanies this distribution, and is available |
6 * which accompanies this distribution, and is available |
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
24 #include <barsread.h> |
24 #include <barsread.h> |
25 #include <aknappui.h> |
25 #include <aknappui.h> |
26 #include <aknitemactionmenu.h> |
26 #include <aknitemactionmenu.h> |
27 #include <AknTasHook.h> // for testability hooks |
27 #include <AknTasHook.h> // for testability hooks |
28 #include <AknPriv.hrh> |
28 #include <AknPriv.hrh> |
29 #include <AknIconArray.h> |
|
30 #include <avkon.mbg> |
|
31 #include <gulicon.h> |
|
32 #include <aknmarkingmodeobserver.h> |
|
33 #include "akntreelistview.h" |
29 #include "akntreelistview.h" |
34 #include "akntree.h" |
30 #include "akntree.h" |
35 #include "akntreelist.h" |
31 #include "akntreelist.h" |
36 #include "akntreeiterator.h" |
32 #include "akntreeiterator.h" |
37 #include "akntreelistphysicshandler.h" |
33 #include "akntreelistphysicshandler.h" |
38 |
34 |
39 #include "akntrace.h" |
35 |
40 |
36 |
41 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
37 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
42 |
38 |
43 #include <aknlistboxtfxinternal.h> // LISTBOX EFFECTS IMPLEMENTATION |
39 #include <aknlistboxtfxinternal.h> // LISTBOX EFFECTS IMPLEMENTATION |
44 #include <aknlistloadertfx.h> |
40 #include <aknlistloadertfx.h> |
51 const TInt KLongPressInterval = 600000; // 0.6 seconds |
47 const TInt KLongPressInterval = 600000; // 0.6 seconds |
52 |
48 |
53 // Number of additional items to draw |
49 // Number of additional items to draw |
54 const TInt KAdditionalItems = 2; |
50 const TInt KAdditionalItems = 2; |
55 |
51 |
56 // Number of icons in marking mode icon array |
|
57 const TInt KMarkingModeIconArraySize = 2; |
|
58 |
52 |
59 // Tree list view flag definitions. |
53 // Tree list view flag definitions. |
60 enum TAknTreeListViewFlags |
54 enum TAknTreeListViewFlags |
61 { |
55 { |
62 EFlagStructureLines, |
56 EFlagStructureLines, |
63 EFlagIndention, |
57 EFlagIndention, |
64 EFlagLooping, |
58 EFlagLooping, |
65 EFlagUpdateBackground, |
59 EFlagUpdateBackground, |
66 EFlagMarkingEnabled, // Marking of list items is enabled. |
60 EFlagMarkingEnabled, // Marking of list items is enabled. |
67 EFlagMarkingState, // List in marking state (MSK controlled by list). |
61 EFlagMarkingMode, // List in marking mode (MSK controlled by list). |
68 EFlagMark, // List items are being marked. |
62 EFlagMark, // List items are being marked. |
69 EFlagUnmark, // List items are being unmarked. |
63 EFlagUnmark, // List items are being unmarked. |
70 EFlagSimultaneousMarking, // Simultaneous marking ongoing. |
64 EFlagSimultaneousMarking, // Simultaneous marking ongoing. |
71 EFlagHashKeyPressed, |
65 EFlagHashKeyPressed, |
72 EFlagCtrlKeyPressed, |
66 EFlagCtrlKeyPressed, |
73 EFlagShiftKeyPressed, |
67 EFlagShiftKeyPressed, |
74 EFlagSaveFocusAfterSorting, |
68 EFlagSaveFocusAfterSorting, |
75 EFlagSingleClickEnabled, |
69 EFlagSingleClickEnabled, |
76 EFlagHighlightEnabled, // Is highlight drawing enabled |
70 EFlagHighlightEnabled, // Is highlight drawing enabled |
77 EFlagIsPressedDownState, |
71 EFlagIgnoreButtonUpEvent // Up event ignored (when styluspopup menu open) |
78 EFlagIsDragged, |
|
79 EFlagScrollPhysicsTop, // Physics view adjusted according to top item |
|
80 EFlagMirroredLayoutInUse, // Mirrored layout in use |
|
81 EFlagMarkingMode // Marking mode activated |
|
82 }; |
72 }; |
83 |
73 |
84 |
74 |
85 // ======== MEMBER FUNCTIONS ======== |
75 // ======== MEMBER FUNCTIONS ======== |
86 |
76 |
120 { |
110 { |
121 iItemActionMenu->RemoveCollection( *this ); |
111 iItemActionMenu->RemoveCollection( *this ); |
122 } |
112 } |
123 delete iLongTapDetector; |
113 delete iLongTapDetector; |
124 |
114 |
125 if ( iMarkingIconArray ) |
|
126 { |
|
127 iMarkingIconArray->ResetAndDestroy(); |
|
128 } |
|
129 |
|
130 delete iMarkingIconArray; |
|
131 |
|
132 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
115 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
133 if ( CAknListLoader::TfxApiInternal( iGc ) ) |
116 if ( CAknListLoader::TfxApiInternal( iGc ) ) |
134 { |
117 { |
135 delete iGc; |
118 delete iGc; |
136 } |
119 } |
178 |
161 |
179 if ( aDrawNow ) |
162 if ( aDrawNow ) |
180 { |
163 { |
181 Window().Invalidate( Rect() ); |
164 Window().Invalidate( Rect() ); |
182 } |
165 } |
183 |
166 UpdateScrollbars(); |
184 UpdateScrollbars( ETrue ); |
|
185 } |
167 } |
186 |
168 |
187 |
169 |
188 // --------------------------------------------------------------------------- |
170 // --------------------------------------------------------------------------- |
189 // Sets the focused item and its position in the view. |
171 // Sets the focused item and its position in the view. |
229 UpdateAnimation(); |
211 UpdateAnimation(); |
230 |
212 |
231 // Draw always |
213 // Draw always |
232 Window().Invalidate( Rect() ); |
214 Window().Invalidate( Rect() ); |
233 |
215 |
234 UpdateScrollbars( ETrue ); |
216 UpdateScrollbars(); |
235 } |
217 } |
236 |
218 |
237 |
219 |
238 |
220 |
239 // --------------------------------------------------------------------------- |
221 // --------------------------------------------------------------------------- |
438 void CAknTreeListView::SetEmptyTextL(const TDesC& aText) |
420 void CAknTreeListView::SetEmptyTextL(const TDesC& aText) |
439 { |
421 { |
440 delete iEmptyListText; |
422 delete iEmptyListText; |
441 iEmptyListText = NULL; |
423 iEmptyListText = NULL; |
442 iEmptyListText = aText.AllocL(); |
424 iEmptyListText = aText.AllocL(); |
443 UpdateScrollbars( ETrue ); |
|
444 } |
425 } |
445 |
426 |
446 |
427 |
447 // --------------------------------------------------------------------------- |
428 // --------------------------------------------------------------------------- |
448 // InitPhysicsL |
429 // InitPhysicsL |
485 // SelectItem |
466 // SelectItem |
486 // --------------------------------------------------------------------------- |
467 // --------------------------------------------------------------------------- |
487 // |
468 // |
488 void CAknTreeListView::SelectItem( CAknTreeItem* aSelectedItem ) |
469 void CAknTreeListView::SelectItem( CAknTreeItem* aSelectedItem ) |
489 { |
470 { |
490 if ( iFlags.IsSet( EFlagMarkingMode ) ) |
471 SelectItem( aSelectedItem, EFalse ); |
491 { |
|
492 if ( aSelectedItem->IsMarkable() ) |
|
493 { |
|
494 MarkItem( aSelectedItem, !aSelectedItem->IsMarked(), ETrue ); |
|
495 } |
|
496 else if ( aSelectedItem->IsNode() ) |
|
497 { |
|
498 SelectItem( aSelectedItem, EFalse ); |
|
499 } |
|
500 } |
|
501 else |
|
502 { |
|
503 SelectItem( aSelectedItem, EFalse ); |
|
504 } |
|
505 } |
472 } |
506 |
473 |
507 |
474 |
508 // --------------------------------------------------------------------------- |
475 // --------------------------------------------------------------------------- |
509 // VisibleItemCount |
476 // VisibleItemCount |
521 // SetPressedDownState |
488 // SetPressedDownState |
522 // --------------------------------------------------------------------------- |
489 // --------------------------------------------------------------------------- |
523 // |
490 // |
524 void CAknTreeListView::SetPressedDownState( const TBool& aPressedDown ) |
491 void CAknTreeListView::SetPressedDownState( const TBool& aPressedDown ) |
525 { |
492 { |
526 if ( aPressedDown ) |
493 iIsPressedDownState = aPressedDown; |
527 { |
|
528 iFlags.Set( EFlagIsPressedDownState ); |
|
529 } |
|
530 else |
|
531 { |
|
532 iFlags.Clear( EFlagIsPressedDownState ); |
|
533 } |
|
534 } |
494 } |
535 |
495 |
536 |
496 |
537 // --------------------------------------------------------------------------- |
497 // --------------------------------------------------------------------------- |
538 // UpdateTreeListView |
498 // UpdateTreeListView |
541 void CAknTreeListView::UpdateTreeListView( const TInt& aFirstItem, |
501 void CAknTreeListView::UpdateTreeListView( const TInt& aFirstItem, |
542 const TBool& aDrawNow ) |
502 const TBool& aDrawNow ) |
543 { |
503 { |
544 CAknTreeItem* first = iTree.VisibleItem( aFirstItem ); |
504 CAknTreeItem* first = iTree.VisibleItem( aFirstItem ); |
545 UpdateVisibleItems( 0, first ); |
505 UpdateVisibleItems( 0, first ); |
546 UpdateScrollbars( ETrue ); |
506 UpdateScrollbars(); |
547 UpdateAnimation(); |
507 UpdateAnimation(); |
548 |
508 |
549 if ( aDrawNow ) |
509 if ( aDrawNow ) |
550 { |
510 { |
551 DrawNow(); |
511 DrawNow(); |
779 // --------------------------------------------------------------------------- |
739 // --------------------------------------------------------------------------- |
780 // |
740 // |
781 void CAknTreeListView::MakeVisible( TBool aVisible ) |
741 void CAknTreeListView::MakeVisible( TBool aVisible ) |
782 { |
742 { |
783 CAknControl::MakeVisible( aVisible ); |
743 CAknControl::MakeVisible( aVisible ); |
784 UpdateScrollbars( aVisible ); |
744 |
745 if ( aVisible ) |
|
746 { |
|
747 UpdateScrollbars(); |
|
748 } |
|
785 } |
749 } |
786 |
750 |
787 |
751 |
788 // --------------------------------------------------------------------------- |
752 // --------------------------------------------------------------------------- |
789 // From class CCoeControl. |
753 // From class CCoeControl. |
804 |
768 |
805 Window().SetPointerGrab( ETrue ); |
769 Window().SetPointerGrab( ETrue ); |
806 |
770 |
807 iScrollbarFrame = new ( ELeave ) CEikScrollBarFrame( this, this ); |
771 iScrollbarFrame = new ( ELeave ) CEikScrollBarFrame( this, this ); |
808 iScrollbarFrame->CreateDoubleSpanScrollBarsL( EFalse, EFalse ); |
772 iScrollbarFrame->CreateDoubleSpanScrollBarsL( EFalse, EFalse ); |
809 if ( CAknEnv::Static()->TransparencyEnabled() && iPhysicsHandler ) |
|
810 { |
|
811 // disable background drawing of scrollbar |
|
812 iScrollbarFrame->DrawBackground( EFalse, EFalse ); |
|
813 } |
|
814 } |
773 } |
815 |
774 |
816 |
775 |
817 // --------------------------------------------------------------------------- |
776 // --------------------------------------------------------------------------- |
818 // From class CCoeControl. |
777 // From class CCoeControl. |
820 // --------------------------------------------------------------------------- |
779 // --------------------------------------------------------------------------- |
821 // |
780 // |
822 void CAknTreeListView::HandleResourceChange( TInt aType ) |
781 void CAknTreeListView::HandleResourceChange( TInt aType ) |
823 { |
782 { |
824 CAknControl::HandleResourceChange( aType ); |
783 CAknControl::HandleResourceChange( aType ); |
825 |
784 if ( aType == KAknsMessageSkinChange ) |
826 switch ( aType ) |
785 { |
827 { |
786 TRAPD( error, CreateAnimationL() ) |
828 case KEikMessageWindowsFadeChange: |
787 if ( error ) |
829 { |
788 { |
830 ReportCollectionChangedEvent(); |
789 delete iAnimation; |
831 } |
790 iAnimation = NULL; |
832 |
791 } |
833 case KAknsMessageSkinChange: |
792 } |
834 { |
793 else if ( aType == KEikDynamicLayoutVariantSwitch && FocusedItem() ) |
835 TRAPD( error, CreateAnimationL() ) |
794 { |
836 if ( error ) |
795 if ( !FocusedItemVisible() ) |
837 { |
796 { |
838 delete iAnimation; |
797 TInt firstItemIndex = 0; |
839 iAnimation = NULL; |
798 if ( iItems.Count() && iItems[0].Item() ) |
840 } |
799 { |
841 |
800 firstItemIndex = iTree.VisibleItemIndex( iItems[0].Item() ); |
842 TRAP_IGNORE( LoadMarkingIconsL() ); |
801 } |
843 break; |
802 |
844 } |
803 TInt index = 0; |
845 |
804 if ( firstItemIndex < iTree.VisibleItemIndex( FocusedItem() ) ) |
846 case KEikDynamicLayoutVariantSwitch: |
805 { |
847 { |
806 index = iItems.Count() - 1; |
848 if ( AknLayoutUtils::LayoutMirrored() ) |
807 } |
849 { |
808 |
850 iFlags.Set( EFlagMirroredLayoutInUse ); |
809 SetFocusedItem( FocusedItem(), index, ETrue ); |
851 } |
810 } |
852 else |
811 else |
853 { |
812 { |
854 iFlags.Clear( EFlagMirroredLayoutInUse ); |
813 SetFocusedItem( FocusedItem(), FocusIndex(), ETrue ); |
855 } |
814 |
856 |
815 |
857 CAknTreeItem* focusedItem( FocusedItem() ); |
816 // This block moves visible view after layout switch |
858 if ( focusedItem ) |
817 // if there are not enough items to fill whole screen |
859 { |
818 TInt visibleItemIndex = iTree.VisibleItemIndex( FocusedItem() ); |
860 if ( !FocusedItemVisible() ) |
819 if ( visibleItemIndex != KErrNotFound) |
820 { |
|
821 TInt focusedItemIndex = FocusedItemIndex(); |
|
822 if (focusedItemIndex != -1) |
|
861 { |
823 { |
862 TInt firstItemIndex = 0; |
824 TInt height = iTree.VisibleItemCount() - visibleItemIndex + focusedItemIndex; |
863 if ( iItems.Count() && iItems[0].Item() ) |
825 TInt itemCountLimit = iItems.Count(); |
826 |
|
827 if ( height < itemCountLimit && height < iTree.VisibleItemCount() ) |
|
864 { |
828 { |
865 firstItemIndex = |
829 TInt move = itemCountLimit - height; |
866 iTree.VisibleItemIndex( iItems[0].Item() ); |
830 UpdateVisibleItems( focusedItemIndex + move, FocusedItem() ); |
867 } |
831 } |
868 |
|
869 TInt index = 0; |
|
870 if ( firstItemIndex < iTree.VisibleItemIndex( focusedItem ) ) |
|
871 { |
|
872 index = iItems.Count() - 1; |
|
873 } |
|
874 |
|
875 if( HighlightEnabled() ) |
|
876 { |
|
877 SetFocusedItem( focusedItem, index, ETrue ); |
|
878 } |
|
879 else |
|
880 { |
|
881 // This block moves visible view after layout switch |
|
882 // if there are not enough items to fill whole screen |
|
883 TInt visibleItemIndex = iTree.VisibleItemIndex( focusedItem ); |
|
884 if ( visibleItemIndex != KErrNotFound ) |
|
885 { |
|
886 TInt visibleItemCount( iTree.VisibleItemCount() ); |
|
887 TInt itemCountLimit = iItems.Count(); |
|
888 if ( visibleItemCount <= itemCountLimit - KAdditionalItems ) |
|
889 { |
|
890 UpdateVisibleItems( visibleItemIndex, focusedItem ); |
|
891 } |
|
892 } |
|
893 } |
|
894 |
|
895 } |
832 } |
896 else |
833 } |
897 { |
834 // end of block |
898 SetFocusedItem( focusedItem, FocusIndex(), ETrue ); |
835 } |
899 |
836 } |
900 // This block moves visible view after layout switch |
837 else if ( aType == KAknMessageFocusLost && HighlightEnabled() ) |
901 // if there are not enough items to fill whole screen |
838 { |
902 TInt visibleItemIndex = |
839 EnableHighlight( EFalse ); |
903 iTree.VisibleItemIndex( focusedItem ); |
|
904 if ( visibleItemIndex != KErrNotFound ) |
|
905 { |
|
906 TInt focusedItemIndex = FocusedItemIndex(); |
|
907 if ( focusedItemIndex != -1 ) |
|
908 { |
|
909 TInt visibleItemCount( iTree.VisibleItemCount() ); |
|
910 |
|
911 TInt height = |
|
912 visibleItemCount - visibleItemIndex + focusedItemIndex; |
|
913 TInt itemCountLimit = iItems.Count(); |
|
914 |
|
915 if ( height < itemCountLimit && |
|
916 height < visibleItemCount ) |
|
917 { |
|
918 TInt move = itemCountLimit - height; |
|
919 UpdateVisibleItems( focusedItemIndex + move, focusedItem ); |
|
920 } |
|
921 } |
|
922 } |
|
923 // end of block |
|
924 } |
|
925 } |
|
926 break; |
|
927 } |
|
928 |
|
929 case KAknMessageFocusLost: |
|
930 { |
|
931 if ( SingleClickEnabled() && HighlightEnabled() && |
|
932 ( iOldWinPos == KErrNotFound || |
|
933 iOldWinPos == DrawableWindow()->OrdinalPosition() ) ) |
|
934 { |
|
935 EnableHighlight( EFalse ); |
|
936 // Redraw item |
|
937 SetFocusedItem( FocusedItem(), FocusIndex(), ETrue ); |
|
938 } |
|
939 break; |
|
940 } |
|
941 |
|
942 default: |
|
943 { |
|
944 break; |
|
945 } |
|
946 } |
840 } |
947 } |
841 } |
948 |
842 |
949 |
843 |
950 // --------------------------------------------------------------------------- |
844 // --------------------------------------------------------------------------- |
955 // focused. |
849 // focused. |
956 // --------------------------------------------------------------------------- |
850 // --------------------------------------------------------------------------- |
957 // |
851 // |
958 void CAknTreeListView::HandlePointerEventL( const TPointerEvent& aPointerEvent ) |
852 void CAknTreeListView::HandlePointerEventL( const TPointerEvent& aPointerEvent ) |
959 { |
853 { |
960 if ( GrabbingComponent() ) |
854 if ( iFlags.IsSet( EFlagIgnoreButtonUpEvent ) |
855 && aPointerEvent.iType == TPointerEvent::EButton1Up ) |
|
856 { |
|
857 return; |
|
858 } |
|
859 |
|
860 if ( GrabbingComponent() != NULL ) |
|
961 { |
861 { |
962 iPhysicsHandler->ResetEventBlockingStatus(); |
862 iPhysicsHandler->ResetEventBlockingStatus(); |
963 } |
863 } |
964 else |
864 else |
965 { |
865 { |
1010 { |
910 { |
1011 EnableHighlight( EFalse ); |
911 EnableHighlight( EFalse ); |
1012 } |
912 } |
1013 |
913 |
1014 TInt thumbPosition = aScrollBar->ThumbPosition(); |
914 TInt thumbPosition = aScrollBar->ThumbPosition(); |
1015 if ( iFlags.IsSet( EFlagMirroredLayoutInUse ) && |
915 if ( AknLayoutUtils::LayoutMirrored() && |
1016 aScrollBar != iScrollbarFrame->VerticalScrollBar() ) |
916 aScrollBar != iScrollbarFrame->VerticalScrollBar() ) |
1017 { |
917 { |
1018 const TEikScrollBarModel* model = aScrollBar->Model(); |
918 const TEikScrollBarModel* model = aScrollBar->Model(); |
1019 thumbPosition = ( model->iScrollSpan - model->iThumbSpan ) |
919 thumbPosition = ( model->iScrollSpan - model->iThumbSpan ) |
1020 - thumbPosition; |
920 - thumbPosition; |
1029 case EEikScrollLeft: |
929 case EEikScrollLeft: |
1030 case EEikScrollRight: |
930 case EEikScrollRight: |
1031 case EEikScrollPageLeft: |
931 case EEikScrollPageLeft: |
1032 case EEikScrollPageRight: |
932 case EEikScrollPageRight: |
1033 iViewLevel = thumbPosition; |
933 iViewLevel = thumbPosition; |
1034 UpdateScrollbars( ETrue ); |
934 UpdateScrollbars(); |
1035 UpdateAnimation(); |
935 UpdateAnimation(); |
1036 Window().Invalidate( Rect() ); |
936 Window().Invalidate( Rect() ); |
1037 break; |
937 break; |
1038 |
938 |
1039 case EEikScrollThumbDragHoriz: |
939 case EEikScrollThumbDragHoriz: |
1041 UpdateAnimation(); |
941 UpdateAnimation(); |
1042 Window().Invalidate( Rect() ); |
942 Window().Invalidate( Rect() ); |
1043 break; |
943 break; |
1044 |
944 |
1045 case EEikScrollThumbReleaseHoriz: |
945 case EEikScrollThumbReleaseHoriz: |
1046 UpdateScrollbars( ETrue ); |
946 UpdateScrollbars(); |
1047 break; |
947 break; |
1048 |
948 |
1049 case EEikScrollHome: |
949 case EEikScrollHome: |
1050 // Not in use |
950 // Not in use! |
1051 break; |
951 break; |
1052 |
952 |
1053 case EEikScrollEnd: |
953 case EEikScrollEnd: |
1054 // Not in use |
954 // Not in use! |
1055 break; |
955 break; |
1056 |
956 |
1057 default: |
957 default: |
1058 break; |
958 break; |
1059 } |
959 } |
1148 break; |
1048 break; |
1149 } |
1049 } |
1150 |
1050 |
1151 if ( aDrawNow ) |
1051 if ( aDrawNow ) |
1152 { |
1052 { |
1153 // DrawNow must be used here. |
1053 Window().Invalidate( Rect() ); |
1154 DrawNow(); |
|
1155 } |
1054 } |
1156 } |
1055 } |
1157 |
1056 |
1158 |
1057 |
1159 // --------------------------------------------------------------------------- |
1058 // --------------------------------------------------------------------------- |
1233 { |
1132 { |
1234 Window().Invalidate( Rect() ); |
1133 Window().Invalidate( Rect() ); |
1235 } |
1134 } |
1236 else if ( IsFocused() && FocusedItemVisible() ) |
1135 else if ( IsFocused() && FocusedItemVisible() ) |
1237 { |
1136 { |
1238 TRect rect = iItems[FocusIndex()].HighlightRect( iViewLevel, |
1137 TRect rect = iItems[FocusIndex()].HighlightRect( iViewLevel, Indention(), IndentionWidth() ); |
1239 Indention(), |
|
1240 IndentionWidth() ); |
|
1241 Window().Invalidate( rect ); |
1138 Window().Invalidate( rect ); |
1242 } |
1139 } |
1243 |
1140 |
1244 ReportTreeListEvent( MAknTreeListObserver::EItemFocused, |
1141 ReportTreeListEvent( MAknTreeListObserver::EItemFocused, |
1245 iTree.Id( FocusedItem() ) ); |
1142 iTree.Id( FocusedItem() ) ); |
1255 { |
1152 { |
1256 // Get layout for the view. |
1153 // Get layout for the view. |
1257 LayoutView(); |
1154 LayoutView(); |
1258 |
1155 |
1259 // Update scrollbars. |
1156 // Update scrollbars. |
1260 UpdateScrollbars( ETrue ); |
1157 UpdateScrollbars(); |
1261 |
1158 |
1159 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
|
1262 UpdateIndexes(); |
1160 UpdateIndexes(); |
1161 #endif |
|
1263 AknsUtils::RegisterControlPosition( this, PositionRelativeToScreen() ); |
1162 AknsUtils::RegisterControlPosition( this, PositionRelativeToScreen() ); |
1264 |
1163 |
1265 TRAP_IGNORE( InitPhysicsL() ); |
1164 TRAP_IGNORE( InitPhysicsL() ); |
1266 } |
1165 } |
1267 |
1166 |
1299 iViewLevel( 0 ), |
1198 iViewLevel( 0 ), |
1300 iMaxViewLevel( 0 ), |
1199 iMaxViewLevel( 0 ), |
1301 iStylusDownItemIndex( -1 ), |
1200 iStylusDownItemIndex( -1 ), |
1302 iAnimationIID( KAknsIIDQsnAnimList ), |
1201 iAnimationIID( KAknsIIDQsnAnimList ), |
1303 iIndentionWidth( -1 ), |
1202 iIndentionWidth( -1 ), |
1304 iPhysicsHandler( NULL ) |
1203 iPhysicsHandler( NULL ), |
1204 iScrollPhysicsTop( ETrue ) |
|
1305 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
1205 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
1306 ,iGc(NULL) |
1206 ,iGc(NULL) |
1307 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
1207 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
1308 ,iItemActionMenu( NULL ), |
1208 ,iItemActionMenu( NULL ), |
1309 iLongTapDetector( NULL ), |
1209 iLongTapDetector( NULL ) |
1310 iOldWinPos( KErrNotFound ) |
|
1311 { |
1210 { |
1312 if ( static_cast<CAknAppUi*>( |
1211 if ( static_cast<CAknAppUi*>( |
1313 iCoeEnv->AppUi() )->IsSingleClickCompatible() ) |
1212 iCoeEnv->AppUi() )->IsSingleClickCompatible() ) |
1314 { |
1213 { |
1315 iFlags.Set( EFlagSingleClickEnabled ); |
1214 iFlags.Set( EFlagSingleClickEnabled ); |
1316 } |
1215 } |
1317 |
1216 |
1318 iFlags.Set( EFlagStructureLines ); |
1217 iFlags.Set( EFlagStructureLines ); |
1319 iFlags.Set( EFlagIndention ); |
1218 iFlags.Set( EFlagIndention ); |
1320 iFlags.Set( EFlagScrollPhysicsTop ); |
|
1321 } |
1219 } |
1322 |
1220 |
1323 |
1221 |
1324 // --------------------------------------------------------------------------- |
1222 // --------------------------------------------------------------------------- |
1325 // Second phase constructor. |
1223 // Second phase constructor. |
1353 iPhysicsHandler = CAknTreeListPhysicsHandler::NewL( this, |
1251 iPhysicsHandler = CAknTreeListPhysicsHandler::NewL( this, |
1354 &iTree, |
1252 &iTree, |
1355 &iItems ); |
1253 &iItems ); |
1356 } |
1254 } |
1357 |
1255 |
1358 iFlags.Clear( EFlagIsPressedDownState ); |
1256 iIsPressedDownState = EFalse; |
1359 iFlags.Clear( EFlagIsDragged ); |
1257 iIsDragged = EFalse; |
1360 iItemActionMenu = CAknItemActionMenu::RegisterCollectionL( *this, this ); |
1258 iItemActionMenu = CAknItemActionMenu::RegisterCollectionL( *this ); |
1361 |
|
1362 if ( iItemActionMenu ) |
1259 if ( iItemActionMenu ) |
1363 { |
1260 { |
1364 iLongTapDetector = CAknLongTapDetector::NewL( this ); |
1261 iLongTapDetector = CAknLongTapDetector::NewL( this ); |
1365 } |
1262 } |
1366 |
1263 |
1370 } |
1267 } |
1371 else |
1268 else |
1372 { |
1269 { |
1373 EnableHighlight( ETrue ); |
1270 EnableHighlight( ETrue ); |
1374 } |
1271 } |
1375 if ( AknLayoutUtils::LayoutMirrored() ) |
|
1376 { |
|
1377 iFlags.Set( EFlagMirroredLayoutInUse ); |
|
1378 } |
|
1379 else |
|
1380 { |
|
1381 iFlags.Clear( EFlagMirroredLayoutInUse ); |
|
1382 } |
|
1383 LoadMarkingIconsL(); |
|
1384 } |
1272 } |
1385 |
1273 |
1386 |
1274 |
1387 // --------------------------------------------------------------------------- |
1275 // --------------------------------------------------------------------------- |
1388 // Handles an addition of new item into tree list. The focused item is kept |
1276 // Handles an addition of new item into tree list. The focused item is kept |
1391 // --------------------------------------------------------------------------- |
1279 // --------------------------------------------------------------------------- |
1392 // |
1280 // |
1393 void CAknTreeListView::HandleItemAddedEvent( CAknTreeItem* /*aItem*/, TBool aDrawNow ) |
1281 void CAknTreeListView::HandleItemAddedEvent( CAknTreeItem* /*aItem*/, TBool aDrawNow ) |
1394 { |
1282 { |
1395 UpdateVisibleItems(); |
1283 UpdateVisibleItems(); |
1396 UpdateScrollbars( aDrawNow ); |
1284 if (aDrawNow) |
1285 { |
|
1286 UpdateScrollbars(); |
|
1287 } |
|
1397 } |
1288 } |
1398 |
1289 |
1399 |
1290 |
1400 // --------------------------------------------------------------------------- |
1291 // --------------------------------------------------------------------------- |
1401 // Handles the movement of a tree item. Movement of focused item has to be |
1292 // Handles the movement of a tree item. Movement of focused item has to be |
1406 { |
1297 { |
1407 // Note: This method cannot deduce, which items in the view have actually |
1298 // Note: This method cannot deduce, which items in the view have actually |
1408 // been changed, unless the it receives information from where the |
1299 // been changed, unless the it receives information from where the |
1409 // specified item was moved. |
1300 // specified item was moved. |
1410 UpdateVisibleItems(); |
1301 UpdateVisibleItems(); |
1411 UpdateScrollbars( ETrue ); |
1302 UpdateScrollbars(); |
1412 } |
1303 } |
1413 |
1304 |
1414 |
1305 |
1415 // --------------------------------------------------------------------------- |
1306 // --------------------------------------------------------------------------- |
1416 // Prepares view for the item removal by moving the focus from the removed |
1307 // Prepares view for the item removal by moving the focus from the removed |
1461 // --------------------------------------------------------------------------- |
1352 // --------------------------------------------------------------------------- |
1462 // |
1353 // |
1463 void CAknTreeListView::HandleItemRemovedEvent( CAknTreeItem* /*aItem*/, TBool aDrawNow ) |
1354 void CAknTreeListView::HandleItemRemovedEvent( CAknTreeItem* /*aItem*/, TBool aDrawNow ) |
1464 { |
1355 { |
1465 UpdateVisibleItems(); |
1356 UpdateVisibleItems(); |
1466 UpdateScrollbars( aDrawNow ); |
1357 if (aDrawNow) |
1358 { |
|
1359 UpdateScrollbars(); |
|
1360 } |
|
1467 } |
1361 } |
1468 |
1362 |
1469 |
1363 |
1470 // --------------------------------------------------------------------------- |
1364 // --------------------------------------------------------------------------- |
1471 // Handles an expansion of a tree node. If the expanded node is focused, it is |
1365 // Handles an expansion of a tree node. If the expanded node is focused, it is |
1484 } |
1378 } |
1485 else |
1379 else |
1486 { |
1380 { |
1487 UpdateVisibleItems(); |
1381 UpdateVisibleItems(); |
1488 } |
1382 } |
1489 |
1383 UpdateScrollbars(); |
1490 UpdateScrollbars( ETrue ); |
|
1491 } |
1384 } |
1492 |
1385 |
1493 |
1386 |
1494 // --------------------------------------------------------------------------- |
1387 // --------------------------------------------------------------------------- |
1495 // Handles a collapse of a tree node. If one of the items in collapsed node |
1388 // Handles a collapse of a tree node. If one of the items in collapsed node |
1525 // visible |
1418 // visible |
1526 UpdateViewItemAsVisible( aNode ); |
1419 UpdateViewItemAsVisible( aNode ); |
1527 } |
1420 } |
1528 |
1421 |
1529 UpdateVisibleItems(); |
1422 UpdateVisibleItems(); |
1530 UpdateScrollbars( ETrue ); |
1423 UpdateScrollbars(); |
1531 } |
1424 } |
1532 |
1425 |
1533 |
1426 |
1534 // --------------------------------------------------------------------------- |
1427 // --------------------------------------------------------------------------- |
1535 // Handles a change in tree item. |
1428 // Handles a change in tree item. |
1577 { |
1470 { |
1578 iItems[ii].SetItem( iterator.Next() ); |
1471 iItems[ii].SetItem( iterator.Next() ); |
1579 } |
1472 } |
1580 } |
1473 } |
1581 } |
1474 } |
1582 |
1475 if ( aDrawNow ) |
1583 UpdateScrollbars( aDrawNow ); |
1476 { |
1477 UpdateScrollbars(); |
|
1478 } |
|
1584 } |
1479 } |
1585 |
1480 |
1586 |
1481 |
1587 // --------------------------------------------------------------------------- |
1482 // --------------------------------------------------------------------------- |
1588 // Updates the view items so that the specified item is located at the |
1483 // Updates the view items so that the specified item is located at the |
1593 void CAknTreeListView::UpdateVisibleItems( TInt aIndex, CAknTreeItem* aItem ) |
1488 void CAknTreeListView::UpdateVisibleItems( TInt aIndex, CAknTreeItem* aItem ) |
1594 { |
1489 { |
1595 SetFocusIndex( KMinTInt ); |
1490 SetFocusIndex( KMinTInt ); |
1596 if ( !iItems.Count() ) |
1491 if ( !iItems.Count() ) |
1597 { |
1492 { |
1493 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
|
1598 UpdateIndexes(); |
1494 UpdateIndexes(); |
1495 #endif |
|
1599 return; |
1496 return; |
1600 } |
1497 } |
1601 |
1498 |
1602 TInt index = Min( aIndex, iTree.VisibleItemIndex( aItem ) ); |
1499 TInt index = Min( aIndex, iTree.VisibleItemIndex( aItem ) ); |
1603 |
1500 |
1631 if ( iItems[ii].Item() == FocusedItem() ) |
1528 if ( iItems[ii].Item() == FocusedItem() ) |
1632 { |
1529 { |
1633 SetFocusIndex( ii ); |
1530 SetFocusIndex( ii ); |
1634 } |
1531 } |
1635 } |
1532 } |
1533 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
|
1636 UpdateIndexes(); |
1534 UpdateIndexes(); |
1535 #endif |
|
1637 } |
1536 } |
1638 |
1537 |
1639 |
1538 |
1640 // --------------------------------------------------------------------------- |
1539 // --------------------------------------------------------------------------- |
1641 // Updates the view items so that the focused item remains in the same |
1540 // Updates the view items so that the focused item remains in the same |
1677 SetFocusIndex( ii ); |
1576 SetFocusIndex( ii ); |
1678 } |
1577 } |
1679 item = iterator.Next(); |
1578 item = iterator.Next(); |
1680 } |
1579 } |
1681 } |
1580 } |
1581 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
|
1682 UpdateIndexes(); |
1582 UpdateIndexes(); |
1583 #endif |
|
1683 } |
1584 } |
1684 else if ( itemCount && iItems.Count() ) |
1585 else if ( itemCount && iItems.Count() ) |
1685 { |
1586 { |
1686 if ( FocusedItemVisible() ) |
1587 if ( FocusedItemVisible() ) |
1687 { |
1588 { |
1710 void CAknTreeListView::HandleSelectionKeyEvent() |
1611 void CAknTreeListView::HandleSelectionKeyEvent() |
1711 { |
1612 { |
1712 CAknTreeItem* item = FocusedItem(); |
1613 CAknTreeItem* item = FocusedItem(); |
1713 if ( item ) |
1614 if ( item ) |
1714 { |
1615 { |
1715 if ( iFlags.IsSet( EFlagMarkingMode ) ) |
1616 if ( MarkingOngoing() ) |
1716 { |
1617 { |
1717 if ( item->IsMarkable() ) |
1618 MarkItem( item, !item->IsMarked(), ETrue ); |
1718 { |
|
1719 MarkItem( item, !item->IsMarked(), ETrue ); |
|
1720 } |
|
1721 } |
1619 } |
1722 else |
1620 else |
1723 { |
1621 { |
1724 SelectItem( item, EFalse ); |
1622 SelectItem( item, true ); |
1725 } |
1623 } |
1726 } |
1624 } |
1727 } |
1625 } |
1728 |
1626 |
1729 |
1627 |
1731 // Handles right arrow key event. |
1629 // Handles right arrow key event. |
1732 // --------------------------------------------------------------------------- |
1630 // --------------------------------------------------------------------------- |
1733 // |
1631 // |
1734 void CAknTreeListView::HandleRightArrowKeyEvent() |
1632 void CAknTreeListView::HandleRightArrowKeyEvent() |
1735 { |
1633 { |
1736 if ( iFlags.IsSet( EFlagMirroredLayoutInUse ) ) |
1634 if ( AknLayoutUtils::LayoutMirrored() ) |
1737 { |
1635 { |
1738 AscendFocus(); |
1636 AscendFocus(); |
1739 } |
1637 } |
1740 else |
1638 else |
1741 { |
1639 { |
1748 // Handles left arrow key event. |
1646 // Handles left arrow key event. |
1749 // --------------------------------------------------------------------------- |
1647 // --------------------------------------------------------------------------- |
1750 // |
1648 // |
1751 void CAknTreeListView::HandleLeftArrowKeyEvent() |
1649 void CAknTreeListView::HandleLeftArrowKeyEvent() |
1752 { |
1650 { |
1753 if ( iFlags.IsSet( EFlagMirroredLayoutInUse ) ) |
1651 if ( AknLayoutUtils::LayoutMirrored() ) |
1754 { |
1652 { |
1755 DescendFocus(); |
1653 DescendFocus(); |
1756 } |
1654 } |
1757 else |
1655 else |
1758 { |
1656 { |
2049 for ( TInt ii = iItems.Count(); ii < itemCountLimit; ++ii ) |
1947 for ( TInt ii = iItems.Count(); ii < itemCountLimit; ++ii ) |
2050 { |
1948 { |
2051 // This should not fail, if enough space was reserved for the |
1949 // This should not fail, if enough space was reserved for the |
2052 // array, and if it fails, it results only fewer items being |
1950 // array, and if it fails, it results only fewer items being |
2053 // shown in the list. |
1951 // shown in the list. |
2054 if ( KErrNone != iItems.Append( TAknTreeListViewItem() ) ) |
1952 iItems.Append( TAknTreeListViewItem() ); |
2055 { |
|
2056 return; |
|
2057 } |
|
2058 } |
1953 } |
2059 } |
1954 } |
2060 |
1955 |
2061 // Get iterator and set it to point at the first item in the view, or at |
1956 // Get iterator and set it to point at the first item in the view, or at |
2062 // the first item in the list, if the view does not contain any items. |
1957 // the first item in the list, if the view does not contain any items. |
2065 if ( first ) |
1960 if ( first ) |
2066 { |
1961 { |
2067 iterator.SetCurrent( first ); |
1962 iterator.SetCurrent( first ); |
2068 iterator.Previous(); |
1963 iterator.Previous(); |
2069 } |
1964 } |
2070 if ( iFlags.IsSet( EFlagMarkingMode ) ) |
|
2071 { |
|
2072 if ( iFlags.IsSet( EFlagMirroredLayoutInUse )) |
|
2073 { |
|
2074 itemRect.iBr.iX -= |
|
2075 AknLayoutScalable_Avkon::list_double_graphic_pane_t1( |
|
2076 0 ).LayoutLine().ir; |
|
2077 } |
|
2078 else |
|
2079 { |
|
2080 itemRect.iBr.iX -= |
|
2081 AknLayoutScalable_Avkon::list_double_graphic_pane_t1( |
|
2082 0 ).LayoutLine().il; |
|
2083 } |
|
2084 } |
|
2085 |
1965 |
2086 // Update items and their rectangles. |
1966 // Update items and their rectangles. |
2087 for ( TInt ii = 0; ii < iItems.Count(); ++ii ) |
1967 for ( TInt ii = 0; ii < iItems.Count(); ++ii ) |
2088 { |
1968 { |
2089 CAknTreeItem* item = iterator.Next(); |
1969 CAknTreeItem* item = iterator.Next(); |
2104 TRect viewRect( listRect ); |
1984 TRect viewRect( listRect ); |
2105 |
1985 |
2106 // Fill whole control area with list items when physics enabled |
1986 // Fill whole control area with list items when physics enabled |
2107 // and threre is no horizontal scrollbar. |
1987 // and threre is no horizontal scrollbar. |
2108 if ( iScrollbarFrame && |
1988 if ( iScrollbarFrame && |
2109 iScrollbarFrame->ScrollBarVisibility( |
1989 iScrollbarFrame->ScrollBarVisibility( CEikScrollBar::EHorizontal ) != CEikScrollBarFrame::EOn && |
2110 CEikScrollBar::EHorizontal ) != CEikScrollBarFrame::EOn && |
|
2111 viewRect.Height() < Rect().Height() ) |
1990 viewRect.Height() < Rect().Height() ) |
2112 { |
1991 { |
2113 viewRect.iTl.iY = Rect().iTl.iY; |
1992 viewRect.iTl.iY = Rect().iTl.iY; |
2114 viewRect.iBr.iY = Rect().iBr.iY; |
1993 viewRect.iBr.iY = Rect().iBr.iY; |
2115 } |
1994 } |
2123 // Updates the span, thumb size and position for both of the scrollbars. New |
2002 // Updates the span, thumb size and position for both of the scrollbars. New |
2124 // layout for the view is applied, if the visibility of either of the |
2003 // layout for the view is applied, if the visibility of either of the |
2125 // scrollbars changes. |
2004 // scrollbars changes. |
2126 // --------------------------------------------------------------------------- |
2005 // --------------------------------------------------------------------------- |
2127 // |
2006 // |
2128 void CAknTreeListView::UpdateScrollbars( TBool aDrawNow ) |
2007 void CAknTreeListView::UpdateScrollbars() |
2129 { |
2008 { |
2130 if ( iScrollbarFrame ) |
2009 if ( iScrollbarFrame ) |
2131 { |
2010 { |
2132 TBool drawHorizontal; |
2011 iPhysicsHandler->UpdateScrollIndex( iScrollPhysicsTop ); |
2133 TBool drawVertical; |
2012 iScrollPhysicsTop = ETrue; |
2134 if ( !aDrawNow ) |
|
2135 { |
|
2136 // Backup the old values. |
|
2137 iScrollbarFrame->DrawBackgroundState( drawHorizontal, |
|
2138 drawVertical ); |
|
2139 |
|
2140 // Disable the scrollbar background drawing for the duration |
|
2141 // of this call. |
|
2142 iScrollbarFrame->DrawBackground( EFalse, EFalse ); |
|
2143 } |
|
2144 |
|
2145 iPhysicsHandler->UpdateScrollIndex( |
|
2146 iFlags.IsSet( EFlagScrollPhysicsTop ) ); |
|
2147 iFlags.Set( EFlagScrollPhysicsTop ); |
|
2148 |
|
2149 |
2013 |
2150 // Get values for horizontal scrollbar. |
2014 // Get values for horizontal scrollbar. |
2151 TInt hThumbPos = iViewLevel; |
2015 TInt hThumbPos = iViewLevel; |
2152 TInt hThumbSpan = iHorizontalViewSpan; |
2016 TInt hThumbSpan = iHorizontalViewSpan; |
2153 TInt hScrollSpan = Max( hThumbPos + hThumbSpan, iMaxViewLevel ); |
2017 TInt hScrollSpan = Max( hThumbPos + hThumbSpan, iMaxViewLevel ); |
2159 TInt c = iItems[0].ItemRect( iViewLevel, Indention(), |
2023 TInt c = iItems[0].ItemRect( iViewLevel, Indention(), |
2160 IndentionWidth() ).Width(); |
2024 IndentionWidth() ).Width(); |
2161 hThumbSpan = a/b; |
2025 hThumbSpan = a/b; |
2162 hScrollSpan = Max( hThumbPos + hThumbSpan, c/b ); |
2026 hScrollSpan = Max( hThumbPos + hThumbSpan, c/b ); |
2163 } |
2027 } |
2164 if ( iFlags.IsSet( EFlagMirroredLayoutInUse ) ) |
2028 |
2165 |
2029 if ( AknLayoutUtils::LayoutMirrored() ) |
2166 { |
2030 { |
2167 hThumbPos = hScrollSpan - ( hThumbPos + hThumbSpan ); |
2031 hThumbPos = hScrollSpan - ( hThumbPos + hThumbSpan ); |
2168 } |
2032 } |
2169 TEikScrollBarModel hModel( hScrollSpan, hThumbSpan, hThumbPos ); |
2033 TEikScrollBarModel hModel( hScrollSpan, hThumbSpan, hThumbPos ); |
2170 |
2034 |
2207 |
2071 |
2208 // Set new model for scrollbars. |
2072 // Set new model for scrollbars. |
2209 iScrollbarFrame->Tile( &hModel, &vModel ); |
2073 iScrollbarFrame->Tile( &hModel, &vModel ); |
2210 |
2074 |
2211 LayoutView(); |
2075 LayoutView(); |
2212 UpdateScrollbars( aDrawNow ); // Recursion |
2076 UpdateScrollbars(); // Recursion |
2213 |
2077 |
2214 // Update animation in case that scrollbar visibility change |
2078 // Update animation in case that scrollbar visibility change |
2215 // has affected the highlight size of focused item. |
2079 // has affected the highlight size of focused item. |
2216 UpdateAnimation(); |
2080 UpdateAnimation(); |
2217 } |
2081 } |
2218 else |
2082 else |
2219 { |
2083 { |
2220 // Set new model for scrollbars. |
2084 // Set new model for scrollbars. |
2221 iScrollbarFrame->Tile( &hModel, &vModel ); |
2085 iScrollbarFrame->Tile( &hModel, &vModel ); |
2222 } |
2086 } |
2223 |
|
2224 if ( !aDrawNow ) |
|
2225 { |
|
2226 // Restore the previous draw background state values. |
|
2227 iScrollbarFrame->DrawBackground( drawHorizontal, drawVertical ); |
|
2228 } |
|
2229 } |
2087 } |
2230 |
2088 |
2231 } |
2089 } |
2232 |
2090 |
2233 |
2091 |
2674 { |
2532 { |
2675 iLongPressTimer->Cancel(); |
2533 iLongPressTimer->Cancel(); |
2676 } |
2534 } |
2677 |
2535 |
2678 // Exits marking mode. |
2536 // Exits marking mode. |
2679 if ( iFlags.IsSet( EFlagMarkingState ) ) |
2537 if ( iFlags.IsSet( EFlagMarkingMode ) ) |
2680 { |
2538 { |
2681 ExitMarking(); |
2539 ExitMarkingMode(); |
2682 } |
2540 } |
2683 |
2541 |
2684 // Remove MSK observer. |
2542 // Remove MSK observer. |
2685 CEikButtonGroupContainer* cba; |
2543 CEikButtonGroupContainer* cba; |
2686 MopGetObject( cba ); |
2544 MopGetObject( cba ); |
2737 // Handles long press. |
2595 // Handles long press. |
2738 // --------------------------------------------------------------------------- |
2596 // --------------------------------------------------------------------------- |
2739 // |
2597 // |
2740 void CAknTreeListView::DoHandleLongPressL() |
2598 void CAknTreeListView::DoHandleLongPressL() |
2741 { |
2599 { |
2742 if ( iFlags.IsClear( EFlagMarkingState ) ) |
2600 if ( iFlags.IsClear( EFlagMarkingMode ) ) |
2743 { |
2601 { |
2744 EnterMarking(); |
2602 EnterMarkingMode(); |
2745 } |
2603 } |
2746 } |
2604 } |
2747 |
2605 |
2748 |
2606 |
2749 // --------------------------------------------------------------------------- |
2607 // --------------------------------------------------------------------------- |
2750 // Enters marking state. |
2608 // Enters marking mode. |
2751 // --------------------------------------------------------------------------- |
2609 // --------------------------------------------------------------------------- |
2752 // |
2610 // |
2753 void CAknTreeListView::EnterMarking() |
2611 void CAknTreeListView::EnterMarkingMode() |
2754 { |
2612 { |
2755 CEikButtonGroupContainer* bgc; |
2613 CEikButtonGroupContainer* bgc; |
2756 CCoeControl* MSK = NULL; |
2614 CCoeControl* MSK = NULL; |
2757 MopGetObject( bgc ); |
2615 MopGetObject( bgc ); |
2758 if ( bgc ) |
2616 if ( bgc ) |
2782 TRAPD( err, bgc->AddCommandToStackL( 3, newResourceId ) ); |
2640 TRAPD( err, bgc->AddCommandToStackL( 3, newResourceId ) ); |
2783 if ( !err ) |
2641 if ( !err ) |
2784 { |
2642 { |
2785 ReportTreeListEvent( MAknTreeListObserver::EMarkingModeEnabled, |
2643 ReportTreeListEvent( MAknTreeListObserver::EMarkingModeEnabled, |
2786 iTree.Id( FocusedItem() ) ); |
2644 iTree.Id( FocusedItem() ) ); |
2787 iFlags.Set( EFlagMarkingState ); |
2645 iFlags.Set( EFlagMarkingMode ); |
2788 bgc->DrawNow(); |
2646 bgc->DrawNow(); |
2789 } |
2647 } |
2790 } |
2648 } |
2791 } |
2649 } |
2792 |
2650 |
2793 |
2651 |
2794 // --------------------------------------------------------------------------- |
2652 // --------------------------------------------------------------------------- |
2795 // Exits marking state. |
2653 // Exits marking mode. |
2796 // --------------------------------------------------------------------------- |
2654 // --------------------------------------------------------------------------- |
2797 // |
2655 // |
2798 void CAknTreeListView::ExitMarking() |
2656 void CAknTreeListView::ExitMarkingMode() |
2799 { |
2657 { |
2800 if ( iFlags.IsSet( EFlagMarkingState ) ) |
2658 if ( iFlags.IsSet( EFlagMarkingMode ) ) |
2801 { |
2659 { |
2802 CEikButtonGroupContainer* bgc = NULL; |
2660 CEikButtonGroupContainer* bgc = NULL; |
2803 CCoeControl* MSK = NULL; |
2661 CCoeControl* MSK = NULL; |
2804 MopGetObject( bgc ); |
2662 MopGetObject( bgc ); |
2805 if ( bgc ) |
2663 if ( bgc ) |
2815 } |
2673 } |
2816 } |
2674 } |
2817 } |
2675 } |
2818 ReportTreeListEvent( MAknTreeListObserver::EMarkingModeDisabled, |
2676 ReportTreeListEvent( MAknTreeListObserver::EMarkingModeDisabled, |
2819 iTree.Id( FocusedItem() ) ); |
2677 iTree.Id( FocusedItem() ) ); |
2820 iFlags.Clear( EFlagMarkingState ); |
2678 iFlags.Clear( EFlagMarkingMode ); |
2821 } |
2679 } |
2822 } |
2680 } |
2823 |
2681 |
2824 |
2682 |
2825 // --------------------------------------------------------------------------- |
2683 // --------------------------------------------------------------------------- |
2861 // --------------------------------------------------------------------------- |
2719 // --------------------------------------------------------------------------- |
2862 // |
2720 // |
2863 void CAknTreeListView::DrawItemsWithPhysics( const TRect& aRect ) const |
2721 void CAknTreeListView::DrawItemsWithPhysics( const TRect& aRect ) const |
2864 { |
2722 { |
2865 TBool empty = IsEmpty(); |
2723 TBool empty = IsEmpty(); |
2866 TInt offset = Offset(); |
2724 |
2867 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
2725 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
2868 CWindowGc& gc = iGc && !empty ? *iGc : SystemGc(); |
2726 CWindowGc& gc = iGc && !empty ? *iGc : SystemGc(); |
2727 TInt offset = Offset(); |
|
2869 #else |
2728 #else |
2870 CWindowGc& gc = SystemGc(); |
2729 CWindowGc& gc = SystemGc(); |
2871 #endif |
2730 #endif |
2872 |
2731 |
2873 TInt checkBoxOffset ( 0 ); |
|
2874 if ( iFlags.IsSet( EFlagMarkingMode ) ) |
|
2875 { |
|
2876 if ( iFlags.IsSet( EFlagMirroredLayoutInUse ) ) |
|
2877 { |
|
2878 checkBoxOffset = |
|
2879 AknLayoutScalable_Avkon::list_double_graphic_pane_t1( |
|
2880 0 ).LayoutLine().ir; |
|
2881 } |
|
2882 else |
|
2883 { |
|
2884 checkBoxOffset = |
|
2885 AknLayoutScalable_Avkon::list_double_graphic_pane_t1( |
|
2886 0 ).LayoutLine().il; |
|
2887 } |
|
2888 } |
|
2889 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
2732 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
2890 MAknListBoxTfxInternal* transApi = CAknListLoader::TfxApiInternal( &gc ); |
2733 MAknListBoxTfxInternal* transApi = CAknListLoader::TfxApiInternal( &gc ); |
2891 if ( !empty && transApi ) |
2734 if ( !empty && transApi ) |
2892 { |
2735 { |
2893 |
2736 |
2928 { |
2771 { |
2929 transApi->StopDrawing(); |
2772 transApi->StopDrawing(); |
2930 } |
2773 } |
2931 #endif // RD_UI_TRANSITION_EFFECTS_LIST |
2774 #endif // RD_UI_TRANSITION_EFFECTS_LIST |
2932 |
2775 |
2933 // text color, used to draw the separator line between list items |
|
2934 TRgb textColor( KRgbBlack ); |
|
2935 AknsUtils::GetCachedColor( skin, |
|
2936 textColor, |
|
2937 KAknsIIDQsnTextColors, |
|
2938 EAknsCIQsnTextColorsCG6 ); |
|
2939 if ( iFlags.IsSet( EFlagMarkingMode ) |
|
2940 && iMarkingIconArray |
|
2941 && iMarkingIconArray->Count() == KMarkingModeIconArraySize ) |
|
2942 |
|
2943 { |
|
2944 // Set sizes for marking icon bitmaps |
|
2945 TRect drawRect; |
|
2946 drawRect = iItems[0].Rect(); |
|
2947 |
|
2948 // Rect for the marking icon |
|
2949 TRect iconRect = RectFromLayout( drawRect, |
|
2950 AknLayoutScalable_Avkon::list_single_graphic_pane_g1( 0 ) ); |
|
2951 |
|
2952 for ( TInt ii = 0; ii < iMarkingIconArray->Count(); ++ii ) |
|
2953 { |
|
2954 CGulIcon* icon = ( *iMarkingIconArray )[ii]; |
|
2955 CFbsBitmap* bitmap = icon->Bitmap(); |
|
2956 |
|
2957 if ( bitmap ) |
|
2958 { |
|
2959 TSize size( bitmap->SizeInPixels() ); // set size if not already |
|
2960 TSize targetSize( iconRect.Size() ); |
|
2961 |
|
2962 if ( size.iWidth != targetSize.iWidth && size.iHeight |
|
2963 != targetSize.iHeight ) |
|
2964 { |
|
2965 AknIconUtils::SetSize( bitmap, targetSize, |
|
2966 EAspectRatioPreservedAndUnusedSpaceRemoved ); |
|
2967 } |
|
2968 } |
|
2969 } |
|
2970 } |
|
2971 const TInt itemCount = iItems.Count(); |
2776 const TInt itemCount = iItems.Count(); |
2972 for ( TInt ii = 0; ii < itemCount; ++ii ) |
2777 for ( TInt ii = 0; ii < itemCount; ++ii ) |
2973 { |
2778 { |
2974 TRect drawRect( iItems[ii].Rect() ); |
2779 TRect drawRect( iItems[ii].Rect() ); |
2975 |
2780 |
2976 if ( iFlags.IsSet( EFlagMarkingMode ) ) |
|
2977 { |
|
2978 drawRect.iBr.iX += checkBoxOffset; |
|
2979 } |
|
2980 |
|
2981 if ( iItems[ii].Item() ) |
2781 if ( iItems[ii].Item() ) |
2982 { |
2782 { |
2983 |
|
2984 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
2783 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
2985 TRect tfxDrawRect( drawRect ); |
2784 TRect tfxDrawRect( drawRect ); |
2986 tfxDrawRect.Move( 0, -offset ); |
2785 tfxDrawRect.Move( 0, -offset ); |
2987 |
2786 |
2988 if ( transApi ) |
2787 if ( transApi ) |
2989 { |
2788 { |
2990 transApi->StartDrawing( MAknListBoxTfxInternal::EListNotSpecified ); |
2789 transApi->StartDrawing( MAknListBoxTfxInternal::EListNotSpecified ); |
2991 } |
2790 } |
2992 |
2791 |
2792 |
|
2993 TRect clippingRect( tfxDrawRect ); |
2793 TRect clippingRect( tfxDrawRect ); |
2994 |
2794 |
2995 // If horizontal scrollbar on, reduce clipping rect |
2795 // If horizontal scrollbar on, reduce clipping rect |
2996 // based on view rect from layout data |
2796 // based on view rect from layout data |
2997 if ( iScrollbarFrame->ScrollBarVisibility( CEikScrollBar::EHorizontal ) |
2797 if ( iScrollbarFrame->ScrollBarVisibility( CEikScrollBar::EHorizontal ) |
3001 if ( clippingRect.iBr.iY > viewRect.iBr.iY ) |
2801 if ( clippingRect.iBr.iY > viewRect.iBr.iY ) |
3002 { |
2802 { |
3003 clippingRect.iBr.iY = viewRect.iBr.iY; |
2803 clippingRect.iBr.iY = viewRect.iBr.iY; |
3004 } |
2804 } |
3005 } |
2805 } |
2806 |
|
3006 // Set clipping rect. |
2807 // Set clipping rect. |
3007 if ( clippingRect.Intersects( aRect ) ) |
2808 gc.SetClippingRect( clippingRect ); |
3008 { |
2809 |
3009 clippingRect.Intersection( aRect ); |
2810 |
3010 gc.SetClippingRect( clippingRect ); |
|
3011 } |
|
3012 else |
|
3013 { |
|
3014 //Draw nothing if no overlap between item rectangel and given rect. |
|
3015 continue; |
|
3016 } |
|
3017 |
|
3018 if ( transApi ) |
2811 if ( transApi ) |
3019 { |
2812 { |
3020 transApi->StopDrawing(); |
2813 transApi->StopDrawing(); |
3021 } |
2814 } |
3022 #endif |
2815 #endif |
3023 |
2816 TBool focused = ( IsFocused() && FocusedItem() && |
3024 if ( iItems[ii].Item() != iBottomItem ) |
|
3025 { |
|
3026 TRect offsetRect( drawRect ); |
|
3027 offsetRect.Move( 0, -offset ); |
|
3028 AknListUtils::DrawSeparator( gc, offsetRect, textColor, skin ); |
|
3029 } |
|
3030 |
|
3031 TBool focused = ( FocusedItem() && |
|
3032 iItems[ii].Item() == FocusedItem() ); |
2817 iItems[ii].Item() == FocusedItem() ); |
3033 |
2818 |
3034 if ( SingleClickEnabled() && !HighlightEnabled() ) |
2819 if ( SingleClickEnabled() && !HighlightEnabled() ) |
3035 { |
2820 { |
3036 focused = EFalse; |
2821 focused = EFalse; |
3039 if ( focused ) |
2824 if ( focused ) |
3040 { |
2825 { |
3041 // Draw highlight for focused item. |
2826 // Draw highlight for focused item. |
3042 TRect highlightRect( iItems[ii].HighlightRect( |
2827 TRect highlightRect( iItems[ii].HighlightRect( |
3043 iViewLevel, Indention(), IndentionWidth() ) ); |
2828 iViewLevel, Indention(), IndentionWidth() ) ); |
3044 |
|
3045 if ( iFlags.IsSet( EFlagMarkingMode ) ) |
|
3046 { |
|
3047 highlightRect.iBr.iX = drawRect.iBr.iX; |
|
3048 highlightRect.iTl.iX = drawRect.iTl.iX; |
|
3049 } |
|
3050 |
2829 |
3051 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
2830 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
3052 TRect tfxHighlightRect( highlightRect ); |
2831 TRect tfxHighlightRect( highlightRect ); |
3053 tfxHighlightRect.Move( 0, -offset ); |
2832 tfxHighlightRect.Move( 0, -offset ); |
3054 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
2833 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
3055 |
2834 |
3056 if ( iFlags.IsSet( EFlagIsPressedDownState ) |
2835 if ( iIsPressedDownState || !DrawAnimation( gc, highlightRect ) ) |
3057 || !DrawAnimation( gc, highlightRect ) ) |
|
3058 { |
2836 { |
3059 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
2837 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
3060 if ( transApi ) |
2838 if ( transApi ) |
3061 { |
2839 { |
3062 transApi->Invalidate(MAknListBoxTfxInternal::EListHighlight ); |
2840 transApi->Invalidate(MAknListBoxTfxInternal::EListHighlight ); |
3063 transApi->BeginRedraw( MAknListBoxTfxInternal::EListHighlight, |
2841 transApi->BeginRedraw( MAknListBoxTfxInternal::EListHighlight, tfxHighlightRect ); |
3064 tfxHighlightRect ); |
|
3065 transApi->StartDrawing( MAknListBoxTfxInternal::EListHighlight ); |
2842 transApi->StartDrawing( MAknListBoxTfxInternal::EListHighlight ); |
3066 } |
2843 } |
3067 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
2844 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
3068 DrawHighlight( gc, highlightRect, |
2845 |
3069 iFlags.IsSet( EFlagIsPressedDownState ) ); |
2846 DrawHighlight( gc, highlightRect, iIsPressedDownState ); |
3070 |
|
3071 |
2847 |
3072 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
2848 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
3073 if ( transApi ) |
2849 if ( transApi ) |
3074 { |
2850 { |
3075 transApi->StopDrawing(); |
2851 transApi->StopDrawing(); |
3083 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
2859 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
3084 tfxDrawRect.BoundingRect( tfxHighlightRect ); |
2860 tfxDrawRect.BoundingRect( tfxHighlightRect ); |
3085 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
2861 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
3086 } |
2862 } |
3087 |
2863 |
3088 if ( iFlags.IsSet( EFlagMarkingMode ) && iMarkingIconArray |
|
3089 && iMarkingIconArray->Count() == |
|
3090 KMarkingModeIconArraySize ) |
|
3091 { |
|
3092 // Rect for the marking icon |
|
3093 TRect iconRect = RectFromLayout( drawRect, |
|
3094 AknLayoutScalable_Avkon::list_single_graphic_pane_g1( 0 ) ); |
|
3095 |
|
3096 iconRect.Move( 0, -offset ); |
|
3097 // unchecked icon |
|
3098 CGulIcon* icon = ( *iMarkingIconArray )[1]; |
|
3099 |
|
3100 TBool marked = ( iItems[ii].Item()->IsMarked() ); |
|
3101 if ( marked ) |
|
3102 { |
|
3103 icon = (*iMarkingIconArray)[0]; |
|
3104 } |
|
3105 |
|
3106 CFbsBitmap* bitmap = icon->Bitmap(); |
|
3107 |
|
3108 if ( bitmap ) |
|
3109 { |
|
3110 gc.BitBltMasked( iconRect.iTl, bitmap, |
|
3111 iconRect.Size(), icon->Mask(), EFalse ); |
|
3112 } |
|
3113 } |
|
3114 |
|
3115 if ( iFlags.IsSet( EFlagMarkingMode ) ) |
|
3116 { |
|
3117 drawRect.iBr.iX -= checkBoxOffset; |
|
3118 if ( iFlags.IsClear( EFlagMirroredLayoutInUse ) ) |
|
3119 { |
|
3120 gc.SetOrigin( TPoint( checkBoxOffset, 0 ) ); |
|
3121 } |
|
3122 } |
|
3123 |
|
3124 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
2864 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
3125 if (iItems[ii].Item()) |
2865 if (iItems[ii].Item()) |
3126 { |
2866 { |
3127 if ( transApi ) |
2867 if ( transApi ) |
3128 { |
2868 { |
3129 transApi->BeginRedraw( |
2869 transApi->BeginRedraw(MAknListBoxTfxInternal::EListItem, tfxDrawRect, iTree.VisibleItemIndex(iItems[ii].Item())); |
3130 MAknListBoxTfxInternal::EListItem, |
|
3131 tfxDrawRect, |
|
3132 iTree.VisibleItemIndex( iItems[ii].Item() ) ); |
|
3133 transApi->StartDrawing( MAknListBoxTfxInternal::EListItem ); |
2870 transApi->StartDrawing( MAknListBoxTfxInternal::EListItem ); |
3134 } |
2871 } |
3135 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
2872 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
3136 |
2873 |
3137 if ( iFlags.IsSet( EFlagMarkingMode ) ) |
2874 // Draw item. |
3138 { |
2875 iItems[ii].Draw( gc, iTree, drawRect, focused, iViewLevel, |
3139 TBool marked = iItems[ii].Item()->IsMarked(); |
2876 StructureLines(), Indention(), IndentionWidth() ); |
3140 if ( marked ) |
|
3141 { |
|
3142 iItems[ii].Item()->SetMarked( EFalse ); |
|
3143 } |
|
3144 iItems[ii].Draw( gc, iTree, drawRect, focused, iViewLevel, |
|
3145 StructureLines(), Indention(), IndentionWidth() ); |
|
3146 |
|
3147 if ( marked ) |
|
3148 { |
|
3149 iItems[ii].Item()->SetMarked( ETrue ); |
|
3150 } |
|
3151 } |
|
3152 else |
|
3153 { |
|
3154 iItems[ii].Draw( gc, iTree, drawRect, focused, iViewLevel, |
|
3155 StructureLines(), Indention(), IndentionWidth() ); |
|
3156 } |
|
3157 |
2877 |
3158 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
2878 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
3159 if ( transApi ) |
2879 if ( transApi ) |
3160 { |
2880 { |
3161 transApi->StopDrawing(); |
2881 transApi->StopDrawing(); |
3162 transApi->EndRedraw( |
2882 transApi->EndRedraw(MAknListBoxTfxInternal::EListItem, iTree.VisibleItemIndex(iItems[ii].Item())); |
3163 MAknListBoxTfxInternal::EListItem, |
|
3164 iTree.VisibleItemIndex( iItems[ii].Item() ) ); |
|
3165 } |
2883 } |
3166 } |
2884 } |
3167 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
2885 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
3168 |
2886 |
3169 if ( iFlags.IsSet( EFlagMarkingMode ) ) |
|
3170 { |
|
3171 gc.SetOrigin( TPoint( 0, 0 ) ); |
|
3172 } |
|
3173 } |
2887 } |
3174 } |
2888 } |
3175 } |
2889 } |
3176 |
2890 |
3177 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
2891 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
3258 SetFocusIndex( ii ); |
2972 SetFocusIndex( ii ); |
3259 } |
2973 } |
3260 item = iterator.Previous(); |
2974 item = iterator.Previous(); |
3261 } |
2975 } |
3262 } |
2976 } |
3263 iFlags.Clear( EFlagScrollPhysicsTop ); |
2977 iScrollPhysicsTop = EFalse; |
3264 } |
2978 } |
3265 |
2979 |
3266 } |
2980 } |
3267 |
2981 |
3268 |
2982 |
3279 |
2993 |
3280 // --------------------------------------------------------------------------- |
2994 // --------------------------------------------------------------------------- |
3281 // Enables or disables the highlight drawing |
2995 // Enables or disables the highlight drawing |
3282 // --------------------------------------------------------------------------- |
2996 // --------------------------------------------------------------------------- |
3283 // |
2997 // |
3284 void CAknTreeListView::EnableHighlight( TBool aEnabled, |
2998 void CAknTreeListView::EnableHighlight( TBool aEnabled ) |
3285 TBool aPointerEnabled ) |
2999 { |
3286 { |
|
3287 TBool wasEnabled = iFlags.IsSet( EFlagHighlightEnabled ); |
|
3288 |
|
3289 if ( aEnabled ) |
3000 if ( aEnabled ) |
3290 { |
3001 { |
3291 iFlags.Set( EFlagHighlightEnabled ); |
3002 iFlags.Set( EFlagHighlightEnabled ); |
3292 } |
3003 } |
3293 else |
3004 else |
3294 { |
3005 { |
3295 iFlags.Clear( EFlagHighlightEnabled ); |
3006 iFlags.Clear( EFlagHighlightEnabled ); |
3296 } |
|
3297 |
|
3298 if ( !aPointerEnabled |
|
3299 && ( ( wasEnabled && !aEnabled ) |
|
3300 || ( !wasEnabled && aEnabled ) ) ) |
|
3301 { |
|
3302 ReportCollectionChangedEvent(); |
|
3303 } |
3007 } |
3304 } |
3008 } |
3305 |
3009 |
3306 // --------------------------------------------------------------------------- |
3010 // --------------------------------------------------------------------------- |
3307 // Returns ETrue if highlight is enabled |
3011 // Returns ETrue if highlight is enabled |
3330 // ----------------------------------------------------------------------------- |
3034 // ----------------------------------------------------------------------------- |
3331 // |
3035 // |
3332 TUint CAknTreeListView::CollectionState() const |
3036 TUint CAknTreeListView::CollectionState() const |
3333 { |
3037 { |
3334 TUint state( 0 ); |
3038 TUint state( 0 ); |
3335 if ( IsVisible() && ( !DrawableWindow() || !DrawableWindow()->IsFaded() ) ) |
3039 if ( IsVisible() ) |
3336 { |
3040 { |
3337 state |= MAknCollection::EStateCollectionVisible; |
3041 state |= MAknCollection::EStateCollectionVisible; |
3338 } |
3042 } |
3339 if ( HighlightEnabled() ) |
3043 if ( HighlightEnabled() ) |
3340 { |
3044 { |
3341 state |= MAknCollection::EStateHighlightVisible; |
3045 state |= MAknCollection::EStateHighlightVisible; |
3342 } |
|
3343 |
|
3344 if ( iList.Flags() & KAknTreeListMarkable ) |
|
3345 { |
|
3346 state |= MAknCollection::EStateMultipleSelection; |
|
3347 } |
|
3348 TBool markedItems( EFalse ); |
|
3349 TRAP_IGNORE( markedItems = HasMarkedItemsL() ); |
|
3350 if ( markedItems ) |
|
3351 { |
|
3352 state |= MAknCollection::EStateMarkedItems; |
|
3353 } |
3046 } |
3354 return state; |
3047 return state; |
3355 } |
3048 } |
3356 |
3049 |
3357 // ----------------------------------------------------------------------------- |
3050 // ----------------------------------------------------------------------------- |
3358 // CAknTreeListView::ItemActionMenuClosed |
3051 // CAknTreeListView::ItemActionMenuClosed |
3359 // ----------------------------------------------------------------------------- |
3052 // ----------------------------------------------------------------------------- |
3360 // |
3053 // |
3361 void CAknTreeListView::ItemActionMenuClosed() |
3054 void CAknTreeListView::ItemActionMenuClosed() |
3362 { |
3055 { |
3363 iOldWinPos = KErrNotFound; |
3056 iFlags.Clear( EFlagIgnoreButtonUpEvent ); |
3364 EnableHighlight( EFalse ); |
3057 EnableHighlight( EFalse ); |
3365 DrawDeferred(); |
3058 DrawDeferred(); |
3366 } |
3059 } |
3367 |
3060 |
3368 // ----------------------------------------------------------------------------- |
3061 // ----------------------------------------------------------------------------- |
3369 // CAknTreeListView::CollectionExtension |
3062 // CAknTreeListView::CollectionExtension |
3370 // ----------------------------------------------------------------------------- |
3063 // ----------------------------------------------------------------------------- |
3371 // |
3064 // |
3372 TInt CAknTreeListView::CollectionExtension( |
3065 TInt CAknTreeListView::CollectionExtension( TUint /*aExtensionId*/, |
3373 TUint aExtensionId, TAny*& a0, TAny* /*a1*/ ) |
3066 TAny*& /*a0*/, TAny* /*a1*/ ) |
3374 { |
3067 { |
3375 if ( aExtensionId == MAknMarkingCollection::TYPE ) |
|
3376 { |
|
3377 a0 = static_cast<MAknMarkingCollection*>( this ); |
|
3378 } |
|
3379 |
|
3380 return KErrNone; |
3068 return KErrNone; |
3381 } |
3069 } |
3382 |
|
3383 |
|
3384 // ----------------------------------------------------------------------------- |
|
3385 // CAknTreeListView::SetMultipleMarkingState |
|
3386 // ----------------------------------------------------------------------------- |
|
3387 // |
|
3388 void CAknTreeListView::SetMultipleMarkingState( TBool aActive ) |
|
3389 { |
|
3390 if ( iFlags.IsSet( EFlagMarkingMode ) != aActive ) |
|
3391 { |
|
3392 if ( !aActive ) |
|
3393 { |
|
3394 TBool markedItems( EFalse ); |
|
3395 TRAP_IGNORE( markedItems = HasMarkedItemsL() ); |
|
3396 if ( markedItems ) |
|
3397 { |
|
3398 UnmarkAll(); |
|
3399 } |
|
3400 } |
|
3401 |
|
3402 EnableMarking( aActive ); |
|
3403 if ( aActive ) |
|
3404 { |
|
3405 iFlags.Set( EFlagMarkingMode ); |
|
3406 } |
|
3407 else |
|
3408 { |
|
3409 iFlags.Clear( EFlagMarkingMode ); |
|
3410 } |
|
3411 if ( aActive ) |
|
3412 { |
|
3413 // Expand all items when entering marking mode |
|
3414 iTree.Expand(); |
|
3415 } |
|
3416 LayoutView(); |
|
3417 DrawDeferred(); |
|
3418 |
|
3419 if ( iList.MarkingModeObserver() ) |
|
3420 { |
|
3421 iList.MarkingModeObserver()->MarkingModeStatusChanged( aActive ); |
|
3422 } |
|
3423 } |
|
3424 } |
|
3425 |
|
3426 |
|
3427 // ----------------------------------------------------------------------------- |
|
3428 // CAknTreeListView::MarkingState |
|
3429 // ----------------------------------------------------------------------------- |
|
3430 // |
|
3431 TUint CAknTreeListView::MarkingState() const |
|
3432 { |
|
3433 TUint state( 0 ); |
|
3434 |
|
3435 if ( iFlags.IsSet( EFlagMarkingMode ) ) |
|
3436 { |
|
3437 state |= MAknMarkingCollection::EStateMarkingMode; |
|
3438 |
|
3439 TBool markedItems ( EFalse ); |
|
3440 TRAP_IGNORE( markedItems = HasMarkedItemsL() ); |
|
3441 if ( markedItems ) |
|
3442 { |
|
3443 state |= MAknMarkingCollection::EStateMarkedItems; |
|
3444 } |
|
3445 if ( iItems.Count() == 0 ) |
|
3446 { |
|
3447 state |= MAknMarkingCollection::EStateCollectionEmpty; |
|
3448 } |
|
3449 } |
|
3450 return state; |
|
3451 } |
|
3452 |
|
3453 |
|
3454 // ----------------------------------------------------------------------------- |
|
3455 // CAknTreeListView::MarkCurrentItemL |
|
3456 // ----------------------------------------------------------------------------- |
|
3457 // |
|
3458 void CAknTreeListView::MarkCurrentItemL() |
|
3459 { |
|
3460 if ( iFlags.IsSet( EFlagMarkingMode ) && FocusedItem() && |
|
3461 FocusedItem()->IsMarkable() ) |
|
3462 { |
|
3463 MarkItem( FocusedItem(), ETrue, ETrue ); |
|
3464 } |
|
3465 } |
|
3466 |
|
3467 |
|
3468 // ----------------------------------------------------------------------------- |
|
3469 // CAknTreeListView::MarkAllL |
|
3470 // ----------------------------------------------------------------------------- |
|
3471 // |
|
3472 void CAknTreeListView::MarkAllL() |
|
3473 { |
|
3474 if ( iFlags.IsSet( EFlagMarkingMode ) ) |
|
3475 { |
|
3476 TAknTreeIterator iterator = iTree.Iterator(); |
|
3477 CAknTreeItem* item = NULL; |
|
3478 item = iterator.First(); |
|
3479 while ( item && iterator.HasNext() ) |
|
3480 { |
|
3481 if ( item->IsMarkable() ) |
|
3482 { |
|
3483 MarkItem( item, ETrue, EFalse ); |
|
3484 } |
|
3485 item = iterator.Next(); |
|
3486 } |
|
3487 DrawDeferred(); |
|
3488 } |
|
3489 } |
|
3490 |
|
3491 |
|
3492 // ----------------------------------------------------------------------------- |
|
3493 // CAknTreeListView::UnmarkAll |
|
3494 // ----------------------------------------------------------------------------- |
|
3495 // |
|
3496 void CAknTreeListView::UnmarkAll() |
|
3497 { |
|
3498 if ( iFlags.IsSet( EFlagMarkingMode ) ) |
|
3499 { |
|
3500 TAknTreeIterator iterator = iTree.Iterator(); |
|
3501 CAknTreeItem* item = NULL; |
|
3502 item = iterator.First(); |
|
3503 while ( item && iterator.HasNext() ) |
|
3504 { |
|
3505 MarkItem( item, EFalse, EFalse ); |
|
3506 item = iterator.Next(); |
|
3507 } |
|
3508 DrawDeferred(); |
|
3509 } |
|
3510 } |
|
3511 |
|
3512 |
|
3513 // ----------------------------------------------------------------------------- |
|
3514 // CAknTreeListView::CurrentItemMarkable |
|
3515 // ----------------------------------------------------------------------------- |
|
3516 // |
|
3517 TBool CAknTreeListView::CurrentItemMarkable() |
|
3518 { |
|
3519 if ( FocusedItem() && !FocusedItem()->IsMarkable() ) |
|
3520 { |
|
3521 return EFalse; |
|
3522 } |
|
3523 return ETrue; |
|
3524 } |
|
3525 |
|
3526 // ----------------------------------------------------------------------------- |
|
3527 // CAknTreeListView::ExitMarkingMode |
|
3528 // ----------------------------------------------------------------------------- |
|
3529 // |
|
3530 TBool CAknTreeListView::ExitMarkingMode() |
|
3531 { |
|
3532 if ( iList.MarkingModeObserver() ) |
|
3533 { |
|
3534 return iList.MarkingModeObserver()->ExitMarkingMode(); |
|
3535 } |
|
3536 return ETrue; |
|
3537 } |
|
3538 |
|
3539 |
|
3540 // ----------------------------------------------------------------------------- |
|
3541 // CAknTreeListView::ReportCollectionChangedEvent |
|
3542 // ----------------------------------------------------------------------------- |
|
3543 // |
|
3544 void CAknTreeListView::ReportCollectionChangedEvent() |
|
3545 { |
|
3546 if ( iItemActionMenu ) |
|
3547 { |
|
3548 iItemActionMenu->CollectionChanged( *this ); |
|
3549 } |
|
3550 } |
|
3551 |
|
3552 |
3070 |
3553 // --------------------------------------------------------------------------- |
3071 // --------------------------------------------------------------------------- |
3554 // CAknTreeListView::HandleLongTapEventL |
3072 // CAknTreeListView::HandleLongTapEventL |
3555 // --------------------------------------------------------------------------- |
3073 // --------------------------------------------------------------------------- |
3556 // |
3074 // |
3557 void CAknTreeListView::HandleLongTapEventL( |
3075 void CAknTreeListView::HandleLongTapEventL( |
3558 const TPoint& /*aPenEventLocation*/, |
3076 const TPoint& /*aPenEventLocation*/, |
3559 const TPoint& aPenEventScreenLocation) |
3077 const TPoint& aPenEventScreenLocation) |
3560 { |
3078 { |
3079 iFlags.Set( EFlagIgnoreButtonUpEvent ); |
|
3561 iItemActionMenu->ShowMenuL( aPenEventScreenLocation, 0 ); |
3080 iItemActionMenu->ShowMenuL( aPenEventScreenLocation, 0 ); |
3562 iOldWinPos = DrawableWindow()->OrdinalPosition(); |
|
3563 IgnoreEventsUntilNextPointerUp(); |
|
3564 } |
3081 } |
3565 |
3082 |
3566 // --------------------------------------------------------------------------- |
3083 // --------------------------------------------------------------------------- |
3567 // CAknTreeListView::LongTapPointerEventL |
3084 // CAknTreeListView::LongTapPointerEventL |
3568 // --------------------------------------------------------------------------- |
3085 // --------------------------------------------------------------------------- |
3569 // |
3086 // |
3570 void CAknTreeListView::LongTapPointerEventL( |
3087 void CAknTreeListView::LongTapPointerEventL( |
3571 const TPointerEvent& aPointerEvent) |
3088 const TPointerEvent& aPointerEvent) |
3572 { |
3089 { |
3573 if ( iLongTapDetector && iItemActionMenu |
3090 if ( iLongTapDetector && iItemActionMenu && iItemActionMenu->InitMenuL() ) |
3574 && !( HasMarkedItemsL() && FocusedItem() |
|
3575 && !FocusedItem()->IsMarked() ) && iItemActionMenu->InitMenuL() ) |
|
3576 { |
3091 { |
3577 iLongTapDetector->PointerEventL( aPointerEvent ); |
3092 iLongTapDetector->PointerEventL( aPointerEvent ); |
3578 } |
3093 } |
3579 } |
3094 } |
3580 |
3095 |
3592 |
3107 |
3593 // --------------------------------------------------------------------------- |
3108 // --------------------------------------------------------------------------- |
3594 // CAknTreeListView::HasMarkedItemsL |
3109 // CAknTreeListView::HasMarkedItemsL |
3595 // --------------------------------------------------------------------------- |
3110 // --------------------------------------------------------------------------- |
3596 // |
3111 // |
3597 TBool CAknTreeListView::HasMarkedItemsL() const |
3112 TBool CAknTreeListView::HasMarkedItemsL() |
3598 { |
3113 { |
3599 RArray<TInt> selection; |
3114 RArray<TInt> selection; |
3600 CleanupClosePushL( selection ); |
3115 CleanupClosePushL( selection ); |
3601 iList.GetMarkedItemsL( selection ); |
3116 iList.GetMarkedItemsL( selection ); |
3602 TInt count( selection.Count() ); |
3117 TInt count( selection.Count() ); |
3603 CleanupStack::PopAndDestroy( &selection ); |
3118 CleanupStack::PopAndDestroy( &selection ); |
3604 return ( count > 0 ); |
3119 if ( count > 0 ) |
3120 { |
|
3121 return ETrue; |
|
3122 } |
|
3123 return EFalse; |
|
3605 } |
3124 } |
3606 |
3125 |
3607 |
3126 |
3608 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
3127 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
3609 // --------------------------------------------------------------------------- |
3128 // --------------------------------------------------------------------------- |
3634 |
3153 |
3635 TInt& CAknTreeListView::BottomIndex() |
3154 TInt& CAknTreeListView::BottomIndex() |
3636 { |
3155 { |
3637 return iBottomIndex; |
3156 return iBottomIndex; |
3638 } |
3157 } |
3639 |
3158 |
3640 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
|
3641 // --------------------------------------------------------------------------- |
|
3642 // CAknTreeListView::UpdateIndexes |
|
3643 // --------------------------------------------------------------------------- |
|
3644 // |
|
3645 void CAknTreeListView::UpdateIndexes() |
3159 void CAknTreeListView::UpdateIndexes() |
3646 { |
3160 { |
3647 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
|
3648 iTopIndex = iBottomIndex = iHighlightIndex = 0; |
3161 iTopIndex = iBottomIndex = iHighlightIndex = 0; |
3649 #else |
|
3650 iBottomIndex = 0; |
|
3651 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
|
3652 |
3162 |
3653 if ( iItems.Count() ) |
3163 if ( iItems.Count() ) |
3654 { |
3164 { |
3655 for (TInt i=iItems.Count()-1; i>=0; i--) |
3165 for (TInt i=iItems.Count()-1; i>=0; i--) |
3656 { |
3166 { |
3657 if (iItems[i].Item()) |
3167 if (iItems[i].Item()) |
3658 { |
3168 { |
3659 iBottomItem = iItems[i].Item(); |
3169 iBottomIndex = iTree.VisibleItemIndex(iItems[i].Item()); |
3660 iBottomIndex = iTree.VisibleItemIndex( iBottomItem ); |
|
3661 break; |
3170 break; |
3662 } |
3171 } |
3663 } |
3172 } |
3664 |
3173 |
3665 #ifdef RD_UI_TRANSITION_EFFECTS_LIST |
|
3666 iTopIndex = iTree.VisibleItemIndex(iItems[0].Item()); |
3174 iTopIndex = iTree.VisibleItemIndex(iItems[0].Item()); |
3667 iHighlightIndex = iTree.VisibleItemIndex(FocusedItem()); |
3175 iHighlightIndex = iTree.VisibleItemIndex(FocusedItem()); |
3176 } |
|
3177 } |
|
3178 |
|
3668 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
3179 #endif //RD_UI_TRANSITION_EFFECTS_LIST |
3669 } |
|
3670 } |
|
3671 |
|
3672 |
|
3673 // ----------------------------------------------------------------------------- |
|
3674 // CAknTreeListView::LoadMarkingIconsL |
|
3675 // ----------------------------------------------------------------------------- |
|
3676 // |
|
3677 void CAknTreeListView::LoadMarkingIconsL() |
|
3678 { |
|
3679 if ( !iMarkingIconArray ) |
|
3680 { |
|
3681 iMarkingIconArray = new ( ELeave ) |
|
3682 CAknIconArray( KMarkingModeIconArraySize ); |
|
3683 } |
|
3684 else |
|
3685 { |
|
3686 iMarkingIconArray->ResetAndDestroy(); |
|
3687 } |
|
3688 |
|
3689 MAknsSkinInstance* skin = AknsUtils::SkinInstance(); |
|
3690 const TDesC& avkonIconFile = AknIconUtils::AvkonIconFileName(); |
|
3691 |
|
3692 CGulIcon* icon = AknsUtils::CreateGulIconL( skin, |
|
3693 KAknsIIDQgnPropCheckboxOn, |
|
3694 avkonIconFile, |
|
3695 EMbmAvkonQgn_prop_checkbox_on, |
|
3696 EMbmAvkonQgn_prop_checkbox_on_mask ); |
|
3697 |
|
3698 CleanupStack::PushL( icon ); |
|
3699 iMarkingIconArray->AppendL( icon ); |
|
3700 CleanupStack::Pop( icon ); |
|
3701 |
|
3702 icon = AknsUtils::CreateGulIconL( skin, |
|
3703 KAknsIIDQgnPropCheckboxOff, |
|
3704 avkonIconFile, |
|
3705 EMbmAvkonQgn_prop_checkbox_off, |
|
3706 EMbmAvkonQgn_prop_checkbox_off_mask ); |
|
3707 |
|
3708 CleanupStack::PushL( icon ); |
|
3709 iMarkingIconArray->AppendL( icon ); |
|
3710 CleanupStack::Pop( icon ); |
|
3711 } |
|
3712 |