//
// Report a requested property
//
TInt CDbTableDatabase::CInterface::Property(CDbDatabase::TProperty aProperty)
{
if (aProperty==EInTransaction)
return Database().Transaction().InTransaction(*this) ? 1 : 0;
//
return Database().Property(aProperty);
}
CDbIncremental* CDbTableDatabase::CInterface::OpenExecuteL(const TDesC& aSql,TDbTextComparison aComparison,TInt& aInit)
{
switch (Sql::Type(aSql))
{
default:
__ASSERT(0);
case Sql::ENone:
__LEAVE(KErrArgument);
case Sql::EDDL:
{
CDbIncremental* inc=Sql::ParseDDLStatementLC(aSql)->ExecuteL(*this,aComparison,aInit);
CleanupStack::PopAndDestroy(); // statement
return inc;
}
case Sql::EDML:
{
CSqlDMLStatement* statement=Sql::ParseDMLStatementLC(aSql);
RDbTransaction& t=Database().Transaction();
t.DMLCheckL(); // ensure we can open a cursor
t.DMLPrepareL(*this);
CDbIncremental* inc=statement->ExecuteL(Database(),aComparison,aInit);
CleanupStack::PopAndDestroy(); // statement
return inc;
}
}
}
//
// Create a database utility. Check the corresponding property to see if it is viable
//
CDbIncremental* CDbTableDatabase::CInterface::OpenUtilityL(CDbDatabase::TUtility aType,TInt& aStep)
{
if (!Property(TProperty(-aType)))
{ // nothing to do, or not capable
aStep=0;
return 0;
}
RDbTransaction& t=Database().Transaction();
t.UtilityPrepareL(*this);
if (aType==ERecover)
Database().Release(); // must not have any tables open during recovery
return CUtility::NewL(t,aType,aStep);
}
int main()
{
int n;
Database();
while(scanf("%d",&n) && n) printf("%d\n",data[n]);
return 0;
}
Benchmarker::Benchmarker(const QString &benchmarkName)
{
const ticks t0 = getticks();
const ticks t1 = getticks();
m_overhead = elapsed(t1, t0);
qDebug() << "overhead" << m_overhead;
m_overhead = elapsed(t1, t0);
qDebug() << "overhead" << m_overhead;
m_overhead = elapsed(t1, t0);
qDebug() << "overhead" << m_overhead;
// are we running in a QTestLib test function?
if (qstrlen(QTest::currentTestFunction()) != 0) {
m_testlibIntegration = new BenchmarkerTestlibIntegration();
m_database = m_testlibIntegration->database();
} else {
m_testlibIntegration = 0;
QString databasePath = QDir::cleanPath(QDir::currentPath() + "/" +
benchmarkName.toLower() + ".sqlite");
// Mutliple test runs are currently not supported. Delete the database.
Database(databasePath).deleteDatabase();
m_database = new Database(databasePath);
}
m_resultsTable = new BenchmarkTable(m_database, benchmarkName.toLower());
m_resultsTable->setAttribute("Name", benchmarkName);
m_database->transaction();
}
void KCApplyFilterCommand::redo()
{
m_undoData.clear();
Database database = m_database;
KCSheet* const sheet = database.range().lastSheet();
const QRect range = database.range().lastRange();
const int start = database.orientation() == Qt::Vertical ? range.top() : range.left();
const int end = database.orientation() == Qt::Vertical ? range.bottom() : range.right();
for (int i = start + 1; i <= end; ++i) {
const bool isFiltered = !database.filter().evaluate(database, i);
// kDebug() <<"Filtering column/row" << i <<"?" << isFiltered;
if (database.orientation() == Qt::Vertical) {
m_undoData[i] = sheet->rowFormat(i)->isFiltered();
sheet->nonDefaultRowFormat(i)->setFiltered(isFiltered);
} else { // database.orientation() == Qt::Horizontal
m_undoData[i] = sheet->columnFormat(i)->isFiltered();
sheet->nonDefaultColumnFormat(i)->setFiltered(isFiltered);
}
}
if (database.orientation() == Qt::Vertical)
sheet->map()->addDamage(new KCSheetDamage(sheet, KCSheetDamage::RowsChanged));
else // database.orientation() == Qt::Horizontal
sheet->map()->addDamage(new KCSheetDamage(sheet, KCSheetDamage::ColumnsChanged));
m_sheet->cellStorage()->setDatabase(*this, Database());
m_sheet->cellStorage()->setDatabase(*this, database);
m_sheet->map()->addDamage(new KCCellDamage(m_sheet, *this, KCCellDamage::Appearance));
}
// Initialize a CFontDescription object with the attributes that
// make a font unique.
BOOL CTextStyle::GetFontDescription(CFontDescription* pFontDescription)
{
BOOL fResult = FALSE;
// Get the typeface number.
int nTypeface = ((PMGFontServer*)(Database()->get_font_server()))->font_record_to_face(Font());
if (nTypeface != -1)
{
// Compute the style (bold, italic) of the typeface.
int nFontStyle = 0;
if (Bold())
{
nFontStyle |= FONT_STYLE_Bold;
}
if (Italic())
{
nFontStyle |= FONT_STYLE_Italic;
}
// Initialize the font description.
pFontDescription->m_nTypeface = typeface_for_fstyle(nTypeface, (FONT_STYLE)nFontStyle);
pFontDescription->m_lPointSize = Size();
pFontDescription->m_lHorizontalExpansion = Expansion();
pFontDescription->m_Fill = Fill();
pFontDescription->m_Outline = Outline();
pFontDescription->m_Shadow = Shadow();
fResult = TRUE;
}
return fResult;
}
mapbox::util::variant<Database, Exception> Database::tryOpen(const std::string &filename, int flags) {
if (!QSqlDatabase::drivers().contains("QSQLITE")) {
return Exception { ResultCode::CantOpen, "SQLite driver not found." };
}
QString connectionName = QString::number(uint64_t(QThread::currentThread())) + incrementCounter();
assert(!QSqlDatabase::contains(connectionName));
auto db = QSqlDatabase::addDatabase("QSQLITE", connectionName);
QString connectOptions = db.connectOptions();
if (flags & OpenFlag::ReadOnly) {
if (!connectOptions.isEmpty()) connectOptions.append(';');
connectOptions.append("QSQLITE_OPEN_READONLY");
}
if (flags & OpenFlag::SharedCache) {
if (!connectOptions.isEmpty()) connectOptions.append(';');
connectOptions.append("QSQLITE_ENABLE_SHARED_CACHE");
}
db.setConnectOptions(connectOptions);
db.setDatabaseName(QString(filename.c_str()));
if (!db.open()) {
// Assume every error when opening the data as CANTOPEN. Qt
// always returns -1 for `nativeErrorCode()` on database errors.
return Exception { ResultCode::CantOpen, "Error opening the database." };
}
return Database(std::make_unique<DatabaseImpl>(connectionName));
}
TEST(ParseFixedCompilationDatabase, ReturnsNullOnEmptyArgumentList) {
int Argc = 0;
OwningPtr<FixedCompilationDatabase> Database(
FixedCompilationDatabase::loadFromCommandLine(Argc, NULL));
EXPECT_FALSE(Database);
EXPECT_EQ(0, Argc);
}
ActiveSyncSource::Databases ActiveSyncSource::getDatabases()
{
Databases result;
// empty string always selects the default database
result.push_back(Database("", "", true));
return result;
}
TEST(FixedCompilationDatabase, GetAllCompileCommands) {
std::vector<std::string> CommandLine;
CommandLine.push_back("one");
CommandLine.push_back("two");
FixedCompilationDatabase Database(".", CommandLine);
EXPECT_EQ(0ul, Database.getAllCompileCommands().size());
}
TEST(ParseFixedCompilationDatabase, ReturnsNullWithoutDoubleDash) {
int Argc = 2;
const char *Argv[] = { "1", "2" };
OwningPtr<FixedCompilationDatabase> Database(
FixedCompilationDatabase::loadFromCommandLine(Argc, Argv));
EXPECT_FALSE(Database);
EXPECT_EQ(2, Argc);
}
void CDbTableDatabase::CAlterTable::ConstructL(const CDbColSet& aNewDef,TInt& aStep)
//
// get all the deleted columns
// check changes to columns still present
// get all the new columns
// construct a new columns set based on the changes
//
{
//
// flag all columns as dropped initially
HDbColumnSet& columns=iDef.Columns();
HDbColumnSet::TIterator iter=columns.Begin();
HDbColumnSet::TIteratorC const end=columns.End();
do
{
iter->iFlags=TDbColumnDef::EDropped;
} while (++iter<end);
//
// look for additions and changes
CDbColSet* change=CDbColSet::NewLC();
CDbColSet* add=CDbColSet::NewLC();
for (TDbColSetIter iterNew(aNewDef);iterNew;++iterNew)
{
const TDbCol& col=*iterNew;
TDbColumnDef* def=columns.ColumnL(iterNew->iName);
if (!def) // a new column
add->AddL(col);
else
{ // see if the definition has changed
if (def->iAttributes!=col.iAttributes)
__LEAVE(KErrArgument); // can't change attributes
TUint8 flag=0;
if (def->iType!=col.iType)
flag=TDbColumnDef::EChangedType;
else if (def->iType>=EDbColText8 && col.iMaxLength!=KDbUndefinedLength && col.iMaxLength!=def->iMaxLength)
flag=TDbColumnDef::EChangedLen;
def->iFlags=flag;
if (flag)
change->AddL(col); // column has changed
}
}
//
// check that all marked columns are not indexed
//
iter=columns.Begin();
do
{
if (iter->iFlags && iDef.IsIndexed(*iter->iName))
__LEAVE(KErrArgument); // can't remove indexed column
} while (++iter<end);
//
iNewSet=HDbColumnSet::NewL(aNewDef.Count());
iDef.AlteredColumnSetL(*iNewSet,*change,*add);
CleanupStack::PopAndDestroy(2); // add, change
Construct(Database().TableAlterL(iDef,*iNewSet,aStep));
}
CTextStyle::CTextStyle(PMGDatabase* pDatabase /*=NULL*/, BOOL fTemporary /*=TRUE*/)
{
Database(pDatabase);
m_fTemporary = fTemporary;
memset(&m_Paragraph, 0, sizeof(m_Paragraph));
memset(&m_Character, 0, sizeof(m_Character));
memset(&m_Metrics, 0, sizeof(m_Metrics));
memset(&m_Frame, 0, sizeof(m_Frame));
}
static std::vector<CompileCommand> getAllCompileCommands(StringRef JSONDatabase,
std::string &ErrorMessage) {
OwningPtr<CompilationDatabase> Database(
JSONCompilationDatabase::loadFromBuffer(JSONDatabase, ErrorMessage));
if (!Database) {
ADD_FAILURE() << ErrorMessage;
return std::vector<CompileCommand>();
}
return Database->getAllCompileCommands();
}
virtual CompilationDatabase *loadFromDirectory(
StringRef Directory, std::string &ErrorMessage) {
llvm::SmallString<1024> JSONDatabasePath(Directory);
llvm::sys::path::append(JSONDatabasePath, "compile_commands.json");
llvm::OwningPtr<CompilationDatabase> Database(
JSONCompilationDatabase::loadFromFile(JSONDatabasePath, ErrorMessage));
if (!Database)
return NULL;
return Database.take();
}
CNSmlDSProfile* CNSmlDSSettings::ProfileOnlyL( TInt aId )
{
HBufC* sqlStatement = HBufC::NewLC( KDSSQLGetProfile().Length() + KNSmlDsSettingsMaxIntegerLength);
TPtr sqlStatementPtr = sqlStatement->Des();
sqlStatementPtr.Format( KDSSQLGetProfile, aId );
PrepareViewL( sqlStatementPtr, iView.EReadOnly );
CleanupStack::PopAndDestroy(); // sqlStatement
CNSmlDSProfile* profile = CNSmlDSProfile::NewLC( Database() );
if( iView.FirstL() )
{
CNSmlDSCrypt* crypt = new(ELeave) CNSmlDSCrypt;
CleanupStack::PushL(crypt);
iView.GetL();
profile->SetIntValue( EDSProfileId, ViewColUint( KNSmlDSProfileId ) );
profile->SetStrValue( EDSProfileDisplayName, ViewColDes( KNSmlDSProfileDisplayName ) );
profile->SetIntValue( EDSProfileIAPId, ViewColInt( KNSmlDSProfileIAPId ) );
profile->SetIntValue( EDSProfileTransportId, ViewColInt( KNSmlDSProfileTransportId ) );
profile->SetStrValue( EDSProfileServerURL, ViewColDes( KNSmlDSProfileServerURL ) );
profile->SetStrValue( EDSProfileServerId, ViewColDes( KNSmlDSProfileServerId ) );
profile->SetStrValue( EDSProfileSyncServerUsername, ViewColDes( KNSmlDSProfileSyncServerUsername ) );
profile->SetStrValue( EDSProfileSyncServerPassword, crypt->DecryptedL(ViewColDes( KNSmlDSProfileSyncServerPassword ) ) );
profile->SetIntValue( EDSProfileServerAlertedAction, ViewColInt( KNSmlDSProfileServerAlertedAction ) );
profile->SetIntValue( EDSProfileDeleteAllowed, ViewColInt( KNSmlDSProfileDeleteAllowed ) );
profile->SetIntValue( EDSProfileHidden, ViewColInt( KNSmlDSProfileHidden ) );
profile->SetIntValue( EDSProfileHttpAuthUsed, ViewColInt( KNSmlDSProfileHttpAuthUsed ) );
profile->SetStrValue( EDSProfileHttpAuthUsername, ViewColDes( KNSmlDSProfileHttpAuthUsername ) );
profile->SetStrValue( EDSProfileHttpAuthPassword, crypt->DecryptedL(ViewColDes( KNSmlDSProfileHttpAuthPassword ) ) );
profile->SetIntValue( EDSProfileAutoChangeIAP, ViewColInt( KNSmlDSProfileAutoChangeIAP ) );
profile->SetIntValue( EDSProfileCreatorId, ViewColInt( KNSmlDSProfileCreatorID ) );
profile->InitVisibilityArray( ViewColDes( KNSmlDSProfileVisibilityStr ) );
profile->SetIntValue( EDSProfileProtocolVersion, ViewColInt( KNSmlDSProfileProtocolVersion ) );
CleanupStack::PopAndDestroy(); // crypt
CleanupStack::Pop(); // profile
}
else
{
CleanupStack::PopAndDestroy(profile);
//couldn't find
profile = NULL;
}
return profile;
}
JSONCompilationDatabase *
JSONCompilationDatabase::loadFromBuffer(StringRef DatabaseString,
std::string &ErrorMessage) {
llvm::OwningPtr<llvm::MemoryBuffer> DatabaseBuffer(
llvm::MemoryBuffer::getMemBuffer(DatabaseString));
llvm::OwningPtr<JSONCompilationDatabase> Database(
new JSONCompilationDatabase(DatabaseBuffer.take()));
if (!Database->parse(ErrorMessage))
return NULL;
return Database.take();
}
//
// build a column set for the table
//
void CDbTableDatabase::CInterface::ColumnsL(CDbColSet& aColSet,const TDesC& aName)
{
TDbCol col;
const HDbColumnSet& set=Database().SchemaL().FindL(aName).Columns();
HDbColumnSet::TIteratorC iter=set.Begin();
const HDbColumnSet::TIteratorC end=set.End();
do
{
iter->AsTDbCol(col);
aColSet.AddL(col);
} while (++iter<end);
}
//
// build a key for the index
//
void CDbTableDatabase::CInterface::KeysL(CDbKey& aKey,const TDesC& aName,const TDesC& aTable)
{
const CDbKey& key=Database().SchemaL().FindL(aTable).Indexes().FindL(aName).Key();
TInt max=key.Count();
for (TInt ii=0;ii<max;++ii)
aKey.AddL(key[ii]);
if (key.IsUnique())
aKey.MakeUnique();
if (key.IsPrimary())
aKey.MakePrimary();
aKey.SetComparison(key.Comparison());
}
static CompileCommand findCompileArgsInJsonDatabase(StringRef FileName,
StringRef JSONDatabase,
std::string &ErrorMessage) {
llvm::OwningPtr<CompilationDatabase> Database(
JSONCompilationDatabase::loadFromBuffer(JSONDatabase, ErrorMessage));
if (!Database)
return CompileCommand();
std::vector<CompileCommand> Commands = Database->getCompileCommands(FileName);
EXPECT_LE(Commands.size(), 1u);
if (Commands.empty())
return CompileCommand();
return Commands[0];
}
nsresult
IDBTransaction::GetOrCreateConnection(mozIStorageConnection** aResult)
{
NS_ASSERTION(IndexedDatabaseManager::IsMainProcess(), "Wrong process!");
NS_ASSERTION(!NS_IsMainThread(), "Wrong thread!");
if (mDatabase->IsInvalidated()) {
return NS_ERROR_NOT_AVAILABLE;
}
if (!mConnection) {
nsCOMPtr<mozIStorageConnection> connection =
IDBFactory::GetConnection(mDatabase->FilePath());
NS_ENSURE_TRUE(connection, NS_ERROR_FAILURE);
nsresult rv;
nsRefPtr<UpdateRefcountFunction> function;
nsCString beginTransaction;
if (mMode != IDBTransaction::READ_ONLY) {
function = new UpdateRefcountFunction(Database()->Manager());
NS_ENSURE_TRUE(function, NS_ERROR_OUT_OF_MEMORY);
rv = function->Init();
NS_ENSURE_SUCCESS(rv, rv);
rv = connection->CreateFunction(
NS_LITERAL_CSTRING("update_refcount"), 2, function);
NS_ENSURE_SUCCESS(rv, rv);
beginTransaction.AssignLiteral("BEGIN IMMEDIATE TRANSACTION;");
}
else {
beginTransaction.AssignLiteral("BEGIN TRANSACTION;");
}
nsCOMPtr<mozIStorageStatement> stmt;
rv = connection->CreateStatement(beginTransaction, getter_AddRefs(stmt));
NS_ENSURE_SUCCESS(rv, rv);
rv = stmt->Execute();
NS_ENSURE_SUCCESS(rv, rv);
function.swap(mUpdateFileRefcountFunction);
connection.swap(mConnection);
}
nsCOMPtr<mozIStorageConnection> result(mConnection);
result.forget(aResult);
return NS_OK;
}
TEST(FixedCompilationDatabase, ReturnsFixedCommandLine) {
std::vector<std::string> CommandLine;
CommandLine.push_back("one");
CommandLine.push_back("two");
FixedCompilationDatabase Database(".", CommandLine);
std::vector<CompileCommand> Result =
Database.getCompileCommands("source");
ASSERT_EQ(1ul, Result.size());
std::vector<std::string> ExpectedCommandLine(1, "clang-tool");
ExpectedCommandLine.insert(ExpectedCommandLine.end(),
CommandLine.begin(), CommandLine.end());
ExpectedCommandLine.push_back("source");
EXPECT_EQ(".", Result[0].Directory);
EXPECT_EQ(ExpectedCommandLine, Result[0].CommandLine);
}
TEST(ParseFixedCompilationDatabase, ReturnsEmptyCommandLine) {
int Argc = 3;
const char *Argv[] = { "1", "2", "--\0no-constant-folding" };
OwningPtr<FixedCompilationDatabase> Database(
FixedCompilationDatabase::loadFromCommandLine(Argc, Argv));
ASSERT_TRUE(Database.isValid());
std::vector<CompileCommand> Result =
Database->getCompileCommands("source");
ASSERT_EQ(1ul, Result.size());
ASSERT_EQ(".", Result[0].Directory);
std::vector<std::string> CommandLine;
CommandLine.push_back("clang-tool");
CommandLine.push_back("source");
ASSERT_EQ(CommandLine, Result[0].CommandLine);
EXPECT_EQ(2, Argc);
}
TEST(ParseFixedCompilationDatabase, HandlesArgv0) {
const char *Argv[] = {"1", "2", "--", "mytool", "somefile.cpp"};
int Argc = sizeof(Argv) / sizeof(char*);
OwningPtr<FixedCompilationDatabase> Database(
FixedCompilationDatabase::loadFromCommandLine(Argc, Argv));
ASSERT_TRUE(Database.isValid());
std::vector<CompileCommand> Result =
Database->getCompileCommands("source");
ASSERT_EQ(1ul, Result.size());
ASSERT_EQ(".", Result[0].Directory);
std::vector<std::string> Expected;
Expected.push_back("clang-tool");
Expected.push_back("source");
ASSERT_EQ(Expected, Result[0].CommandLine);
EXPECT_EQ(2, Argc);
}
JSONCompilationDatabase *
JSONCompilationDatabase::loadFromFile(StringRef FilePath,
std::string &ErrorMessage) {
llvm::OwningPtr<llvm::MemoryBuffer> DatabaseBuffer;
llvm::error_code Result =
llvm::MemoryBuffer::getFile(FilePath, DatabaseBuffer);
if (Result != 0) {
ErrorMessage = "Error while opening JSON database: " + Result.message();
return NULL;
}
llvm::OwningPtr<JSONCompilationDatabase> Database(
new JSONCompilationDatabase(DatabaseBuffer.take()));
if (!Database->parse(ErrorMessage))
return NULL;
return Database.take();
}
int main(int argc, char *argv[])
{
QCoreApplication a(argc, argv);
if (a.arguments().count() < 2) {
qDebug() << "Usage: qtstats path-to-qt";
return 0;
}
const QString qtPath = a.arguments().at(1);
qDebug() << "Looking at Qt at" << qtPath;
bool loadData = true;
if (loadData) {
Database("qtstats.sqlite").deleteDatabase();
}
Database database("qtstats.sqlite");
AttributedTable commitsTable(&database, "Commits");
commitsTable.setTableScema(QStringList() << "Branch" << "Sha1" << "CommitTime" << "PatchSize",
QStringList() << "VARCHAR" << "VARCHAR" << "INTEGER" << "INTEGER");
commitsTable.setColumnRoleAttributes(commitsTable.columnNames(),
QStringList() << "Index" << "Data" << "TimeIndex" << "Data");
if (loadData) {
loadData(&database, qtPath);
}
database.execQuery("CREATE INDEX CommitsIndex ON Commits (CommitTime)", true);
deleteDuplicates(&database, commitsTable);
TimeGroupCounter counter(&database);
counter.skipColumn("Sha1");
AttributedTable aggregatedCommits = counter.aggregate(commitsTable);
trimZeroValues(&database, aggregatedCommits);
aggregatedCommits.setAttribute("Title", "Weekly Commit Rate For " + QDir(qtPath).dirName());
aggregatedCommits.setAttribute("CountTitle", "Commit Count");
aggregatedCommits.setAttribute("TimeTitle", "Time");
aggregatedCommits.setAttribute("timeChart", "true");
// Generate report
ReportGenerator(&database, aggregatedCommits.tableName()).generateReport(QDir::currentPath());
}
bool cManager::saveMapToFile(char* name) {
ifstream Database(name); //open a file
map <string, cFile> mymap;
map <string, cFile> myhash=this->hashFiles;
string line;
if(Database){ // write file in our map
while(getline(Database,line)){
string filename=line;
getline(Database,line);
int lvl= atoi(line.c_str());
getline(Database,line);
string author=line;
getline(Database,line);
string desc=line;
cFile file1(filename, author, lvl, desc);
getline(Database,line);
mymap.insert(pair<string,cFile>(line,file1) );
}
}
Database.close();
for (map<string,cFile>::iterator it=myhash.begin(); it!=myhash.end(); ++it){ // check if we have in hashFiles
for (map<string,cFile>::iterator ite=mymap.begin(); ite!=mymap.end(); ++ite){
if(ite->first==it->first) {
if(ite->second.getName() == it->second.getName()) {
if(ite->second.getAuthor() ==it->second.getAuthor()) {
if(ite->second.getTrustLvlFile() ==it->second.getTrustLvlFile()) {
myhash.erase(it); // erase while it is
}
}
}
}
}
}
ofstream Database2(name, ios::app); // open database to write our hash
for (map<string,cFile>::iterator it=myhash.begin(); it!=myhash.end(); ++it){
Database2<<it->second.getName()<<endl;
Database2<<it->second.getTrustLvlFile()<<endl;
Database2<<it->second.getAuthor()<<endl;
Database2<<it->second.getDesc()<<endl;
Database2<<it->first<<endl;
}
return true;
}
BOOL
CTextStyle::GetHyperlinkData(HyperlinkData &Data)
{
DB_RECORD_NUMBER RecordNumber;
if ((RecordNumber = HyperlinkStyle()) != 0)
{
CHTMLTagLink Link;
PMGDatabase *pd;
if ((pd = Database()) != NULL)
{
HyperlinkRecord *pRec;
if ((pRec = (HyperlinkRecord*)pd->get_record(RecordNumber, NULL, RECORD_TYPE_Hyperlink)) != NULL)
{
pRec->GetData(&Data);
pRec->release();
return TRUE;
}
}
}
return FALSE;
}
void KCApplyFilterCommand::undo()
{
Database database = m_database;
database.setFilter(*m_oldFilter);
KCSheet* const sheet = database.range().lastSheet();
const QRect range = database.range().lastRange();
const int start = database.orientation() == Qt::Vertical ? range.top() : range.left();
const int end = database.orientation() == Qt::Vertical ? range.bottom() : range.right();
for (int i = start + 1; i <= end; ++i) {
if (database.orientation() == Qt::Vertical)
sheet->nonDefaultRowFormat(i)->setFiltered(m_undoData[i]);
else // database.orientation() == Qt::Horizontal
sheet->nonDefaultColumnFormat(i)->setFiltered(m_undoData[i]);
}
if (database.orientation() == Qt::Vertical)
sheet->map()->addDamage(new KCSheetDamage(sheet, KCSheetDamage::RowsChanged));
else // database.orientation() == Qt::Horizontal
sheet->map()->addDamage(new KCSheetDamage(sheet, KCSheetDamage::ColumnsChanged));
m_sheet->cellStorage()->setDatabase(*this, Database());
m_sheet->cellStorage()->setDatabase(*this, database);
m_sheet->map()->addDamage(new KCCellDamage(m_sheet, *this, KCCellDamage::Appearance));
}
