/** return a list of included images*/
QStringList GeoImageList::list(QString type)
{
if (type.isEmpty())
return list_;
QStringList list;
QStringList::ConstIterator it;
for (it = list_.begin(); it != list_.end(); ++it) {
GeoImage *im = geoImage(*it);
if (QString::compare(im->type(), type, Qt::CaseInsensitive) == 0)
list += (*it);
qDebug("GeoImageList::list(item=%s)", it->toLatin1().constData());
}
return list;
}
void UpdaterDialog::keyPressEvent(QKeyEvent *event)
{
if(event->key() == Qt::Key_F11)
{
QFile logFile(QString("%1/%2.log").arg(MUtils::temp_folder(), MUtils::rand_str()));
if(logFile.open(QIODevice::WriteOnly | QIODevice::Truncate))
{
logFile.write("\xEF\xBB\xBF");
for(QStringList::ConstIterator iter = m_logFile.constBegin(); iter != m_logFile.constEnd(); iter++)
{
logFile.write(iter->toUtf8());
logFile.write("\r\n");
}
logFile.close();
QDesktopServices::openUrl(QUrl::fromLocalFile(logFile.fileName()));
}
}
}
enum Kompare::Format PerforceParser::determineFormat()
{
qCDebug(LIBKOMPAREDIFF2) << "Determining the format of the Perforce Diff";
QRegExp unifiedRE( "^@@" );
QRegExp contextRE( "^\\*{15}" );
QRegExp normalRE ( "^\\d+(|,\\d+)[acd]\\d+(|,\\d+)" );
QRegExp rcsRE ( "^[acd]\\d+ \\d+" );
// Summary is not supported since it gives no useful parsable info
QStringList::ConstIterator it = m_diffLines.begin();
while( it != m_diffLines.end() )
{
if( it->indexOf( unifiedRE, 0 ) == 0 )
{
qCDebug(LIBKOMPAREDIFF2) << "Difflines are from a Unified diff...";
return Kompare::Unified;
}
else if( it->indexOf( contextRE, 0 ) == 0 )
{
qCDebug(LIBKOMPAREDIFF2) << "Difflines are from a Context diff...";
return Kompare::Context;
}
else if( it->indexOf( normalRE, 0 ) == 0 )
{
qCDebug(LIBKOMPAREDIFF2) << "Difflines are from a Normal diff...";
return Kompare::Normal;
}
else if( it->indexOf( rcsRE, 0 ) == 0 )
{
qCDebug(LIBKOMPAREDIFF2) << "Difflines are from a RCS diff...";
return Kompare::RCS;
}
++it;
}
qCDebug(LIBKOMPAREDIFF2) << "Difflines are from an unknown diff...";
return Kompare::UnknownFormat;
}
QtsDvdFile QtsDvdDirectory::searchPath(QStringList::ConstIterator begin, QStringList::ConstIterator end, Qt::CaseSensitivity cs) const
{
if (begin == end) {
// Empty path, no file.
return QtsDvdFile();
}
const QStringList::ConstIterator next(begin + 1);
if (next == end) {
// We are at the end of the path, search a file.
return searchFile(*begin, cs);
}
foreach (const QtsDvdDirectoryPtr& dir, _subDirectories) {
if (!dir.isNull() && begin->compare(dir->name(), cs) == 0) {
return dir->searchPath(next, end, cs);
}
}
// Not found
return QtsDvdFile(*(end - 1));
}
void MainWindow::selectPlugin( Kontact::Plugin *plugin )
{
if ( !plugin )
return;
if ( plugin->isRunningStandalone() ) {
statusBar()->message( i18n( "Application is running standalone. Foregrounding..." ), 1000 );
mSidePane->indicateForegrunding( plugin );
plugin->bringToForeground();
return;
}
KApplication::setOverrideCursor( QCursor( Qt::WaitCursor ) );
KParts::Part *part = plugin->part();
if ( !part ) {
KApplication::restoreOverrideCursor();
KMessageBox::error( this, i18n( "Cannot load part for %1." )
.arg( plugin->title() )
+ "\n" + lastErrorMessage() );
plugin->setDisabled( true );
mSidePane->updatePlugins();
return;
}
// store old focus widget
QWidget *focusWidget = kapp->focusWidget();
if ( mCurrentPlugin && focusWidget ) {
// save the focus widget only when it belongs to the activated part
QWidget *parent = focusWidget->parentWidget();
while ( parent ) {
if ( parent == mCurrentPlugin->part()->widget() )
mFocusWidgets.insert( mCurrentPlugin->identifier(), QGuardedPtr<QWidget>( focusWidget ) );
parent = parent->parentWidget();
}
}
if ( mSidePane )
mSidePane->selectPlugin( plugin );
plugin->select();
mPartManager->setActivePart( part );
QWidget *view = part->widget();
Q_ASSERT( view );
if ( view ) {
mPartsStack->raiseWidget( view );
view->show();
if ( mFocusWidgets.contains( plugin->identifier() ) ) {
focusWidget = mFocusWidgets[ plugin->identifier() ];
if ( focusWidget )
focusWidget->setFocus();
} else
view->setFocus();
mCurrentPlugin = plugin;
KAction *newAction = plugin->newActions()->first();
KAction *syncAction = plugin->syncActions()->first();
createGUI( plugin->part() );
KToolBar* navigatorToolBar = findToolBar( "navigatorToolBar" );
// Let the navigator toolbar be always the last one, if it's in the top dockwindow
if ( navigatorToolBar && !navigatorToolBar->isHidden() &&
navigatorToolBar->barPos() == KToolBar::Top ) {
topDock()->moveDockWindow( navigatorToolBar, -1 );
}
setCaption( i18n( "Plugin dependent window title" ,"%1 - Kontact" ).arg( plugin->title() ) );
if ( newAction ) {
mNewActions->setIcon( newAction->icon() );
mNewActions->setText( newAction->text() );
} else { // we'll use the action of the first plugin which offers one
PluginList::Iterator it;
for ( it = mPlugins.begin(); it != mPlugins.end(); ++it ) {
newAction = (*it)->newActions()->first();
if ( newAction ) {
mNewActions->setIcon( newAction->icon() );
mNewActions->setText( newAction->text() );
break;
}
}
}
if ( mSyncActionsEnabled ) {
if ( syncAction ) {
mSyncActions->setIcon( syncAction->icon() );
mSyncActions->setText( syncAction->text() );
} else { // we'll use the action of the first plugin which offers one
PluginList::Iterator it;
for ( it = mPlugins.begin(); it != mPlugins.end(); ++it ) {
syncAction = (*it)->syncActions()->first();
if ( syncAction ) {
mSyncActions->setIcon( syncAction->icon() );
mSyncActions->setText( syncAction->text() );
break;
}
}
}
}
}
QStringList invisibleActions = plugin->invisibleToolbarActions();
QStringList::ConstIterator it;
for ( it = invisibleActions.begin(); it != invisibleActions.end(); ++it ) {
KAction *action = part->actionCollection()->action( (*it).latin1() );
if ( action ) {
QPtrListIterator<KToolBar> it( toolBarIterator() );
for ( ; it.current() ; ++it ) {
action->unplug( it.current() );
}
}
}
KApplication::restoreOverrideCursor();
}
void CharStyle::runFeatures(const QStringList& featureList, const CharStyle* parent)
{
QStringList::ConstIterator it;
for (it = featureList.begin(); it != featureList.end(); ++it)
{
QString feature = it->trimmed();
if (feature == INHERIT)
{
if (parent)
runFeatures(parent->features(), dynamic_cast<const CharStyle*>(parent->parentStyle()));
}
else if (feature == BOLD)
{
// select bolder font
}
else if (feature == ITALIC)
{
// select italic font
}
else if (feature == UNDERLINE)
{
m_Effects |= ScStyle_Underline;
}
else if (feature == UNDERLINEWORDS)
{
m_Effects |= ScStyle_UnderlineWords;
}
else if (feature == STRIKETHROUGH)
{
m_Effects |= ScStyle_Strikethrough;
}
else if (feature == SUPERSCRIPT)
{
m_Effects |= ScStyle_Superscript;
}
else if (feature == SUBSCRIPT)
{
m_Effects |= ScStyle_Subscript;
}
else if (feature == OUTLINE)
{
m_Effects |= ScStyle_Outline;
}
else if (feature == SHADOWED)
{
m_Effects |= ScStyle_Shadowed;
}
else if (feature == ALLCAPS)
{
m_Effects |= ScStyle_AllCaps;
}
else if (feature == SMALLCAPS)
{
m_Effects |= ScStyle_SmallCaps;
}
else if (feature == SHYPHEN)
{
m_Effects |= ScStyle_HyphenationPossible;
}
else if (feature.startsWith("-"))
{
QString no_feature = feature.mid(1);
if (no_feature == BOLD)
{
// deselect bolder font
}
else if (no_feature == ITALIC)
{
// deselect italic font
}
else if (no_feature == UNDERLINE)
{
m_Effects &= ~ScStyle_Underline;
}
else if (no_feature == UNDERLINEWORDS)
{
m_Effects &= ~ScStyle_UnderlineWords;
}
else if (no_feature == STRIKETHROUGH)
{
m_Effects &= ~ScStyle_Strikethrough;
}
else if (no_feature == SUPERSCRIPT)
{
m_Effects &= ~ScStyle_Superscript;
}
else if (no_feature == SUBSCRIPT)
{
m_Effects &= ~ScStyle_Subscript;
}
else if (no_feature == OUTLINE)
{
m_Effects &= ~ScStyle_Outline;
}
else if (no_feature == SHADOWED)
{
m_Effects &= ~ScStyle_Shadowed;
}
else if (no_feature == ALLCAPS)
{
m_Effects &= ~ScStyle_AllCaps;
}
else if (no_feature == SMALLCAPS)
{
m_Effects &= ~ScStyle_SmallCaps;
}
else {
qDebug("CharStyle: unknown feature: %s", feature.toLocal8Bit().constData());
}
}
else {
qDebug("CharStyle: unknown feature: %s", feature.toLocal8Bit().constData());
}
}
}
bool PMInsertRuleSystem::canInsert( const PMObject* parentObject,
const QString& className,
const PMObject* after,
const PMObjectList* objectsBetween )
{
bool possible = false;
// find rules for target class
PMMetaObject* meta = parentObject->metaObject( );
for( ; meta && !possible; meta = meta->superClass( ) )
{
PMRuleTargetClass* tc = m_rulesDict.find( meta->className( ) );
if( tc )
{
// check the exception list
QStringList exceptions = tc->exceptions( );
bool exceptionFound = false;
QStringList::ConstIterator it;
for( it = exceptions.begin( );
it != exceptions.end( ) && !exceptionFound; ++it )
if( parentObject->isA( *it ) )
exceptionFound = true;
if( !exceptionFound )
{
QPtrListIterator<PMRule> rit = tc->rules( );
// find matching rules for class name
for( ; rit.current( ) && !possible; ++rit )
{
PMRule* rule = rit.current( );
if( rule->matches( className ) )
{
// matching rule found
// reset the rule
rit.current( )->reset( );
// count already inserted child objects
bool afterInsertPoint = false;
PMObject* o = parentObject->firstChild( );
if( !after )
afterInsertPoint = true;
for( ; o; o = o->nextSibling( ) )
{
rule->countChild( o->className( ), afterInsertPoint );
if( o == after )
afterInsertPoint = true;
}
if( objectsBetween )
{
PMObjectListIterator it( *objectsBetween );
for( ; it.current( ); ++it )
rule->countChild( it.current( )->type( ), false );
}
// evaluate condition value
possible = rule->evaluate( parentObject );
}
}
}
}
}
return possible;
}
bool SvgParser::parseGradient(const KoXmlElement &e, const KoXmlElement &referencedBy)
{
// IMPROVEMENTS:
// - Store the parsed colorstops in some sort of a cache so they don't need to be parsed again.
// - A gradient inherits attributes it does not have from the referencing gradient.
// - Gradients with no color stops have no fill or stroke.
// - Gradients with one color stop have a solid color.
SvgGraphicsContext *gc = m_context.currentGC();
if (!gc)
return false;
SvgGradientHelper gradhelper;
if (e.hasAttribute("xlink:href")) {
QString href = e.attribute("xlink:href").mid(1);
if (! href.isEmpty()) {
// copy the referenced gradient if found
SvgGradientHelper *pGrad = findGradient(href);
if (pGrad)
gradhelper = *pGrad;
} else {
//gc->fillType = SvgGraphicsContext::None; // <--- TODO Fill OR Stroke are none
return false;
}
}
// Use the gradient that is referencing, or if there isn't one, the original gradient.
KoXmlElement b;
if (!referencedBy.isNull())
b = referencedBy;
else
b = e;
QString gradientId = b.attribute("id");
if (! gradientId.isEmpty()) {
// check if we have this gradient already parsed
// copy existing gradient if it exists
if (m_gradients.find(gradientId) != m_gradients.end())
gradhelper.copyGradient(m_gradients[ gradientId ].gradient());
}
if (b.attribute("gradientUnits") == "userSpaceOnUse")
gradhelper.setGradientUnits(SvgGradientHelper::UserSpaceOnUse);
// parse color prop
QColor c = gc->currentColor;
if (!b.attribute("color").isEmpty()) {
m_context.styleParser().parseColor(c, b.attribute("color"));
} else {
// try style attr
QString style = b.attribute("style").simplified();
const QStringList substyles = style.split(';', QString::SkipEmptyParts);
for (QStringList::ConstIterator it = substyles.begin(); it != substyles.end(); ++it) {
QStringList substyle = it->split(':');
QString command = substyle[0].trimmed();
QString params = substyle[1].trimmed();
if (command == "color")
m_context.styleParser().parseColor(c, params);
}
}
gc->currentColor = c;
if (b.tagName() == "linearGradient") {
QLinearGradient *g = new QLinearGradient();
if (gradhelper.gradientUnits() == SvgGradientHelper::ObjectBoundingBox) {
g->setCoordinateMode(QGradient::ObjectBoundingMode);
g->setStart(QPointF(SvgUtil::fromPercentage(b.attribute("x1", "0%")),
SvgUtil::fromPercentage(b.attribute("y1", "0%"))));
g->setFinalStop(QPointF(SvgUtil::fromPercentage(b.attribute("x2", "100%")),
SvgUtil::fromPercentage(b.attribute("y2", "0%"))));
} else {
g->setStart(QPointF(SvgUtil::fromUserSpace(b.attribute("x1").toDouble()),
SvgUtil::fromUserSpace(b.attribute("y1").toDouble())));
g->setFinalStop(QPointF(SvgUtil::fromUserSpace(b.attribute("x2").toDouble()),
SvgUtil::fromUserSpace(b.attribute("y2").toDouble())));
}
// preserve color stops
if (gradhelper.gradient())
g->setStops(gradhelper.gradient()->stops());
gradhelper.setGradient(g);
} else if (b.tagName() == "radialGradient") {
QRadialGradient *g = new QRadialGradient();
if (gradhelper.gradientUnits() == SvgGradientHelper::ObjectBoundingBox) {
g->setCoordinateMode(QGradient::ObjectBoundingMode);
g->setCenter(QPointF(SvgUtil::fromPercentage(b.attribute("cx", "50%")),
SvgUtil::fromPercentage(b.attribute("cy", "50%"))));
g->setRadius(SvgUtil::fromPercentage(b.attribute("r", "50%")));
g->setFocalPoint(QPointF(SvgUtil::fromPercentage(b.attribute("fx", "50%")),
SvgUtil::fromPercentage(b.attribute("fy", "50%"))));
} else {
g->setCenter(QPointF(SvgUtil::fromUserSpace(b.attribute("cx").toDouble()),
SvgUtil::fromUserSpace(b.attribute("cy").toDouble())));
g->setFocalPoint(QPointF(SvgUtil::fromUserSpace(b.attribute("fx").toDouble()),
SvgUtil::fromUserSpace(b.attribute("fy").toDouble())));
g->setRadius(SvgUtil::fromUserSpace(b.attribute("r").toDouble()));
}
// preserve color stops
if (gradhelper.gradient())
g->setStops(gradhelper.gradient()->stops());
gradhelper.setGradient(g);
} else {
return false;
}
// handle spread method
QString spreadMethod = b.attribute("spreadMethod");
if (!spreadMethod.isEmpty()) {
if (spreadMethod == "reflect")
gradhelper.gradient()->setSpread(QGradient::ReflectSpread);
else if (spreadMethod == "repeat")
gradhelper.gradient()->setSpread(QGradient::RepeatSpread);
else
gradhelper.gradient()->setSpread(QGradient::PadSpread);
} else
gradhelper.gradient()->setSpread(QGradient::PadSpread);
// Parse the color stops. The referencing gradient does not have colorstops,
// so use the stops from the gradient it references to (e in this case and not b)
m_context.styleParser().parseColorStops(gradhelper.gradient(), e);
gradhelper.setTransform(SvgUtil::parseTransform(b.attribute("gradientTransform")));
m_gradients.insert(gradientId, gradhelper);
return true;
}