18 // INCLUDE FILES |
18 // INCLUDE FILES |
19 #include <QList> |
19 #include <QList> |
20 #include <logview.h> |
20 #include <logview.h> |
21 #include <logwraplimits.h> |
21 #include <logwraplimits.h> |
22 #include "logsreaderstates.h" |
22 #include "logsreaderstates.h" |
|
23 #include "logsstatebasecontext.h" |
23 #include "logsreaderstatecontext.h" |
24 #include "logsreaderstatecontext.h" |
24 #include "logsevent.h" |
25 #include "logsevent.h" |
25 #include "logseventdata.h" |
26 #include "logseventdata.h" |
26 #include "logsengdefs.h" |
27 #include "logsengdefs.h" |
27 #include "logslogger.h" |
28 #include "logslogger.h" |
33 // ---------------------------------------------------------------------------- |
34 // ---------------------------------------------------------------------------- |
34 // LogsReaderStateBase::LogsReaderStateBase |
35 // LogsReaderStateBase::LogsReaderStateBase |
35 // ---------------------------------------------------------------------------- |
36 // ---------------------------------------------------------------------------- |
36 // |
37 // |
37 LogsReaderStateBase::LogsReaderStateBase( |
38 LogsReaderStateBase::LogsReaderStateBase( |
38 LogsReaderStateContext& context) |
39 LogsStateBaseContext& context, LogsReaderStateContext& readerContext) |
39 : mContext(context), |
40 : LogsStateBase(context), |
40 mNextState(0) |
41 mContext(readerContext) |
41 { |
42 { |
42 } |
43 } |
43 |
44 |
44 // ---------------------------------------------------------------------------- |
45 // ---------------------------------------------------------------------------- |
45 // LogsReaderStateBase::~LogsReaderStateBase |
46 // LogsReaderStateBase::~LogsReaderStateBase |
47 // |
48 // |
48 LogsReaderStateBase::~LogsReaderStateBase() |
49 LogsReaderStateBase::~LogsReaderStateBase() |
49 { |
50 { |
50 |
51 |
51 } |
52 } |
52 |
|
53 // ---------------------------------------------------------------------------- |
|
54 // LogsReaderStateFiltering::setNextState |
|
55 // ---------------------------------------------------------------------------- |
|
56 // |
|
57 void LogsReaderStateBase::setNextState(LogsReaderStateBase& nextState) |
|
58 { |
|
59 mNextState = &nextState; |
|
60 } |
|
61 |
|
62 // ---------------------------------------------------------------------------- |
|
63 // LogsReaderStateFiltering::enterNextStateL |
|
64 // ---------------------------------------------------------------------------- |
|
65 // |
|
66 bool LogsReaderStateBase::enterNextStateL() |
|
67 { |
|
68 if ( mNextState ){ |
|
69 mContext.setCurrentState(*mNextState); |
|
70 return mNextState->enterL(); |
|
71 } |
|
72 return false; |
|
73 } |
|
74 |
|
75 // ---------------------------------------------------------------------------- |
|
76 // LogsReaderStateBase::enterL |
|
77 // ---------------------------------------------------------------------------- |
|
78 // |
|
79 bool LogsReaderStateBase::enterL() |
|
80 { |
|
81 return false; |
|
82 } |
|
83 |
|
84 // ---------------------------------------------------------------------------- |
|
85 // LogsReaderStateBase::continueL |
|
86 // ---------------------------------------------------------------------------- |
|
87 // |
|
88 bool LogsReaderStateBase::continueL() |
|
89 { |
|
90 return false; |
|
91 } |
|
92 |
|
93 // ---------------------------------------------------------------------------- |
|
94 // LogsReaderStateBase::viewCount |
|
95 // ---------------------------------------------------------------------------- |
|
96 // |
|
97 int LogsReaderStateBase::viewCountL() const |
|
98 { |
|
99 return mContext.logView().CountL(); |
|
100 } |
|
101 |
|
102 // ---------------------------------------------------------------------------- |
|
103 // LogsReaderStateBase::event |
|
104 // ---------------------------------------------------------------------------- |
|
105 // |
|
106 CLogEvent& LogsReaderStateBase::event() const |
|
107 { |
|
108 //The RVCT compiler provides warnings "type qualifier on return type is meaningless" |
|
109 //for functions that return const values. In order to avoid these numerous warnings and |
|
110 //const cascading, the CLogEvent is const_casted here. |
|
111 return const_cast<CLogEvent&>( mContext.logView().Event() ); |
|
112 } |
|
113 |
53 |
114 // ---------------------------------------------------------------------------- |
54 // ---------------------------------------------------------------------------- |
115 // LogsReaderStateBase::updateAndInsertEventL |
55 // LogsReaderStateBase::updateAndInsertEventL |
116 // ---------------------------------------------------------------------------- |
56 // ---------------------------------------------------------------------------- |
117 // |
57 // |
189 } |
129 } |
190 return event; |
130 return event; |
191 } |
131 } |
192 |
132 |
193 // ---------------------------------------------------------------------------- |
133 // ---------------------------------------------------------------------------- |
194 // LogsReaderStateBase::duplicatesL |
|
195 // ---------------------------------------------------------------------------- |
|
196 // |
|
197 bool LogsReaderStateBase::duplicatesL(const CLogFilter* aFilter){ |
|
198 bool gettingDuplicates( false ); |
|
199 if ( mContext.isRecentView() ){ |
|
200 if ( aFilter ){ |
|
201 gettingDuplicates = |
|
202 static_cast<CLogViewRecent&>( mContext.logView() ).DuplicatesL( |
|
203 mContext.duplicatesView(), *aFilter, mContext.reqStatus() ); |
|
204 } else { |
|
205 gettingDuplicates = |
|
206 static_cast<CLogViewRecent&>( mContext.logView() ).DuplicatesL( |
|
207 mContext.duplicatesView(), mContext.reqStatus() ); |
|
208 } |
|
209 } |
|
210 return gettingDuplicates; |
|
211 } |
|
212 |
|
213 // ---------------------------------------------------------------------------- |
|
214 // LogsReaderStateInitReading::LogsReaderStateInitReading |
134 // LogsReaderStateInitReading::LogsReaderStateInitReading |
215 // ---------------------------------------------------------------------------- |
135 // ---------------------------------------------------------------------------- |
216 // |
136 // |
217 LogsReaderStateInitReading::LogsReaderStateInitReading( |
137 LogsReaderStateInitReading::LogsReaderStateInitReading( |
218 LogsReaderStateContext& context ) |
138 LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) |
219 : LogsReaderStateBase(context) |
139 : LogsReaderStateBase(context, readerContext) |
220 { |
140 { |
221 } |
141 } |
222 |
142 |
223 // ---------------------------------------------------------------------------- |
143 // ---------------------------------------------------------------------------- |
224 // LogsReaderInitReadingState::enterL |
144 // LogsReaderInitReadingState::enterL |
234 // ---------------------------------------------------------------------------- |
154 // ---------------------------------------------------------------------------- |
235 // LogsReaderStateFiltering::LogsReaderStateFiltering |
155 // LogsReaderStateFiltering::LogsReaderStateFiltering |
236 // ---------------------------------------------------------------------------- |
156 // ---------------------------------------------------------------------------- |
237 // |
157 // |
238 LogsReaderStateFiltering::LogsReaderStateFiltering( |
158 LogsReaderStateFiltering::LogsReaderStateFiltering( |
239 LogsReaderStateContext& context ) |
159 LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) |
240 : LogsReaderStateBase(context), |
160 : LogsReaderStateBase(context, readerContext), |
241 mFilterList(0) |
161 mFilterList(0) |
242 { |
162 { |
243 } |
163 } |
244 |
164 |
245 // ---------------------------------------------------------------------------- |
165 // ---------------------------------------------------------------------------- |
301 // ---------------------------------------------------------------------------- |
221 // ---------------------------------------------------------------------------- |
302 // LogsReaderStateFiltering::setFilterL |
222 // LogsReaderStateFiltering::setFilterL |
303 // ---------------------------------------------------------------------------- |
223 // ---------------------------------------------------------------------------- |
304 // |
224 // |
305 bool LogsReaderStateFiltering::setFilterL(CLogFilterList& filterList){ |
225 bool LogsReaderStateFiltering::setFilterL(CLogFilterList& filterList){ |
306 __ASSERT_ALWAYS( mContext.isRecentView(), User::Leave( KErrNotFound ) ); |
226 __ASSERT_ALWAYS( mBaseContext.isRecentView(), User::Leave( KErrNotFound ) ); |
307 return static_cast<CLogViewRecent&>( mContext.logView() ).SetRecentListL( |
227 return static_cast<CLogViewRecent&>( mBaseContext.logView() ).SetRecentListL( |
308 KLogNullRecentList, filterList, mContext.reqStatus() ); |
228 KLogNullRecentList, filterList, mBaseContext.reqStatus() ); |
309 } |
229 } |
310 |
230 |
311 // ---------------------------------------------------------------------------- |
231 // ---------------------------------------------------------------------------- |
312 // LogsReaderStateFiltering::LogsReaderStateFiltering |
232 // LogsReaderStateFiltering::LogsReaderStateFiltering |
313 // ---------------------------------------------------------------------------- |
233 // ---------------------------------------------------------------------------- |
314 // |
234 // |
315 LogsReaderStateFilteringAll::LogsReaderStateFilteringAll( |
235 LogsReaderStateFilteringAll::LogsReaderStateFilteringAll( |
316 LogsReaderStateContext& context ) |
236 LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) |
317 : LogsReaderStateFiltering(context) |
237 : LogsReaderStateFiltering(context, readerContext) |
318 { |
238 { |
319 } |
239 } |
320 |
240 |
321 // ---------------------------------------------------------------------------- |
241 // ---------------------------------------------------------------------------- |
322 // LogsReaderStateFilteringAll::~LogsReaderStateFilteringAll |
242 // LogsReaderStateFilteringAll::~LogsReaderStateFilteringAll |
329 // ---------------------------------------------------------------------------- |
249 // ---------------------------------------------------------------------------- |
330 // LogsReaderStateFilteringAll::setFilterL |
250 // LogsReaderStateFilteringAll::setFilterL |
331 // ---------------------------------------------------------------------------- |
251 // ---------------------------------------------------------------------------- |
332 // |
252 // |
333 bool LogsReaderStateFilteringAll::setFilterL(CLogFilterList& filterList){ |
253 bool LogsReaderStateFilteringAll::setFilterL(CLogFilterList& filterList){ |
334 __ASSERT_ALWAYS( !mContext.isRecentView(), User::Leave( KErrNotFound ) ); |
254 __ASSERT_ALWAYS( !mBaseContext.isRecentView(), User::Leave( KErrNotFound ) ); |
335 return static_cast<CLogViewEvent&>( mContext.logView() ).SetFilterL( |
255 return static_cast<CLogViewEvent&>( mBaseContext.logView() ).SetFilterL( |
336 filterList, mContext.reqStatus() ); |
256 filterList, mBaseContext.reqStatus() ); |
337 } |
257 } |
338 |
258 |
339 // ---------------------------------------------------------------------------- |
259 // ---------------------------------------------------------------------------- |
340 // LogsReaderStateReading::LogsReaderStateReading |
260 // LogsReaderStateReading::LogsReaderStateReading |
341 // ---------------------------------------------------------------------------- |
261 // ---------------------------------------------------------------------------- |
342 // |
262 // |
343 LogsReaderStateReading::LogsReaderStateReading( |
263 LogsReaderStateReading::LogsReaderStateReading( |
344 LogsReaderStateContext& context ) |
264 LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) |
345 : LogsReaderStateBase(context), |
265 : LogsReaderStateBase(context, readerContext), |
346 mDuplicateMissedFilter(0), |
266 mDuplicateMissedFilter(0), |
347 mCheckingMissed(false), |
267 mCheckingMissed(false), |
348 mEventIndex(0), |
268 mEventIndex(0), |
349 mReadSizeCounter(0) |
269 mReadSizeCounter(0) |
350 { |
270 { |
374 mDuplicateMissedFilter = CLogFilter::NewL(); |
294 mDuplicateMissedFilter = CLogFilter::NewL(); |
375 mDuplicateMissedFilter->SetFlags(KLogEventRead); |
295 mDuplicateMissedFilter->SetFlags(KLogEventRead); |
376 mDuplicateMissedFilter->SetNullFields(ELogFlagsField); |
296 mDuplicateMissedFilter->SetNullFields(ELogFlagsField); |
377 } |
297 } |
378 |
298 |
379 if ( viewCountL() > 0 && mContext.logView().FirstL( mContext.reqStatus() ) ){ |
299 if ( viewCountL() > 0 && mBaseContext.logView().FirstL( mBaseContext.reqStatus() ) ){ |
380 return true; |
300 return true; |
381 } |
301 } |
382 |
302 |
383 // Not possible to continue with reading |
303 // Not possible to continue with reading |
384 return enterNextStateL(); |
304 return enterNextStateL(); |
388 // LogsReaderStateReading::continueL |
308 // LogsReaderStateReading::continueL |
389 // ---------------------------------------------------------------------------- |
309 // ---------------------------------------------------------------------------- |
390 // |
310 // |
391 bool LogsReaderStateReading::continueL() |
311 bool LogsReaderStateReading::continueL() |
392 { |
312 { |
393 int& index = mContext.index(); |
313 int& index = mBaseContext.index(); |
394 QList<LogsEvent*> &events = mContext.events(); |
314 QList<LogsEvent*> &events = mContext.events(); |
395 |
315 |
396 if ( mCheckingMissed ) { |
316 if ( mCheckingMissed ) { |
397 events.at(mEventIndex-1)->setDuplicates( |
317 events.at(mEventIndex-1)->setDuplicates( |
398 mContext.duplicatesView().CountL() ); |
318 mBaseContext.duplicatesView().CountL() ); |
399 mCheckingMissed = false; |
319 mCheckingMissed = false; |
400 } |
320 } |
401 else { |
321 else { |
402 const CLogEvent& sourceEvent = event(); |
322 const CLogEvent& sourceEvent = event(); |
403 LogsEvent* event = takeMatchingEvent(sourceEvent); |
323 LogsEvent* event = takeMatchingEvent(sourceEvent); |
474 // ---------------------------------------------------------------------------- |
394 // ---------------------------------------------------------------------------- |
475 // LogsReaderStateFillDetails::LogsReaderStateFillDetails |
395 // LogsReaderStateFillDetails::LogsReaderStateFillDetails |
476 // ---------------------------------------------------------------------------- |
396 // ---------------------------------------------------------------------------- |
477 // |
397 // |
478 LogsReaderStateFillDetails::LogsReaderStateFillDetails( |
398 LogsReaderStateFillDetails::LogsReaderStateFillDetails( |
479 LogsReaderStateContext& context) |
399 LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) |
480 : LogsReaderStateBase(context) |
400 : LogsReaderStateBase(context, readerContext) |
481 { |
401 { |
482 } |
402 } |
483 |
403 |
484 // ---------------------------------------------------------------------------- |
404 // ---------------------------------------------------------------------------- |
485 // LogsReaderStateFillDetails::~LogsReaderStateFillDetails |
405 // LogsReaderStateFillDetails::~LogsReaderStateFillDetails |
537 // ---------------------------------------------------------------------------- |
457 // ---------------------------------------------------------------------------- |
538 // LogsReaderStateDone::LogsReaderStateDone |
458 // LogsReaderStateDone::LogsReaderStateDone |
539 // ---------------------------------------------------------------------------- |
459 // ---------------------------------------------------------------------------- |
540 // |
460 // |
541 LogsReaderStateDone::LogsReaderStateDone( |
461 LogsReaderStateDone::LogsReaderStateDone( |
542 LogsReaderStateContext& context ) |
462 LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) |
543 : LogsReaderStateBase(context) |
463 : LogsReaderStateBase(context, readerContext) |
544 { |
464 { |
545 } |
465 } |
546 |
466 |
547 // ---------------------------------------------------------------------------- |
467 // ---------------------------------------------------------------------------- |
548 // LogsReaderStateDone::~LogsReaderStateDone |
468 // LogsReaderStateDone::~LogsReaderStateDone |
558 // |
478 // |
559 bool LogsReaderStateDone::enterL() |
479 bool LogsReaderStateDone::enterL() |
560 { |
480 { |
561 LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateDone::enterL" ); |
481 LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateDone::enterL" ); |
562 |
482 |
563 int numRead = qMin(mContext.index(),viewCountL()); |
483 int numRead = qMin(mBaseContext.index(),viewCountL()); |
564 mContext.observer().readCompleted(numRead); |
484 mContext.observer().readCompleted(numRead); |
565 |
485 |
566 LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateDone::enterL" ); |
486 LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateDone::enterL" ); |
567 |
487 |
568 return false; |
488 return false; |
569 } |
489 } |
570 |
|
571 |
|
572 // ---------------------------------------------------------------------------- |
|
573 // LogsReaderStateSearchingEvent::LogsReaderStateSearchingEvent |
|
574 // ---------------------------------------------------------------------------- |
|
575 // |
|
576 LogsReaderStateSearchingEvent::LogsReaderStateSearchingEvent( |
|
577 LogsReaderStateContext& context ) |
|
578 : LogsReaderStateBase(context) |
|
579 { |
|
580 } |
|
581 |
|
582 |
|
583 // ---------------------------------------------------------------------------- |
|
584 // LogsReaderStateSearchingEvent::enterL |
|
585 // ---------------------------------------------------------------------------- |
|
586 // |
|
587 bool LogsReaderStateSearchingEvent::enterL() |
|
588 { |
|
589 LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateSearchingEvent::enterL" ); |
|
590 if ( viewCountL() > 0 && mContext.logView().FirstL( mContext.reqStatus() ) ){ |
|
591 return true; |
|
592 } |
|
593 return enterNextStateL(); |
|
594 } |
|
595 |
|
596 |
|
597 // ---------------------------------------------------------------------------- |
|
598 // LogsReaderStateSearchingEvent::continueL |
|
599 // ---------------------------------------------------------------------------- |
|
600 // |
|
601 bool LogsReaderStateSearchingEvent::continueL() |
|
602 { |
|
603 LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateSearchingEvent::continueL" ); |
|
604 int& index = mContext.index(); |
|
605 if ( event().Id() != mContext.currentEventId() ) { |
|
606 index++; |
|
607 if ( index < viewCountL() ){ |
|
608 return mContext.logView().NextL( mContext.reqStatus() ); |
|
609 } |
|
610 } |
|
611 |
|
612 return enterNextStateL(); |
|
613 } |
|
614 |
490 |
615 // ---------------------------------------------------------------------------- |
491 // ---------------------------------------------------------------------------- |
616 // LogsReaderStateFindingDuplicates::LogsReaderStateFindingDuplicates |
492 // LogsReaderStateFindingDuplicates::LogsReaderStateFindingDuplicates |
617 // ---------------------------------------------------------------------------- |
493 // ---------------------------------------------------------------------------- |
618 // |
494 // |
619 LogsReaderStateFindingDuplicates::LogsReaderStateFindingDuplicates( |
495 LogsReaderStateFindingDuplicates::LogsReaderStateFindingDuplicates( |
620 LogsReaderStateContext& context ) |
496 LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) |
621 : LogsReaderStateBase(context), |
497 : LogsReaderStateBase(context, readerContext), |
622 mDuplicateFilter(0) |
498 mDuplicateFilter(0) |
623 { |
499 { |
624 } |
500 } |
625 |
501 |
626 // ---------------------------------------------------------------------------- |
502 // ---------------------------------------------------------------------------- |
671 // ---------------------------------------------------------------------------- |
547 // ---------------------------------------------------------------------------- |
672 // LogsReaderStateMarkingDuplicates::LogsReaderStateMarkingDuplicates |
548 // LogsReaderStateMarkingDuplicates::LogsReaderStateMarkingDuplicates |
673 // ---------------------------------------------------------------------------- |
549 // ---------------------------------------------------------------------------- |
674 // |
550 // |
675 LogsReaderStateMarkingDuplicates::LogsReaderStateMarkingDuplicates( |
551 LogsReaderStateMarkingDuplicates::LogsReaderStateMarkingDuplicates( |
676 LogsReaderStateContext& context ) |
552 LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) |
677 : LogsReaderStateBase(context) |
553 : LogsReaderStateBase(context, readerContext) |
678 { |
554 { |
679 } |
555 } |
680 |
556 |
681 // ---------------------------------------------------------------------------- |
557 // ---------------------------------------------------------------------------- |
682 // LogsReaderStateMarkingDuplicates::enterL |
558 // LogsReaderStateMarkingDuplicates::enterL |
685 bool LogsReaderStateMarkingDuplicates::enterL() |
561 bool LogsReaderStateMarkingDuplicates::enterL() |
686 { |
562 { |
687 LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateMarkingDuplicates::enterL" ); |
563 LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateMarkingDuplicates::enterL" ); |
688 |
564 |
689 mGettingDuplicates = false; |
565 mGettingDuplicates = false; |
690 if ( event().Id() == mContext.currentEventId() ) { |
566 if ( event().Id() == mBaseContext.currentEventId() ) { |
691 // Mark event read |
567 // Mark event read |
692 event().SetFlags( event().Flags() | KLogEventRead ); |
568 event().SetFlags( event().Flags() | KLogEventRead ); |
693 mContext.logClient().ChangeEvent(event(), mContext.reqStatus()); |
569 mBaseContext.logClient().ChangeEvent(event(), mBaseContext.reqStatus()); |
694 return true; |
570 return true; |
695 } |
571 } |
696 |
572 |
697 // Not possible to continue with marking |
573 // Not possible to continue with marking |
698 return enterNextStateL(); |
574 return enterNextStateL(); |
712 mGettingDuplicates = true; |
588 mGettingDuplicates = true; |
713 return true; |
589 return true; |
714 } |
590 } |
715 } else { |
591 } else { |
716 // Mark duplicate events read |
592 // Mark duplicate events read |
717 mContext.duplicatesView().SetFlagsL( |
593 mBaseContext.duplicatesView().SetFlagsL( |
718 mContext.duplicatesView().Event().Flags() | KLogEventRead ); |
594 mBaseContext.duplicatesView().Event().Flags() | KLogEventRead ); |
719 } |
595 } |
720 |
596 |
721 LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateMarkingDuplicates::continueL" ); |
597 LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateMarkingDuplicates::continueL" ); |
722 |
598 |
723 return enterNextStateL(); |
599 return enterNextStateL(); |
726 // ---------------------------------------------------------------------------- |
602 // ---------------------------------------------------------------------------- |
727 // LogsReaderStateReadingDuplicates::LogsReaderStateReadingDuplicates |
603 // LogsReaderStateReadingDuplicates::LogsReaderStateReadingDuplicates |
728 // ---------------------------------------------------------------------------- |
604 // ---------------------------------------------------------------------------- |
729 // |
605 // |
730 LogsReaderStateReadingDuplicates::LogsReaderStateReadingDuplicates( |
606 LogsReaderStateReadingDuplicates::LogsReaderStateReadingDuplicates( |
731 LogsReaderStateContext& context ) |
607 LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) |
732 : LogsReaderStateBase(context) |
608 : LogsReaderStateBase(context, readerContext) |
733 { |
609 { |
734 } |
610 } |
735 |
611 |
736 // ---------------------------------------------------------------------------- |
612 // ---------------------------------------------------------------------------- |
737 // LogsReaderStateReadingDuplicates::enterL |
613 // LogsReaderStateReadingDuplicates::enterL |
738 // ---------------------------------------------------------------------------- |
614 // ---------------------------------------------------------------------------- |
739 // |
615 // |
740 bool LogsReaderStateReadingDuplicates::enterL() |
616 bool LogsReaderStateReadingDuplicates::enterL() |
741 { |
617 { |
742 LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateReadingDuplicates::enterL" ); |
618 LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateReadingDuplicates::enterL" ); |
743 if ( mContext.duplicatesView().CountL() > 0 && |
619 if ( mBaseContext.duplicatesView().CountL() > 0 && |
744 mContext.duplicatesView().FirstL(mContext.reqStatus()) ){ |
620 mBaseContext.duplicatesView().FirstL(mBaseContext.reqStatus()) ){ |
745 LOGS_QDEBUG( "logs [ENG] duplicates exist!"); |
621 LOGS_QDEBUG( "logs [ENG] duplicates exist!"); |
746 return true; |
622 return true; |
747 } |
623 } |
748 |
624 |
749 // Not possible to continue with deletion |
625 // Not possible to continue with deletion |
757 bool LogsReaderStateReadingDuplicates::continueL() |
633 bool LogsReaderStateReadingDuplicates::continueL() |
758 { |
634 { |
759 LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateReadingDuplicates::continueL" ); |
635 LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateReadingDuplicates::continueL" ); |
760 |
636 |
761 int nextIndex = mContext.duplicatedEvents().count(); |
637 int nextIndex = mContext.duplicatedEvents().count(); |
762 const CLogEvent& sourceEvent = mContext.duplicatesView().Event(); |
638 const CLogEvent& sourceEvent = mBaseContext.duplicatesView().Event(); |
763 LogsEvent* event = new LogsEvent; |
639 LogsEvent* event = new LogsEvent; |
764 constructAndInsertEventL( |
640 constructAndInsertEventL( |
765 sourceEvent, event, nextIndex, mContext.duplicatedEvents() ); |
641 sourceEvent, event, nextIndex, mContext.duplicatedEvents() ); |
766 if ( mContext.duplicatesView().NextL(mContext.reqStatus()) ) { |
642 if ( mBaseContext.duplicatesView().NextL(mBaseContext.reqStatus()) ) { |
767 return true; |
643 return true; |
768 } |
644 } |
769 |
645 |
770 LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateReadingDuplicates::continueL" ); |
646 LOGS_QDEBUG( "logs [ENG] <- LogsReaderStateReadingDuplicates::continueL" ); |
771 |
647 |
775 // ---------------------------------------------------------------------------- |
651 // ---------------------------------------------------------------------------- |
776 // LogsReaderStateModifyingDone::LogsReaderStateModifyingDone |
652 // LogsReaderStateModifyingDone::LogsReaderStateModifyingDone |
777 // ---------------------------------------------------------------------------- |
653 // ---------------------------------------------------------------------------- |
778 // |
654 // |
779 LogsReaderStateModifyingDone::LogsReaderStateModifyingDone( |
655 LogsReaderStateModifyingDone::LogsReaderStateModifyingDone( |
780 LogsReaderStateContext& context) : LogsReaderStateBase(context) |
656 LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) |
|
657 : LogsReaderStateBase(context, readerContext) |
781 { |
658 { |
782 |
659 |
783 } |
660 } |
784 |
661 |
785 // ---------------------------------------------------------------------------- |
662 // ---------------------------------------------------------------------------- |
788 // |
665 // |
789 bool LogsReaderStateModifyingDone::enterL() |
666 bool LogsReaderStateModifyingDone::enterL() |
790 { |
667 { |
791 LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateModifyingDone::enterL" ); |
668 LOGS_QDEBUG( "logs [ENG] -> LogsReaderStateModifyingDone::enterL" ); |
792 |
669 |
793 LogsEvent* modifiedEvent = eventById(mContext.currentEventId()); |
670 LogsEvent* modifiedEvent = eventById(mBaseContext.currentEventId()); |
794 if ( modifiedEvent ){ |
671 if ( modifiedEvent ){ |
795 // Update modified event to know that it has been marked. Real |
672 // Update modified event to know that it has been marked. Real |
796 // update of the event happens soon when db notifies the change. |
673 // update of the event happens soon when db notifies the change. |
797 modifiedEvent->markedAsSeenLocally(true); |
674 modifiedEvent->markedAsSeenLocally(true); |
798 } |
675 } |
806 // ---------------------------------------------------------------------------- |
683 // ---------------------------------------------------------------------------- |
807 // LogsReaderStateReadingDuplicatesDone::LogsReaderStateReadingDuplicatesDone |
684 // LogsReaderStateReadingDuplicatesDone::LogsReaderStateReadingDuplicatesDone |
808 // ---------------------------------------------------------------------------- |
685 // ---------------------------------------------------------------------------- |
809 // |
686 // |
810 LogsReaderStateReadingDuplicatesDone::LogsReaderStateReadingDuplicatesDone( |
687 LogsReaderStateReadingDuplicatesDone::LogsReaderStateReadingDuplicatesDone( |
811 LogsReaderStateContext& context) : LogsReaderStateBase(context) |
688 LogsStateBaseContext& context, LogsReaderStateContext& readerContext ) |
|
689 : LogsReaderStateBase(context, readerContext) |
812 { |
690 { |
813 |
691 |
814 } |
692 } |
815 |
693 |
816 // ---------------------------------------------------------------------------- |
694 // ---------------------------------------------------------------------------- |