void MainWindow::slotPreferences() { static SettingsDialogWrapper *dlg = 0; if ( !dlg ) { // do not show settings of components running standalone QValueList<KPluginInfo*> filteredPlugins = mPluginInfos; PluginList::ConstIterator it; for ( it = mPlugins.begin(); it != mPlugins.end(); ++it ) if ( (*it)->isRunningStandalone() ) { QValueList<KPluginInfo*>::ConstIterator infoIt; for ( infoIt = filteredPlugins.begin(); infoIt != filteredPlugins.end(); ++infoIt ) { if ( (*infoIt)->pluginName() == (*it)->identifier() ) { filteredPlugins.remove( *infoIt ); break; } } } dlg = new SettingsDialogWrapper( KSettings::Dialog::Configurable, this ); dlg->addPluginInfos( filteredPlugins ); connect( dlg, SIGNAL( pluginSelectionChanged() ), SLOT( pluginsChanged() ) ); } dlg->show(); dlg->fixButtonLabel( this ); }
void OKeyFilterPrivate::remHandler(QWSServer::KeyboardFilter*aF) { if (!aF) return; QValueList<QWSServer::KeyboardFilter*>::Iterator iter; if ( (iter=filterList.find(aF))==filterList.end() ) { return; } odebug << "removing a keyboard filter handler"<<oendl; filterList.remove(iter); }
void AddressEditWidget::setAddresses( const KABC::Addressee &addr, const KABC::Address::List &list ) { mAddressee = addr; mAddressList.clear(); // Insert types for existing numbers. mTypeCombo->insertTypeList( list ); QValueList<int> defaultTypes; defaultTypes << KABC::Address::Home; defaultTypes << KABC::Address::Work; AddresseeConfig config( mAddressee ); const QValueList<int> configList = config.noDefaultAddrTypes(); QValueList<int>::ConstIterator it; for ( it = configList.begin(); it != configList.end(); ++it ) defaultTypes.remove( *it ); // Insert default types. // Doing this for mPrefCombo is enough because the list is shared by all // combos. for ( it = defaultTypes.begin(); it != defaultTypes.end(); ++it ) { if ( !mTypeCombo->hasType( *it ) ) mTypeCombo->insertType( list, *it, Address( *it ) ); } mTypeCombo->updateTypes(); // find preferred address which will be shown int preferred = KABC::Address::Home; // default if no preferred address set KABC::Address::List::ConstIterator addrIt; for ( addrIt = list.begin(); addrIt != list.end(); ++addrIt ) if ( (*addrIt).type() & KABC::Address::Pref ) { preferred = (*addrIt).type(); break; } mTypeCombo->selectType( preferred ); updateAddressEdit(); }
void PMLatheEdit::slotRemovePoint( ) { int row = m_pPoints->currentRow( ); if( row >= 0 ) { QValueList<PMVector> points = m_pPoints->vectors( ); QValueListIterator<PMVector> it = points.at( row ); if( it != points.end( ) && points.size( ) > 1 ) { points.remove( it ); m_pPoints->setVectors( points, true ); updatePointButtons( ); emit dataChanged( ); emit sizeChanged( ); } } }
QValueList<MyMoneyAccount> MyMoneyForecast::accountList(void) { MyMoneyFile* file = MyMoneyFile::instance(); QValueList<MyMoneyAccount> accList; QStringList emptyStringList; //Get all accounts from the file and check if they are present file->accountList(accList, emptyStringList, false); QValueList<MyMoneyAccount>::iterator accList_t = accList.begin(); for(; accList_t != accList.end(); ) { MyMoneyAccount acc = *accList_t; if(!isForecastAccount( acc ) ) { accList.remove(accList_t); //remove the account accList_t = accList.begin(); } else { ++accList_t; } } return accList; }
QValueList<MyMoneyAccount> MyMoneyForecast::forecastAccountList(void) { MyMoneyFile* file = MyMoneyFile::instance(); QValueList<MyMoneyAccount> accList; //Get all accounts from the file and check if they are of the right type to calculate forecast file->accountList(accList); QValueList<MyMoneyAccount>::iterator accList_t = accList.begin(); for(; accList_t != accList.end(); ) { MyMoneyAccount acc = *accList_t; if(acc.isClosed() //check the account is not closed || (!acc.isAssetLiability()) ) { //|| (acc.accountType() == MyMoneyAccount::Investment) ) {//check that it is not an Investment account and only include Stock accounts accList.remove(accList_t); //remove the account if it is not of the correct type accList_t = accList.begin(); } else { ++accList_t; } } return accList; }
QValueList<MyMoneyAccount> MyMoneyForecast::budgetAccountList(void) { MyMoneyFile* file = MyMoneyFile::instance(); QValueList<MyMoneyAccount> accList; QStringList emptyStringList; //Get all accounts from the file and check if they are of the right type to calculate forecast file->accountList(accList, emptyStringList, false); QValueList<MyMoneyAccount>::iterator accList_t = accList.begin(); for(; accList_t != accList.end(); ) { MyMoneyAccount acc = *accList_t; if(acc.isClosed() //check the account is not closed || (!acc.isIncomeExpense()) ) { accList.remove(accList_t); //remove the account if it is not of the correct type accList_t = accList.begin(); } else { ++accList_t; } } return accList; }
/** Delete a memory block. This @em really returns the memory to the heap. @param b block to delete @internal */ void KZoneAllocator::delBlock(MemBlock *b) { /* Update also the hashlists if we aren't going to reconstruct them soon. */ if (hashList && !hashDirty) { unsigned long adr = ((unsigned long)b->begin) & (~(blockSize - 1)); unsigned long end = ((unsigned long)b->begin) + blockSize; while (adr < end) { unsigned long key = adr >> log2; key = key & (hashSize - 1); if (hashList[key]) { QValueList<MemBlock *> *list = hashList[key]; QValueList<MemBlock *>::Iterator it = list->begin(); QValueList<MemBlock *>::Iterator endit = list->end(); for (; it != endit; ++it) if (*it == b) { list->remove(it); break; } } adr += blockSize; } }
void MyMoneyForecast::addScheduledTransactions (void) { MyMoneyFile* file = MyMoneyFile::instance(); // now process all the schedules that may have an impact QValueList<MyMoneySchedule> schedule; schedule = file->scheduleList("", MyMoneySchedule::TYPE_ANY, MyMoneySchedule::OCCUR_ANY, MyMoneySchedule::STYPE_ANY, QDate(), forecastEndDate()); if(schedule.count() > 0) { QValueList<MyMoneySchedule>::Iterator it; do { qBubbleSort(schedule); it = schedule.begin(); if(it == schedule.end()) break; if((*it).isFinished()) { schedule.erase(it); continue; } QDate date = (*it).nextPayment((*it).lastPayment()); if(!date.isValid()) { schedule.remove(it); continue; } QDate nextDate = (*it).adjustedNextPayment((*it).adjustedDate((*it).lastPayment(), (*it).weekendOption())); if (nextDate > forecastEndDate()) { // We're done with this schedule, let's move on to the next schedule.remove(it); continue; } // found the next schedule. process it MyMoneyAccount acc = (*it).account(); if(!acc.id().isEmpty()) { try { if(acc.accountType() != MyMoneyAccount::Investment) { MyMoneyTransaction t = (*it).transaction(); // only process the entry, if it is still active if(!(*it).isFinished() && nextDate != QDate()) { // make sure we have all 'starting balances' so that the autocalc works QValueList<MyMoneySplit>::const_iterator it_s; QMap<QString, MyMoneyMoney> balanceMap; for(it_s = t.splits().begin(); it_s != t.splits().end(); ++it_s ) { MyMoneyAccount acc = file->account((*it_s).accountId()); if(isForecastAccount(acc)) { // collect all overdues on the first day QDate forecastDate = nextDate; if(QDate::currentDate() >= nextDate) forecastDate = QDate::currentDate().addDays(1); dailyBalances balance; balance = m_accountList[acc.id()]; for(QDate f_day = QDate::currentDate(); f_day < forecastDate; ) { balanceMap[acc.id()] += m_accountList[acc.id()][f_day]; f_day = f_day.addDays(1); } } } // take care of the autoCalc stuff calculateAutoLoan(*it, t, balanceMap); // now add the splits to the balances for(it_s = t.splits().begin(); it_s != t.splits().end(); ++it_s ) { MyMoneyAccount acc = file->account((*it_s).accountId()); if(isForecastAccount(acc)) { dailyBalances balance; balance = m_accountList[acc.id()]; //int offset = QDate::currentDate().daysTo(nextDate); //if(offset <= 0) { // collect all overdues on the first day // offset = 1; //} // collect all overdues on the first day QDate forecastDate = nextDate; if(QDate::currentDate() >= nextDate) forecastDate = QDate::currentDate().addDays(1); if(acc.accountType() == MyMoneyAccount::Income) { balance[forecastDate] += ((*it_s).shares() * MyMoneyMoney(-1, 1)); } else { balance[forecastDate] += (*it_s).shares(); } m_accountList[acc.id()] = balance; } } } } (*it).setLastPayment(date); } catch(MyMoneyException* e) { kdDebug(2) << __func__ << " Schedule " << (*it).id() << " (" << (*it).name() << "): " << e->what() << endl; schedule.remove(it); delete e; } } else { // remove schedule from list schedule.remove(it); } } while(1); } #if 0 { s << "\n\nAdded scheduled transactions\n"; QMap<QString, dailyBalances>::Iterator it_a; QMap<QString, QString>::ConstIterator it_n; for(it_n = m_nameIdx.begin(); it_n != m_nameIdx.end(); ++it_n) { MyMoneyAccount acc = file->account(*it_n); it_a = m_accountList.find(*it_n); s << "\"" << acc.name() << "\","; for(int i = 0; i < 90; ++i) { s << "\"" << (*it_a)[i].formatMoney("") << "\","; } s << "\n"; } } #endif }
void KSDBHandler::syncTypes() { //A bool for knowing when to display the warning. bool remove = false; //We get the list of parts from KSData. KSlovar::KSInstance()->loadPartOfSpeech(KSData::instance()->getLanguage()); QValueList<KSElement> partsOfSpeech = KSData::instance()->getPartOfSpeechList(); //We also get the parts of speech list from the dictionary. QString rawQuery = "SELECT id_type, name FROM type;"; query(rawQuery); //We store the result into a local variable. You don't know when will the thread start messing with it! QValueList<KSResult> result = m_result; //We figure out if there is a part of speech removed from the languages.ldft. If so, we warn the user. bool find = false; rawQuery = "BEGIN TRANSACTION;"; for(QValueList<KSResult>::const_iterator count = result.begin(); count != result.end(); count++) { for(QValueList<KSElement>::iterator count2 = partsOfSpeech.begin(); count2 != partsOfSpeech.end(); count2++) { //The editing part of the query. if(((*count2).id == (*count)["id_type"])) { //If the name is not the same, but ID is, then the name of the part of speech has been changed. We commit this change to the dictionary. if((*count2).name == (*count)["name"]) { rawQuery += "UPDATE type SET name='"+(*count2).name+"' WHERE id_type='"+(*count)["id_type"]+"';"; } //Remove the type from the list, so we end up with the list of types that needs to be inserted. partsOfSpeech.remove(count2); find = true; break; } } //Add the removing part of the query. if(!find) { rawQuery += "DELETE FROM type WHERE id_type='"+(*count)["id_type"]+"';"; remove = true; } else { find = false; } } //The inserting part of the query. for(QValueList<KSElement>::const_iterator count = partsOfSpeech.begin(); count != partsOfSpeech.end(); count++) { rawQuery += "INSERT INTO type (id_type, name) VALUES ('"+QString::number((*count).id)+"', '"+(*count).name+"');"; } //The actual warning. if(remove) { if(KMessageBox::warningContinueCancel(KSlovar::KSInstance(), i18n("If you proceed with this update, some of the words will loose their part of speech. Are you sure you want to do this?"), i18n("Warning possible unexpected loss of data"), i18n("Remove")) == KMessageBox::Cancel) { return; } } //We finish the query and execute it. rawQuery += "COMMIT;"; query(rawQuery); //Reload the parts of speech. KSlovar::KSInstance()->loadPartOfSpeech(); KMessageBox::information(0, i18n("Synchronisation successful.")); }
/****************************************************************************** * Initialise a KCal::Recurrence to be the same as this instance. * Additional recurrence rules are created as necessary if it recurs on Feb 29th. */ void KARecurrence::writeRecurrence(KCal::Recurrence &recur) const { recur.clear(); recur.setStartDateTime(startDateTime()); recur.setExDates(exDates()); recur.setExDateTimes(exDateTimes()); const RecurrenceRule *rrule = defaultRRuleConst(); if(!rrule) return; int freq = frequency(); int count = duration(); static_cast<KARecurrence *>(&recur)->setNewRecurrenceType(rrule->recurrenceType(), freq); if(count) recur.setDuration(count); else recur.setEndDateTime(endDateTime()); switch(type()) { case DAILY: if(rrule->byDays().isEmpty()) break; // fall through to rWeekly case WEEKLY: case MONTHLY_POS: recur.defaultRRule(true)->setByDays(rrule->byDays()); break; case MONTHLY_DAY: recur.defaultRRule(true)->setByMonthDays(rrule->byMonthDays()); break; case ANNUAL_POS: recur.defaultRRule(true)->setByMonths(rrule->byMonths()); recur.defaultRRule()->setByDays(rrule->byDays()); break; case ANNUAL_DATE: { QValueList<int> months = rrule->byMonths(); QValueList<int> days = monthDays(); bool special = (mFeb29Type != FEB29_FEB29 && !days.isEmpty() && days.first() == 29 && months.remove(2)); RecurrenceRule *rrule1 = recur.defaultRRule(); rrule1->setByMonths(months); rrule1->setByMonthDays(days); if(!special) break; // It recurs on the 29th February. // Create an additional 60th day of the year, or last day of February, rule. RecurrenceRule *rrule2 = new RecurrenceRule(); rrule2->setRecurrenceType(RecurrenceRule::rYearly); rrule2->setFrequency(freq); rrule2->setStartDt(startDateTime()); rrule2->setFloats(doesFloat()); if(!count) rrule2->setEndDt(endDateTime()); if(mFeb29Type == FEB29_MAR1) { QValueList<int> ds; ds.append(60); rrule2->setByYearDays(ds); } else { QValueList<int> ds; ds.append(-1); rrule2->setByMonthDays(ds); QValueList<int> ms; ms.append(2); rrule2->setByMonths(ms); } if(months.isEmpty()) { // Only February recurs. // Replace the RRULE and keep the recurrence count the same. if(count) rrule2->setDuration(count); recur.unsetRecurs(); } else { // Months other than February also recur on the 29th. // Remove February from the list and add a separate RRULE for February. if(count) { rrule1->setDuration(-1); rrule2->setDuration(-1); if(count > 0) { /* Adjust counts in the two rules to keep the correct occurrence total. * Note that durationTo() always includes the start date. Since for an * individual RRULE the start date may not actually be included, we need * to decrement the count if the start date doesn't actually recur in * this RRULE. * Note that if the count is small, one of the rules may not recur at * all. In that case, retain it so that the February 29th characteristic * is not lost should the user later change the recurrence count. */ QDateTime end = endDateTime(); kdDebug() << "29th recurrence: count=" << count << ", end date=" << end.toString() << endl; int count1 = rrule1->durationTo(end) - (rrule1->recursOn(startDate()) ? 0 : 1); if(count1 > 0) rrule1->setDuration(count1); else rrule1->setEndDt(startDateTime()); int count2 = rrule2->durationTo(end) - (rrule2->recursOn(startDate()) ? 0 : 1); if(count2 > 0) rrule2->setDuration(count2); else rrule2->setEndDt(startDateTime()); } } } recur.addRRule(rrule2); break; } default: break; } }
/****************************************************************************** * Must be called after presetting with a KCal::Recurrence, to convert the * recurrence to KARecurrence types: * - Convert hourly recurrences to minutely. * - Remove all but the first day in yearly date recurrences. * - Check for yearly recurrences falling on February 29th and adjust them as * necessary. A 29th of the month rule can be combined with either a 60th day * of the year rule or a last day of February rule. */ void KARecurrence::fix() { mCachedType = -1; mFeb29Type = FEB29_FEB29; int convert = 0; int days[2] = { 0, 0 }; RecurrenceRule *rrules[2]; RecurrenceRule::List rrulelist = rRules(); RecurrenceRule::List::ConstIterator rr = rrulelist.begin(); for(int i = 0; i < 2 && rr != rrulelist.end(); ++i, ++rr) { RecurrenceRule *rrule = *rr; rrules[i] = rrule; bool stop = true; int rtype = recurrenceType(rrule); switch(rtype) { case rHourly: // Convert an hourly recurrence to a minutely one rrule->setRecurrenceType(RecurrenceRule::rMinutely); rrule->setFrequency(rrule->frequency() * 60); // fall through to rMinutely case rMinutely: case rDaily: case rWeekly: case rMonthlyDay: case rMonthlyPos: case rYearlyPos: if(!convert) ++rr; // remove all rules except the first break; case rOther: if(dailyType(rrule)) { // it's a daily rule with BYDAYS if(!convert) ++rr; // remove all rules except the first } break; case rYearlyDay: { // Ensure that the yearly day number is 60 (i.e. Feb 29th/Mar 1st) if(convert) { // This is the second rule. // Ensure that it can be combined with the first one. if(days[0] != 29 || rrule->frequency() != rrules[0]->frequency() || rrule->startDt() != rrules[0]->startDt()) break; } QValueList<int> ds = rrule->byYearDays(); if(!ds.isEmpty() && ds.first() == 60) { ++convert; // this rule needs to be converted days[i] = 60; stop = false; break; } break; // not day 60, so remove this rule } case rYearlyMonth: { QValueList<int> ds = rrule->byMonthDays(); if(!ds.isEmpty()) { int day = ds.first(); if(convert) { // This is the second rule. // Ensure that it can be combined with the first one. if(day == days[0] || day == -1 && days[0] == 60 || rrule->frequency() != rrules[0]->frequency() || rrule->startDt() != rrules[0]->startDt()) break; } if(ds.count() > 1) { ds.clear(); // remove all but the first day ds.append(day); rrule->setByMonthDays(ds); } if(day == -1) { // Last day of the month - only combine if it's February QValueList<int> months = rrule->byMonths(); if(months.count() != 1 || months.first() != 2) day = 0; } if(day == 29 || day == -1) { ++convert; // this rule may need to be converted days[i] = day; stop = false; break; } } if(!convert) ++rr; break; } default: break; } if(stop) break; } // Remove surplus rules for(; rr != rrulelist.end(); ++rr) { removeRRule(*rr); delete *rr; } QDate end; int count; QValueList<int> months; if(convert == 2) { // There are two yearly recurrence rules to combine into a February 29th recurrence. // Combine the two recurrence rules into a single rYearlyMonth rule falling on Feb 29th. // Find the duration of the two RRULEs combined, using the shorter of the two if they differ. if(days[0] != 29) { // Swap the two rules so that the 29th rule is the first RecurrenceRule *rr = rrules[0]; rrules[0] = rrules[1]; // the 29th rule rrules[1] = rr; int d = days[0]; days[0] = days[1]; days[1] = d; // the non-29th day } // If February is included in the 29th rule, remove it to avoid duplication months = rrules[0]->byMonths(); if(months.remove(2)) rrules[0]->setByMonths(months); count = combineDurations(rrules[0], rrules[1], end); mFeb29Type = (days[1] == 60) ? FEB29_MAR1 : FEB29_FEB28; } else if(convert == 1 && days[0] == 60) { // There is a single 60th day of the year rule. // Convert it to a February 29th recurrence. count = duration(); if(!count) end = endDate(); mFeb29Type = FEB29_MAR1; } else return; // Create the new February 29th recurrence setNewRecurrenceType(RecurrenceRule::rYearly, frequency()); RecurrenceRule *rrule = defaultRRule(); months.append(2); rrule->setByMonths(months); QValueList<int> ds; ds.append(29); rrule->setByMonthDays(ds); if(count) setDuration(count); else setEndDate(end); }
QValueList<int> KPrinter::pageList() const { QValueList<int> list; int mp(minPage()), MP(maxPage()); if (mp > 0 && MP > 0 && MP >= mp) { // do something only if bounds specified if (option("kde-current") == "1") { // print only current page int pp = currentPage(); if (pp >= mp && pp <= MP) list.append(pp); } else { // process range specification if (!option("kde-range").isEmpty()) { QStringList ranges = QStringList::split(',',option("kde-range"),false); for (QStringList::ConstIterator it=ranges.begin();it!=ranges.end();++it) { int p = (*it).find('-'); bool ok; if (p == -1) { int pp = (*it).toInt(&ok); if (ok && pp >= mp && pp <= MP) list.append(pp); } else { int p1(0), p2(0); p1 = (*it).left(p).toInt(&ok); if (ok) p2 = (*it).right((*it).length()-p-1).toInt(&ok); if (ok && p1 <= p2) { // clip to min/max p1 = QMAX(mp,p1); p2 = QMIN(MP,p2); for (int i=p1;i<=p2;i++) list.append(i); } } } } else { // add all pages between min and max for (int i=mp;i<=MP;i++) list.append(i); } // revert the list if needed if (pageOrder() == LastPageFirst) { for (uint i=0;i<(list.count()/2);i++) qSwap(list[i],list[list.count()-1-i]); } // select page set if needed if (pageSet() != AllPages) { bool keepEven = (pageSet() == EvenPages); for (QValueList<int>::Iterator it=list.begin();it!=list.end();) if ((((*it) % 2) != 0 && keepEven) || (((*it) % 2) == 0 && !keepEven)) it = list.remove(it); else ++it; } } } return list; }
void EditFunctions::okClicked() { QValueList<MetaDataBase::Function> functionList = MetaDataBase::functionList( formWindow ); QString n = tr( "Add/Remove functions of '%1'" ).arg( formWindow->name() ); QPtrList<Command> commands; QValueList<MetaDataBase::Function>::Iterator fit; if ( !functionList.isEmpty() ) { for ( fit = functionList.begin(); fit != functionList.end(); ++fit ) { bool functionFound = FALSE; QValueList<FunctItem>::Iterator it = functList.begin(); for ( ; it != functList.end(); ++it ) { if ( MetaDataBase::normalizeFunction( (*it).oldName ) == MetaDataBase::normalizeFunction( (*fit).function ) ) { functionFound = TRUE; break; } } if ( !functionFound ) commands.append( new RemoveFunctionCommand( tr( "Remove function" ), formWindow, (*fit).function, (*fit).specifier, (*fit).access, (*fit).type, formWindow->project()->language(), (*fit).returnType ) ); } } bool invalidFunctions = FALSE; QValueList<FunctItem> invalidItems; if ( !functList.isEmpty() ) { QStrList lst; QValueList<FunctItem>::Iterator it = functList.begin(); for ( ; it != functList.end(); ++it ) { MetaDataBase::Function function; function.function = (*it).newName; function.returnType = (*it).retTyp; function.specifier = (*it).spec; function.access = (*it).access; function.type = (*it).type; function.language = formWindow->project()->language(); if ( function.returnType.isEmpty() ) function.returnType = "void"; QString s = function.function; s = s.simplifyWhiteSpace(); bool startNum = s[ 0 ] >= '0' && s[ 0 ] <= '9'; bool noParens = s.contains( '(' ) != 1 || s.contains( ')' ) != 1; bool illegalSpace = s.find( ' ' ) != -1 && s.find( ' ' ) < s.find( '(' ); if ( startNum || noParens || illegalSpace || lst.find( function.function ) != -1 ) { invalidFunctions = TRUE; invalidItems.append( (*it) ); continue; } bool functionFound = FALSE; for ( fit = functionList.begin(); fit != functionList.end(); ++fit ) { if ( MetaDataBase::normalizeFunction( (*fit).function ) == MetaDataBase::normalizeFunction( (*it).oldName ) ) { functionFound = TRUE; break; } } if ( !functionFound ) commands.append( new AddFunctionCommand( tr( "Add function" ), formWindow, function.function, function.specifier, function.access, function.type, formWindow->project()->language(), function.returnType ) ); if ( MetaDataBase::normalizeFunction( (*it).newName ) != MetaDataBase::normalizeFunction( (*it).oldName ) || (*it).spec != (*it).oldSpec || (*it).access != (*it).oldAccess || (*it).type != (*it).oldType || (*it).retTyp != (*it).oldRetTyp ) { QString normalizedOldName = MetaDataBase::normalizeFunction( (*it).oldName ); if ((*it).oldName.endsWith("const")) // make sure we get the 'const' when we remove the old name normalizedOldName += " const"; commands.append( new ChangeFunctionAttribCommand( tr( "Change function attributes" ), formWindow, function, normalizedOldName, (*it).oldSpec, (*it).oldAccess, (*it).oldType, formWindow->project()->language(), (*it).oldRetTyp ) ); } lst.append( function.function ); } } if ( invalidFunctions ) { if ( QMessageBox::information( this, tr( "Edit Functions" ), tr( "Some syntactically incorrect functions have been defined.\n" "Remove these functions?" ), tr( "&Yes" ), tr( "&No" ) ) == 0 ) { QValueList<FunctItem>::Iterator it = functList.begin(); while ( it != functList.end() ) { bool found = FALSE; QValueList<FunctItem>::Iterator vit = invalidItems.begin(); for ( ; vit != invalidItems.end(); ++vit ) { if ( (*vit).newName == (*it).newName ) { invalidItems.remove( vit ); found = TRUE; break; } } if ( found ) { int delId = (*it).id; it = functList.remove( it ); QMap<QListViewItem*, int>::Iterator fit = functionIds.begin(); while ( fit != functionIds.end() ) { if ( *fit == delId ) { QListViewItem *litem = fit.key(); functionIds.remove( fit ); delete litem; if ( functionListView->currentItem() ) functionListView->setSelected( functionListView->currentItem(), TRUE ); currentItemChanged( functionListView->currentItem() ); break; } ++fit; } } else ++it; } if ( functionListView->firstChild() ) { functionListView->setCurrentItem( functionListView->firstChild() ); functionListView->setSelected( functionListView->firstChild(), TRUE ); } } formWindow->mainWindow()->objectHierarchy()->updateFormDefinitionView(); return; } if ( !commands.isEmpty() ) { MacroCommand *cmd = new MacroCommand( n, formWindow, commands ); formWindow->commandHistory()->addCommand( cmd ); cmd->execute(); } formWindow->mainWindow()->objectHierarchy()->updateFormDefinitionView(); accept(); }