void IHaveDragPoints::FlipPointX(Vertex2D *pvCenter) { GetIEditable()->BeginUndo(); GetIEditable()->MarkForUndo(); Vertex2D newcenter; GetPointCenter(&newcenter); const float xcenter = pvCenter->x; for (int i = 0; i < m_vdpoint.Size(); i++) { const float deltax = m_vdpoint.ElementAt(i)->m_v.x - xcenter; m_vdpoint.ElementAt(i)->m_v.x -= deltax*2.0f; } const float deltax = newcenter.x - xcenter; newcenter.x -= deltax*2.0f; PutPointCenter(&newcenter); ReverseOrder(); GetIEditable()->EndUndo(); GetPTable()->SetDirtyDraw(); }
/**--------------------------------------------------------------------------<BR> C2DLineBaseSet::ReverseDirection \brief Reverse direction. <P>---------------------------------------------------------------------------*/ void C2DLineBaseSet::ReverseDirection(void ) { ReverseOrder(); for (unsigned int i = 0; i < size() ; i++) { GetAt(i)->ReverseDirection(); } }
void CustomVirtListCtrl<T,L>::OnColClick( wxListEvent& event ) { if ( event.GetColumn() == -1 ) return; const int evt_col = event.GetColumn(); m_sort_timer.Stop();//otherwise sorting will be way delayed int old_sort_col = m_sortorder[0].col; wxListItem col; GetColumn( m_sortorder[0].col, col ); col.SetImage( icons().ICON_NONE ); SetColumn( m_sortorder[0].col, col ); unsigned int i = 0; SortOrder::const_iterator it = m_sortorder.begin(); for ( ; it != m_sortorder.begin(); ++i, ++it ) { if ( m_sortorder[i].col == evt_col ) break; } // for ( ; m_sortorder[i].col != event.GetColumn() && i < 4; ++i ) {} i = LSL::Util::Clamp( i, (unsigned int)0, m_sort_criteria_count ); for ( ; i > 0; i--) { m_sortorder[i] = m_sortorder[i-1]; } m_sortorder[0].col = evt_col; m_sortorder[0].direction *= -1; GetColumn( m_sortorder[0].col, col ); //col.SetImage( ( m_sortorder[0].direction )?ICON_UP:ICON_DOWN ); col.SetImage( ( m_sortorder[0].direction > 0 )?icons().ICON_UP:icons().ICON_DOWN ); SetColumn( m_sortorder[0].col, col ); if ( (old_sort_col != m_sortorder[0].col) || m_dirty_sort) { SortList( true ); } else { // O(n) instead of guaranteed worst case O(n*n) ReverseOrder(); } }
/**--------------------------------------------------------------------------<BR> C2DBaseSet::SortByDistance \brief Sorts the collection by the distance from the point. <P>---------------------------------------------------------------------------*/ void C2DBaseSet::SortByDistance(const C2DPoint& pt, bool bAscending) { C2DBaseData& Data = *reinterpret_cast<C2DBaseData*>(m_Data); std::vector<double> dDists; for (unsigned int i = 0 ; i < size(); i++) { dDists.push_back( GetAt(i)->Distance(pt)); } GeoSort::PQuickSort<std::vector<double>, double, C2DBaseData, C2DBase*>(dDists, Data); if (! bAscending) ReverseOrder(); }
void CMsvEntryArray::ReverseOrder(TMsvSorting aSortType) // // Reverse based in SortBy value // { switch(aSortType) { case EMsvSortByDateReverse: case EMsvSortByIdReverse: case EMsvSortBySizeReverse: case EMsvSortByDescriptionReverse: case EMsvSortByDetailsReverse: ReverseOrder(); break; default: // Not required - break return; } }
void CMsvEntryArray::GroupL(TGroupCriterion aGroupCriterion,TMsvSelectionOrdering aOrdering,TBool aDoSort) // // This function works recursively, grouping and sorting the entry selection. The // 'sort' happens at the same time as the 1st 'group', then separate grouped arrays // are grouped indidvidually and then merged together at the end. The order in which // the grouping occurs is determined by the CMsvEntryArray::TGroupCriterion enum // { TMsvSorting sortType=aOrdering.Sorting(); TKeyArrayFixPtr key=MessageSortKey(sortType); if (aGroupCriterion==EStopGrouping) { // if you haven't sorted yet if (aDoSort) { // Subject based sorting requires a special algorithm. Only message entries are treated as other entries normally // do not have a prefix like e.g. "re: " or "fwd: " if(At(0)->iType == KUidMsvMessageEntry && (sortType == EMsvSortByDescription || sortType == EMsvSortByDescriptionReverse)) { SubjectBasedSortL(sortType == EMsvSortByDescriptionReverse,aOrdering.SubjectSkipString()); } else { CMsvEntryArray* temp=CMsvEntryArray::NewLC(iOrigMtmList); TInt count=Count(); if (count) temp->InsertL(0,&(*(this))[0],count); Reset(); const TMsvEntry** entry = &temp->At(0); while (count--) InsertIsqAllowDuplicatesL(*entry++, key); // Sorted ReverseOrder(sortType); CleanupStack::PopAndDestroy(); // temp } if (At(0)->iType == KUidMsvMessageEntry && (sortType == EMsvSortByDetails || sortType == EMsvSortByDetailsReverse)) { DetailBasedSortL(); // Sort blocks of messages with matching details into newest first } } else { // The aDoSort flag is not set, but we still need to do a subject // based sort if this array contains only message entries, and we are // sorting by description. Alternatively, we need to do a date based sort // if this array contains only message entries and we are sorting by detail. // In order to ensure the array contains only message entries, we // check that we have previously grouped the entries by type which would // have put all the message entries together in their own array. if (Count() > 0 && At(0)->iType == KUidMsvMessageEntry && OkToGroup(EGroupByType, aOrdering)) { if (sortType == EMsvSortByDescription || sortType == EMsvSortByDescriptionReverse) { SubjectBasedSortL(sortType == EMsvSortByDescriptionReverse,aOrdering.SubjectSkipString()); } else if (sortType == EMsvSortByDetails || sortType == EMsvSortByDetailsReverse) { DetailBasedSortL(); // Sort blocks of messages with matching details into newest first } } } return; } if (OkToGroup(aGroupCriterion, aOrdering)) { // // Copy contents into temp and then put new grouped contents into 'this' TInt count=Count(); if (count==0) return; // nothing to do here const TInt numberOfArrays=NumberOfArraysToSplitIntoL(aGroupCriterion); if (numberOfArrays<1) // cannot group on this so move on to next grouping { GroupL(TGroupCriterion(aGroupCriterion+1), aOrdering, aDoSort); return; } CMsvEntryArray* temp; if (iActualMtmList) temp = CMsvEntryArray::NewLC(*iActualMtmList); else temp = CMsvEntryArray::NewLC(iOrigMtmList); temp->InsertL(0,&(*(this))[0],count); Reset(); // // create the separate arrays for each group CArrayFixFlat<CMsvEntryArray*>* arrays=new(ELeave) CArrayFixFlat<CMsvEntryArray*>(numberOfArrays); CleanupStack::PushL(arrays); for (TInt ii=0; ii<numberOfArrays; ii++) { if (iActualMtmList) arrays->AppendL(CMsvEntryArray::NewLC(*iActualMtmList)); else arrays->AppendL(CMsvEntryArray::NewLC(iOrigMtmList)); } // // split the selection into the correct group, // sorting aswell if needed and not doing standard folders const TMsvEntry** entry = &temp->At(0); if (!aDoSort || aGroupCriterion==EGroupByStandardFolders) { while (count--) { arrays->At(ArrayId(*entry,aGroupCriterion))->AppendL(*entry); entry++; } } else if (aGroupCriterion==EGroupByType) { TKeyArrayFixPtr folderKey = TKeyArrayFixPtr(_FOFF(TMsvEntry,iDetails),ECmpCollated); while (count--) { if ((*entry)->iType==KUidMsvFolderEntry) arrays->At(ArrayId(*entry, aGroupCriterion))->InsertIsqAllowDuplicatesL(*entry, folderKey); else arrays->At(ArrayId(*entry, aGroupCriterion))->InsertIsqAllowDuplicatesL(*entry, key); entry++; } for (TInt jj=0; jj<numberOfArrays; jj++) { if (arrays->At(jj)->Count() && arrays->At(jj)->At(0)->iType!=KUidMsvFolderEntry) arrays->At(jj)->ReverseOrder(sortType); } aDoSort=EFalse; } else { while (count--) { arrays->At(ArrayId(*entry, aGroupCriterion))->InsertIsqAllowDuplicatesL(*entry, key); // Sorted entry++; } for (TInt jj=0; jj<numberOfArrays; jj++) arrays->At(jj)->ReverseOrder(sortType); aDoSort=EFalse; } // // group further - but check that standard entries and grouped folders are not grouped anymore if (aGroupCriterion==EGroupByStandardFolders) { __ASSERT_DEBUG(numberOfArrays==2, PanicServer(EMsvToManyGroups)); arrays->At(0)->GroupL(TGroupCriterion(aGroupCriterion+1), aOrdering, aDoSort); } else if (aGroupCriterion==EGroupByType) { for (TInt jj=0; jj<numberOfArrays; jj++) if (arrays->At(jj)->Count() && arrays->At(jj)->At(0)->iType!=KUidMsvFolderEntry) arrays->At(jj)->GroupL(TGroupCriterion(aGroupCriterion+1), aOrdering, aDoSort); } else { for (TInt jj=0; jj<numberOfArrays; jj++) arrays->At(jj)->GroupL(TGroupCriterion(aGroupCriterion+1), aOrdering, aDoSort); } // // merge the separate arrays into 'this' for (TInt kk=0; kk<numberOfArrays; kk++) { count=arrays->At(kk)->Count(); if (count) InsertL(0,&(*(arrays->At(kk)))[0],count); } CleanupStack::PopAndDestroy(numberOfArrays+2); // arrays contents + temp + arrays } else // move on to the next grouping GroupL(TGroupCriterion(aGroupCriterion+1), aOrdering, aDoSort); }