void InternalToolBox::restore(const KConfigGroup &containmentGroup)
{
KConfigGroup group = KConfigGroup(&containmentGroup, "ToolBox");
if (!group.hasKey("corner")) {
return;
}
m_userMoved = true;
setCorner(Corner(group.readEntry("corner", int(corner()))));
const int offset = group.readEntry("offset", 0);
const int w = boundingRect().width();
const int h = boundingRect().height();
const int maxW = m_containment ? m_containment->geometry().width() - w : offset;
const int maxH = m_containment ? m_containment->geometry().height() - h : offset;
switch (corner()) {
case InternalToolBox::TopLeft:
setPos(0, 0);
break;
case InternalToolBox::Top:
setPos(qMin(offset, maxW), 0);
break;
case InternalToolBox::TopRight:
setPos(m_containment->size().width() - boundingRect().width(), 0);
break;
case InternalToolBox::Right:
setPos(m_containment->size().width() - boundingRect().width(), qMin(offset, maxH));
break;
case InternalToolBox::BottomRight:
setPos(m_containment->size().width() - boundingRect().width(), m_containment->size().height() - boundingRect().height());
break;
case InternalToolBox::Bottom:
setPos(qMin(offset, maxW), m_containment->size().height() - boundingRect().height());
break;
case InternalToolBox::BottomLeft:
setPos(0, m_containment->size().height() - boundingRect().height());
break;
case InternalToolBox::Left:
setPos(0, qMin(offset, maxH));
break;
}
//kDebug() << "marked as user moved" << pos()
// << (m_containment->containmentType() == Containment::PanelContainment);
}
QVariant LanguageListModel::data(const QModelIndex& index, int role) const
{
if (role==Qt::DecorationRole)
{
#if 0 //#ifndef NOKDE
static QMap<QString,QVariant> iconCache;
QString langCode=stringList().at(index.row());
if (!iconCache.contains(langCode))
{
QString code=QLocale(langCode).name();
QString path;
if (code.contains('_')) code=QString::fromRawData(code.unicode()+3, 2).toLower();
if (code!="C")
{
static const QString flagPath("l10n/%1/flag.png");
path=QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral("locale/") + flagPath.arg(code));
}
iconCache[langCode]=QIcon(path);
}
return iconCache.value(langCode);
#endif
}
else if (role==Qt::DisplayRole)
{
const QString& code=stringList().at(index.row());
if (code.isEmpty()) return code;
//qDebug()<<"languageCodeToName"<<code;
static QVector<QString> displayNames(stringList().size());
if (displayNames.at(index.row()).length())
return displayNames.at(index.row());
#ifndef NOKDE
return QVariant::fromValue<QString>(
displayNames[index.row()]=KConfigGroup(m_systemLangList,code).readEntry("Name")%QStringLiteral(" (")%code%')');
#else
QLocale l(code);
// if (l.language()==QLocale::C && code!="C")
return QVariant::fromValue<QString>(
displayNames[index.row()]=QLocale::languageToString(l.language())%QStringLiteral(" (")%code%')');
#endif
}
return QStringListModel::data(index, role);
}
//_______________________________________________________________________
void Config::load( const KConfigGroup& )
{
// load standard configuration
loadConfiguration( Configuration( KConfigGroup( _configuration, "Windeco") ) );
loadShadowConfiguration( QPalette::Active, ShadowConfiguration( QPalette::Active, KConfigGroup( _configuration, "ActiveShadow") ) );
loadShadowConfiguration( QPalette::Inactive, ShadowConfiguration( QPalette::Inactive, KConfigGroup( _configuration, "InactiveShadow") ) );
// load exceptions
ExceptionList exceptions;
exceptions.read( *_configuration );
if( exceptions.empty() )
{ exceptions = ExceptionList::defaultList(); }
// install in ui
ui->ui.exceptions->setExceptions( exceptions );
updateChanged();
}
void GPSSyncDialog::saveSettings()
{
KConfig config("kipirc");
KConfigGroup group = config.group(QString("GPS Sync 2 Settings"));
// --------------------------
KConfigGroup groupMapWidget = KConfigGroup(&group, "Map Widget");
d->mapWidget->saveSettingsToGroup(&groupMapWidget);
if (d->mapWidget2)
{
KConfigGroup groupMapWidget = KConfigGroup(&group, "Map Widget 2");
d->mapWidget2->saveSettingsToGroup(&groupMapWidget);
}
KConfigGroup groupCorrelatorWidget = KConfigGroup(&group, "Correlator Widget");
d->correlatorWidget->saveSettingsToGroup(&groupCorrelatorWidget);
KConfigGroup groupTreeView = KConfigGroup(&group, "Tree View");
d->treeView->saveSettingsToGroup(&groupTreeView);
KConfigGroup groupSearchWidget = KConfigGroup(&group, "Search Widget");
d->searchWidget->saveSettingsToGroup(&groupSearchWidget);
KConfigGroup groupRGWidget = KConfigGroup(&group, "Reverse Geocoding Widget");
d->rgWidget->saveSettingsToGroup(&groupRGWidget);
KConfigGroup groupDialog = KConfigGroup(&group, "Dialog");
saveDialogSize(groupDialog);
// --------------------------
group.writeEntry("Current Tab", d->tabBar->currentIndex());
group.writeEntry("Show oldest images first", d->sortActionOldestFirst->isChecked());
group.writeEntry("Bookmarks visible", d->actionBookmarkVisibility->isChecked());
group.writeEntry(QString("SplitterState V1"), d->VSplitter->saveState().toBase64());
group.writeEntry(QString("SplitterState H1"), d->HSplitter->saveState().toBase64());
group.writeEntry("Splitter H1 CollapsedSize", d->splitterSize);
group.writeEntry("Map Layout", QVariant::fromValue(int(d->mapLayout)));
// --------------------------
config.sync();
}
void PlasmoidProtocol::init()
{
//this should never happen
if (m_containment) {
return;
}
Host* h = qobject_cast<Host*>(parent());
QQuickItem* rootItem = h->rootItem();
if (rootItem) {
m_systrayApplet = rootItem->property("_plasma_applet").value<Plasma::Applet*>();
}
if (!m_systrayApplet) {
qWarning() << "Don't have a parent applet, Can't initialize the Plasmoid protocol!!!";
return;
}
int containmentId = 0;
KConfigGroup cg = m_systrayApplet->config();
cg = KConfigGroup(&cg, "Containments");
if (cg.isValid() && cg.groupList().size()) {
containmentId = cg.groupList().first().toInt();
}
m_containment = new Plasma::Containment(m_systrayApplet, QStringLiteral("null"), containmentId);
m_containment->setImmutability(Plasma::Types::Mutable);
m_containment->setFormFactor(Plasma::Types::Horizontal);
m_containment->setLocation(m_systrayApplet->location());
m_containment->setContainmentActions(QStringLiteral("RightButton;NoModifier"), QStringLiteral("org.kde.contextmenu"));
m_containment->init();
emit m_systrayApplet->containment()->corona()->containmentAdded(m_containment);
connect(m_systrayApplet, &Plasma::Applet::locationChanged, this, [=]() {
m_containment->setLocation(m_systrayApplet->location());
});
m_systrayApplet->setProperty("containment", QVariant::fromValue(m_containment));
restorePlasmoids();
}
QString ExportManager::saveLocation() const
{
KSharedConfigPtr config = KSharedConfig::openConfig(QStringLiteral("spectaclerc"));
KConfigGroup generalConfig = KConfigGroup(config, "General");
QString savePath = generalConfig.readPathEntry(
"default-save-location", QStandardPaths::writableLocation(QStandardPaths::PicturesLocation));
if (savePath.isEmpty() || savePath.isNull()) {
savePath = QDir::homePath();
}
savePath = QDir::cleanPath(savePath);
QDir savePathDir(savePath);
if (!(savePathDir.exists())) {
savePathDir.mkpath(QStringLiteral("."));
generalConfig.writePathEntry("last-saved-to", savePath);
}
return savePath;
}
void SpellCheckConfig::load()
{
KCModule::load();
//FIXME: This shouldn't be hardcoded!
KSharedConfig::Ptr cfg = KSharedConfig::openConfig( QLatin1String( "krunnerrc" ) );
KConfigGroup conf = cfg->group( "Runners" );
KConfigGroup grp = KConfigGroup( &conf, "Spell Checker");
const bool requireTrigger = grp.readEntry("requireTriggerWord", true);
const QString trigger = grp.readEntry("trigger", i18n("spell"));
if (!requireTrigger) {
m_ui->m_triggerWord->setEnabled(false);
}
m_ui->m_requireTriggerWord->setCheckState( (requireTrigger) ? Qt::Checked : Qt::Unchecked );
m_ui->m_triggerWord->setText( trigger );
emit changed(false);
}
void MousePluginWidget::save()
{
QString trigger = m_triggerButton->trigger();
if (trigger.isEmpty()) {
m_lastConfigLocation.clear();
return;
}
if (m_pluginInstance || !m_lastConfigLocation.isEmpty()) {
KConfigGroup cfg = m_containment->containmentActionsConfig();
cfg = KConfigGroup(&cfg, trigger);
if (m_pluginInstance) {
m_pluginInstance.data()->save(cfg);
} else {
m_tempConfig.copyTo(&cfg);
//kDebug() << "copied from temp";
}
m_lastConfigLocation = trigger;
}
m_containment->setContainmentActions(trigger, m_plugin.pluginName());
}
RecipientDialog::RecipientDialog(QWidget* parent, QAbstractListModel* model) :
QDialog(parent)
{
setModal( true );
setWindowTitle( i18n("Select Recipient") );
// Add the layout to the widget
QVBoxLayout* dialogLayout = new QVBoxLayout(this);
// Add the nickname list widget
QSortFilterProxyModel *sortModel = new QSortFilterProxyModel(this);
sortModel->setSortCaseSensitivity(Preferences::self()->sortCaseInsensitive() ? Qt::CaseInsensitive : Qt::CaseSensitive);
sortModel->setSourceModel(model);
sortModel->sort(0, Qt::AscendingOrder);
QListView* nicknameList = new QListView(this);
nicknameList->setUniformItemSizes(true);
nicknameList->setModel(sortModel);
nicknameInput = new KLineEdit(this);
dialogLayout->addWidget(nicknameList);
dialogLayout->addWidget(nicknameInput);
connect(nicknameList, &QListView::clicked, this, &RecipientDialog::newNicknameSelected);
connect(nicknameList, &QListView::doubleClicked, this, &RecipientDialog::newNicknameSelectedQuit);
QDialogButtonBox* buttonBox = new QDialogButtonBox(this);
dialogLayout->addWidget(buttonBox);
QPushButton* button = buttonBox->addButton(QDialogButtonBox::Ok);
button->setToolTip(i18n("Select nickname and close the window"));
button->setIcon(SmallIcon("dialog-ok"));
button->setShortcut(Qt::CTRL | Qt::Key_Return);
button->setDefault(true);
button = buttonBox->addButton(QDialogButtonBox::Cancel);
button->setToolTip(i18n("Close the window without changes"));
button->setIcon(SmallIcon("dialog-cancel"));
KWindowConfig::restoreWindowSize(windowHandle(), KConfigGroup(KSharedConfig::openConfig(), "DCCRecipientDialog"));
connect(buttonBox, &QDialogButtonBox::accepted, this, &RecipientDialog::slotOk);
connect(buttonBox, &QDialogButtonBox::rejected, this, &RecipientDialog::slotCancel);
}
FileBrowserWidget::FileBrowserWidget(KileDocument::Extensions *extensions, QWidget *parent)
: QWidget(parent), m_extensions(extensions)
{
m_configGroup = KConfigGroup(KSharedConfig::openConfig(),"FileBrowserWidget");
QVBoxLayout* layout = new QVBoxLayout(this);
layout->setMargin(0);
layout->setSpacing(0);
setLayout(layout);
m_toolbar = new KToolBar(this);
m_toolbar->setMovable(false);
m_toolbar->setToolButtonStyle(Qt::ToolButtonIconOnly);
m_toolbar->setContextMenuPolicy(Qt::NoContextMenu);
layout->addWidget(m_toolbar);
KFilePlacesModel* model = new KFilePlacesModel(this);
m_urlNavigator = new KUrlNavigator(model, QUrl::fromLocalFile(QDir::homePath()), this);
layout->addWidget(m_urlNavigator);
connect(m_urlNavigator, SIGNAL(urlChanged(const QUrl&)), SLOT(setDir(const QUrl&)));
m_dirOperator = new KDirOperator(QUrl(), this);
m_dirOperator->setViewConfig(m_configGroup);
m_dirOperator->readConfig(m_configGroup);
m_dirOperator->setView(KFile::Default);
m_dirOperator->setMode(KFile::Files);
setFocusProxy(m_dirOperator);
connect(m_urlNavigator, SIGNAL(urlChanged(const QUrl&)), m_dirOperator, SLOT(setFocus()));
connect(m_dirOperator, SIGNAL(fileSelected(const KFileItem&)), this, SIGNAL(fileSelected(const KFileItem&)));
connect(m_dirOperator, SIGNAL(urlEntered(const QUrl&)), this, SLOT(dirUrlEntered(const QUrl&)));
setupToolbar();
layout->addWidget(m_dirOperator);
layout->setStretchFactor(m_dirOperator, 2);
readConfig();
}
LoadScriptList KWin::Scripting::queryScriptsToLoad()
{
KSharedConfig::Ptr _config = KSharedConfig::openConfig();
static bool s_started = false;
if (s_started) {
_config->reparseConfiguration();
} else {
s_started = true;
}
QMap<QString,QString> pluginStates = KConfigGroup(_config, "Plugins").entryMap();
KService::List offers = KServiceTypeTrader::self()->query(QStringLiteral("KWin/Script"));
LoadScriptList scriptsToLoad;
foreach (const KService::Ptr & service, offers) {
KPluginInfo plugininfo(service);
const QString value = pluginStates.value(plugininfo.pluginName() + QString::fromLatin1("Enabled"), QString());
plugininfo.setPluginEnabled(value.isNull() ? plugininfo.isPluginEnabledByDefault() : QVariant(value).toBool());
const bool javaScript = service->property(QStringLiteral("X-Plasma-API")).toString() == QStringLiteral("javascript");
const bool declarativeScript = service->property(QStringLiteral("X-Plasma-API")).toString() == QStringLiteral("declarativescript");
if (!javaScript && !declarativeScript) {
continue;
}
if (!plugininfo.isPluginEnabled()) {
if (isScriptLoaded(plugininfo.pluginName())) {
// unload the script
unloadScript(plugininfo.pluginName());
}
continue;
}
const QString pluginName = service->property(QStringLiteral("X-KDE-PluginInfo-Name")).toString();
const QString scriptName = service->property(QStringLiteral("X-Plasma-MainScript")).toString();
const QString file = QStandardPaths::locate(QStandardPaths::GenericDataLocation, QStringLiteral(KWIN_NAME) + QStringLiteral("/scripts/") + pluginName + QStringLiteral("/contents/") + scriptName);
if (file.isNull()) {
qDebug() << "Could not find script file for " << pluginName;
continue;
}
scriptsToLoad << qMakePair(javaScript, qMakePair(file, pluginName));
}
void KMovingConfig::save(void)
{
KConfigGroup cg(config, "Windows");
cg.writeEntry(KWIN_GEOMETRY, getGeometryTip());
cg.writeEntry(KWM_BRDR_SNAP_ZONE, getBorderSnapZone());
cg.writeEntry(KWM_WNDW_SNAP_ZONE, getWindowSnapZone());
cg.writeEntry(KWM_CNTR_SNAP_ZONE, getCenterSnapZone());
cg.writeEntry("SnapOnlyWhenOverlapping", m_ui->OverlapSnap->isChecked());
KConfigGroup(config, "Plugins").writeEntry("kwin4_effect_windowgeometryEnabled", getGeometryTip());
if (standAlone) {
config->sync();
// Send signal to all kwin instances
QDBusMessage message =
QDBusMessage::createSignal("/KWin", "org.kde.KWin", "reloadConfig");
QDBusConnection::sessionBus().send(message);
}
emit KCModule::changed(false);
}
void DesktopThemeDetails::removeTheme()
{
bool removeTheme = true;
KConfigGroup cfg = KConfigGroup(KSharedConfig::openConfig("plasmarc"), "Theme");
QString activeTheme = cfg.readEntry("name", "default");
const QString theme = m_theme->currentIndex().data(ThemeModel::PackageNameRole).toString();
const QString themeName = m_theme->currentIndex().data(Qt::DisplayRole).toString();
if (m_themeCustomized) {
if(KMessageBox::questionYesNo(this, i18n("Theme items have been changed. Do you still wish remove the \"%1\" theme?", themeName), i18n("Remove Desktop Theme")) == KMessageBox::No) {
removeTheme = false;
}
} else {
if (theme == "default") {
KMessageBox::information(this, i18n("Removal of the default desktop theme is not allowed."), i18n("Remove Desktop Theme"));
removeTheme = false;
} else {
if(KMessageBox::questionYesNo(this, i18n("Are you sure you wish remove the \"%1\" theme?", themeName), i18n("Remove Desktop Theme")) == KMessageBox::No) {
removeTheme = false;
}
}
}
KStandardDirs dirs;
if (removeTheme) {
if (theme == activeTheme) {
setDesktopTheme("default");
activeTheme = "default";
}
if (QDir(dirs.locateLocal("data", "desktoptheme/" + theme, false)).exists()) {
KIO::DeleteJob *deleteTheme = KIO::del(QUrl::fromLocalFile(dirs.locateLocal("data", "desktoptheme/" + theme, false)), KIO::HideProgressInfo);
KIO::NetAccess::synchronousRun(deleteTheme, this);
}
}
m_themeModel->reload();
reloadConfig();
m_theme->setCurrentIndex(m_themeModel->indexOf(activeTheme));
}
void GPSSyncDialog::adjustMapLayout(const bool syncSettings)
{
if (d->mapLayout==MapLayoutOne)
{
if (d->mapSplitter->count()>1)
{
delete d->mapSplitter->widget(1);
d->mapWidget2 = 0;
}
}
else
{
if (d->mapSplitter->count()==1)
{
QWidget* mapHolder = 0;
d->mapWidget2 = makeMapWidget(&mapHolder);
d->mapSplitter->addWidget(mapHolder);
if (syncSettings)
{
KConfig config("kipirc");
KConfigGroup group = config.group(QString("GPS Sync 2 Settings"));
const KConfigGroup groupMapWidget = KConfigGroup(&group, "Map Widget");
d->mapWidget2->readSettingsFromGroup(&groupMapWidget);
d->mapWidget2->setActive(true);
}
}
if (d->mapLayout==MapLayoutHorizontal)
{
d->mapSplitter->setOrientation(Qt::Horizontal);
}
else
{
d->mapSplitter->setOrientation(Qt::Vertical);
}
}
}
void RecentFileManager::addRecent(const QString &_url)
{
if (d->recentFiles.size() > d->maxItems) {
d->recentFiles.removeLast();
d->recentFilesIndex.removeLast();
}
QString localFile = QDir::toNativeSeparators(_url);
QString fileName = QFileInfo(_url).fileName();
if (d->recentFiles.contains(localFile)) {
d->recentFiles.removeAll(localFile);
}
if (d->recentFilesIndex.contains(fileName)) {
d->recentFilesIndex.removeAll(fileName);
}
d->recentFiles.insert(0, localFile);
d->recentFilesIndex.insert(0, fileName);
d->saveEntries(KConfigGroup(KGlobal::config(), "RecentFiles"));
emit recentFilesListChanged();
}
void servercontroller::readGlobalProperties(KConfig *ksc)
{
QString group = ksc->group();
// ksc == K Session Config
// KMainWindow silently disables our menubar, when we quit in a docked
// state, so we have to force showing it here.
menuBar()->show();
// commented in for testing...
ksc->setGroup( "KSircSession" );
QMap<QString,QString> keyMap = ksc->entryMap( ksc->group() );
QMap<QString,QString>::Iterator it = keyMap.begin();
while(it != keyMap.end()) {
QString server = it.key();
QString port = KConfigGroup( ksc, "KSircSessionPort" ).readEntry( server );
// debug("%s", it.key().latin1());
KSircServer kss(server, port);
new_ksircprocess( kss ); // sets up proc_list
QStringList channels = ksc->readListEntry( server );
QStringList desktops = KConfigGroup( ksc, "KSircSessionDesktopNumbers" ).readListEntry( server );
for(uint i = 0; i < channels.count(); i++){
QString channel = channels[ i ];
proc_list[ server ]->new_toplevel( KSircChannel(server, channel), true );
KSircTopLevel *topLevel = dynamic_cast<KSircTopLevel *>( proc_list[ server ]->getWindowList()[ channel ] );
if ( !topLevel || !topLevel->isTopLevel() )
continue;
QStringList::ConstIterator desktopNumberIt = desktops.at( i );
if ( desktopNumberIt == desktops.end() )
continue;
int desktop = ( *desktopNumberIt ).toInt();
if ( desktop == -1 )
continue;
#ifdef Q_WS_X11
NETWinInfo winInfo( qt_xdisplay(), topLevel->winId(), qt_xrootwin(), NET::WMDesktop );
winInfo.setDesktop( desktop );
#endif
}
++it;
}
QRect geom;
// ksc->setGroup("ServerController");
// bool docked = ksc->readBoolEntry("Docked", FALSE);
// if ( !docked )
// show();
if(ksopts->runDocked == false)
show();
geom = ksc->readRectEntry("Size");
if(! geom.isEmpty())
setGeometry(geom);
ksc->setGroup(group);
}
void CalibrateFlossDlg::hideEvent(QHideEvent *event)
{
KConfigGroup(KSharedConfig::openConfig(), QStringLiteral("DialogSizes")).writeEntry(QStringLiteral("CalibrateFlossDlg"), size());
QDialog::hideEvent(event);
}
/** Generate the list of hl modes, store them in myModeList
force: if true forces to rebuild the Mode List from the xml files (instead of katesyntax...rc)
*/
void KateSyntaxDocument::setupModeList (bool force)
{
// If there's something in myModeList the Mode List was already built so, don't do it again
if (!myModeList.isEmpty())
return;
// We'll store the ModeList in katesyntaxhighlightingrc
KConfigGroup generalConfig(m_config, "General");
// figure our if the kate install is too new
if (generalConfig.readEntry ("Version",0) > generalConfig.readEntry ("CachedVersion",0))
{
generalConfig.writeEntry ("CachedVersion", generalConfig.readEntry ("Version",0));
force = true;
}
// Let's get a list of all the xml files for hl
const QStringList list = KGlobal::dirs()->findAllResources("data","katepart/syntax/*.xml",
KStandardDirs::NoDuplicates);
// Let's iterate through the list and build the Mode List
for ( QStringList::ConstIterator it = list.begin(); it != list.end(); ++it )
{
// Each file has a group called:
QString Group="Cache "+ *it;
// Let's go to this group
KConfigGroup config(m_config, Group);
// stat the file
KDE_struct_stat sbuf;
memset (&sbuf, 0, sizeof(sbuf));
KDE::stat(*it, &sbuf);
// If the group exist and we're not forced to read the xml file, let's build myModeList for katesyntax..rc
if (!force && config.exists() && (sbuf.st_mtime == config.readEntry("lastModified",0)))
{
// Let's make a new KateSyntaxModeListItem to instert in myModeList from the information in katesyntax..rc
KateSyntaxModeListItem *mli=new KateSyntaxModeListItem;
mli->name = config.readEntry("name");
mli->nameTranslated = i18nc("Language",mli->name.toUtf8());
mli->section = i18nc("Language Section",config.readEntry("section").toUtf8());
mli->mimetype = config.readEntry("mimetype");
mli->extension = config.readEntry("extension");
mli->version = config.readEntry("version");
mli->priority = config.readEntry("priority");
mli->style = config.readEntry("style");
mli->author = config.readEntry("author");
mli->license = config.readEntry("license");
mli->indenter = config.readEntry("indenter");
mli->hidden = config.readEntry("hidden", false);
mli->identifier = *it;
// Apend the item to the list
myModeList.append(mli);
}
else
{
#ifdef KSD_OVER_VERBOSE
kDebug (13010) << "UPDATE hl cache for: " << *it;
#endif
// We're forced to read the xml files or the mode doesn't exist in the katesyntax...rc
QFile f(*it);
if (f.open(QIODevice::ReadOnly))
{
// Ok we opened the file, let's read the contents and close the file
/* the return of setContent should be checked because a false return shows a parsing error */
QString errMsg;
int line, col;
bool success = setContent(&f,&errMsg,&line,&col);
f.close();
if (success)
{
QDomElement root = documentElement();
if (!root.isNull())
{
// If the 'first' tag is language, go on
if (root.tagName()=="language")
{
// let's make the mode list item.
KateSyntaxModeListItem *mli = new KateSyntaxModeListItem;
mli->name = root.attribute("name");
mli->section = root.attribute("section");
mli->mimetype = root.attribute("mimetype");
mli->extension = root.attribute("extensions");
mli->version = root.attribute("version");
mli->priority = root.attribute("priority");
mli->style = root.attribute("style");
mli->author = root.attribute("author");
mli->license = root.attribute("license");
mli->indenter = root.attribute("indenter");
QString hidden = root.attribute("hidden");
mli->hidden = (hidden == "true" || hidden == "TRUE");
mli->identifier = *it;
// Now let's write or overwrite (if force==true) the entry in katesyntax...rc
config = KConfigGroup(m_config, Group);
config.writeEntry("name",mli->name);
config.writeEntry("section",mli->section);
config.writeEntry("mimetype",mli->mimetype);
config.writeEntry("extension",mli->extension);
config.writeEntry("version",mli->version);
config.writeEntry("priority",mli->priority);
config.writeEntry("style",mli->style);
config.writeEntry("author",mli->author);
config.writeEntry("license",mli->license);
config.writeEntry("indenter",mli->indenter);
config.writeEntry("hidden",mli->hidden);
// modified time to keep cache in sync
config.writeEntry("lastModified", int(sbuf.st_mtime));
// Now that the data is in the config file, translate section
mli->section = i18nc("Language Section",mli->section.toUtf8());
mli->nameTranslated = i18nc("Language",mli->name.toUtf8());
// Append the new item to the list.
myModeList.append(mli);
}
}
}
else
{
KateSyntaxModeListItem *emli=new KateSyntaxModeListItem;
emli->section=i18n("Errors!");
emli->mimetype="invalid_file/invalid_file";
emli->extension="invalid_file.invalid_file";
emli->version="1.";
emli->name=QString ("Error: %1").arg(*it); // internal
emli->nameTranslated=i18n("Error: %1", *it); // translated
emli->identifier=(*it);
myModeList.append(emli);
}
}
}
}
// Synchronize with the file katesyntax...rc
generalConfig.sync();
}
void TextToolDlg::hideEvent(QHideEvent *event)
{
KConfigGroup(KSharedConfig::openConfig(), QStringLiteral("DialogSizes")).writeEntry(QStringLiteral("TextToolDlg"), size());
QDialog::hideEvent(event);
}
void ApplicationListModel::loadApplications()
{
auto cfg = KSharedConfig::openConfig("applications-blacklistrc");
auto blgroup = KConfigGroup(cfg, QStringLiteral("Applications"));
// This is only temporary to get a clue what those apps' desktop files are called
// I'll remove it once I've done a blacklist
QStringList bl;
QStringList blacklist = blgroup.readEntry("blacklist", QStringList());
beginResetModel();
m_applicationList.clear();
KServiceGroup::Ptr group = KServiceGroup::root();
if (!group || !group->isValid()) return;
KServiceGroup::List subGroupList = group->entries(true);
QMap<int, ApplicationData> orderedList;
QList<ApplicationData> unorderedList;
// Iterate over all entries in the group
while (!subGroupList.isEmpty()) {
KSycocaEntry::Ptr groupEntry = subGroupList.first();
subGroupList.pop_front();
if (groupEntry->isType(KST_KServiceGroup)) {
KServiceGroup::Ptr serviceGroup(static_cast<KServiceGroup* >(groupEntry.data()));
if (!serviceGroup->noDisplay()) {
KServiceGroup::List entryGroupList = serviceGroup->entries(true);
for(KServiceGroup::List::ConstIterator it = entryGroupList.constBegin(); it != entryGroupList.constEnd(); it++) {
KSycocaEntry::Ptr entry = (*it);
if (entry->isType(KST_KServiceGroup)) {
KServiceGroup::Ptr serviceGroup(static_cast<KServiceGroup* >(entry.data()));
subGroupList << serviceGroup;
} else if (entry->property("Exec").isValid()) {
KService::Ptr service(static_cast<KService* >(entry.data()));
qDebug() << " desktopEntryName: " << service->desktopEntryName();
if (service->isApplication() &&
!blacklist.contains(service->desktopEntryName()) &&
service->showOnCurrentPlatform() &&
!service->property("Terminal", QVariant::Bool).toBool()) {
bl << service->desktopEntryName();
ApplicationData data;
data.name = service->name();
data.icon = service->icon();
data.storageId = service->storageId();
data.entryPath = service->exec();
auto it = m_appPositions.constFind(service->storageId());
if (it != m_appPositions.constEnd()) {
orderedList[*it] = data;
} else {
unorderedList << data;
}
}
}
}
}
}
}
blgroup.writeEntry("allapps", bl);
blgroup.writeEntry("blacklist", blacklist);
cfg->sync();
std::sort(unorderedList.begin(), unorderedList.end(), appNameLessThan);
m_applicationList << orderedList.values();
m_applicationList << unorderedList;
endResetModel();
emit countChanged();
}
void K3b::ImageWritingDialog::slotStartClicked()
{
d->md5Job->cancel();
// save the path
KConfigGroup grp( KGlobal::config(), configGroup() );
grp.writePathEntry( "last written image", d->imagePath() );
if( d->imageFile.isEmpty() )
d->imageFile = d->imagePath();
if( d->tocFile.isEmpty() )
d->tocFile = d->imagePath();
// create a progresswidget
K3b::BurnProgressDialog dlg( parentWidget() );
// create the job
K3b::BurnJob* job = 0;
switch( d->currentImageType() ) {
case IMAGE_CDRECORD_CLONE:
{
K3b::CloneJob* _job = new K3b::CloneJob( &dlg, this );
_job->setWriterDevice( d->writerSelectionWidget->writerDevice() );
_job->setImagePath( d->imageFile );
_job->setSimulate( d->checkDummy->isChecked() );
_job->setWriteSpeed( d->writerSelectionWidget->writerSpeed() );
_job->setCopies( d->checkDummy->isChecked() ? 1 : d->spinCopies->value() );
_job->setOnlyBurnExistingImage( true );
job = _job;
}
break;
case IMAGE_AUDIO_CUE:
{
K3b::AudioCueFileWritingJob* job_ = new K3b::AudioCueFileWritingJob( &dlg, this );
job_->setBurnDevice( d->writerSelectionWidget->writerDevice() );
job_->setSpeed( d->writerSelectionWidget->writerSpeed() );
job_->setSimulate( d->checkDummy->isChecked() );
job_->setWritingMode( d->writingModeWidget->writingMode() );
job_->setCueFile( d->tocFile );
job_->setCopies( d->checkDummy->isChecked() ? 1 : d->spinCopies->value() );
job_->setOnTheFly( !d->checkCacheImage->isChecked() );
job_->setTempDir( d->tempDirSelectionWidget->tempPath() );
job = job_;
}
break;
case IMAGE_CUE_BIN:
// for now the K3b::BinImageWritingJob decides if it's a toc or a cue file
case IMAGE_CDRDAO_TOC:
{
K3b::BinImageWritingJob* job_ = new K3b::BinImageWritingJob( &dlg, this );
job_->setWriter( d->writerSelectionWidget->writerDevice() );
job_->setSpeed( d->writerSelectionWidget->writerSpeed() );
job_->setTocFile( d->tocFile );
job_->setSimulate(d->checkDummy->isChecked());
job_->setMulti( false /*d->checkNoFix->isChecked()*/ );
job_->setCopies( d->checkDummy->isChecked() ? 1 : d->spinCopies->value() );
job = job_;
}
break;
case IMAGE_ISO:
{
K3b::Iso9660 isoFs( d->imageFile );
if( isoFs.open() ) {
if( K3b::filesize( KUrl(d->imageFile) ) < Private::volumeSpaceSize( isoFs ) ) {
if( KMessageBox::questionYesNo( this,
i18n("<p>The actual file size does not match the size declared in the file header. "
"If it has been downloaded make sure the download is complete.</p>"
"<p>Only continue if you know what you are doing.</p>"),
i18n("Warning"),
KStandardGuiItem::cont(),
KStandardGuiItem::cancel() ) == KMessageBox::No )
return;
}
}
K3b::Iso9660ImageWritingJob* job_ = new K3b::Iso9660ImageWritingJob( &dlg );
job_->setBurnDevice( d->writerSelectionWidget->writerDevice() );
job_->setSpeed( d->writerSelectionWidget->writerSpeed() );
job_->setSimulate( d->checkDummy->isChecked() );
job_->setWritingMode( d->writingModeWidget->writingMode() );
job_->setVerifyData( d->checkVerify->isChecked() );
job_->setNoFix( d->checkNoFix->isChecked() );
job_->setDataMode( d->dataModeWidget->dataMode() );
job_->setImagePath( d->imageFile );
job_->setCopies( d->checkDummy->isChecked() ? 1 : d->spinCopies->value() );
job = job_;
}
break;
default:
kDebug() << "(K3b::ImageWritingDialog) this should really not happen!";
break;
}
if( job ) {
job->setWritingApp( d->writerSelectionWidget->writingApp() );
hide();
dlg.startJob(job);
delete job;
if( KConfigGroup( KGlobal::config(), "General Options" ).readEntry( "keep action dialogs open", false ) )
show();
else
close();
}
}
void K3b::MediaCopyDialog::slotStartClicked()
{
//
// Let's check the available size
//
if( m_checkCacheImage->isChecked() || m_checkOnlyCreateImage->isChecked() ) {
if( neededSize() > m_tempDirSelectionWidget->freeTempSpace() ) {
if( KMessageBox::warningContinueCancel( this, i18n("There does not seem to be enough free space in the temporary folder. "
"Write anyway?") ) == KMessageBox::Cancel )
return;
}
}
K3b::Device::Device* readDev = m_comboSourceDevice->selectedDevice();
K3b::Device::Device* burnDev = m_writerSelectionWidget->writerDevice();
K3b::Medium sourceMedium = k3bappcore->mediaCache()->medium( readDev );
K3b::Medium burnMedium = k3bappcore->mediaCache()->medium( burnDev );
K3b::JobProgressDialog* dlg = 0;
if( m_checkOnlyCreateImage->isChecked() ) {
dlg = new K3b::JobProgressDialog( parentWidget() );
}
else {
dlg = new K3b::BurnProgressDialog( parentWidget() );
}
K3b::BurnJob* burnJob = 0;
if( m_comboCopyMode->currentIndex() == 1 ) {
//
// check for m_tempDirSelectionWidget->tempPath() and
// m_tempDirSelectionWidget-tempPath() + ".toc"
//
if( QFileInfo( m_tempDirSelectionWidget->tempPath() ).isFile() ) {
if( KMessageBox::warningContinueCancel( this,
i18n("Do you want to overwrite %1?",m_tempDirSelectionWidget->tempPath()),
i18n("File Exists"),
KStandardGuiItem::overwrite() )
!= KMessageBox::Continue )
return;
}
if( QFileInfo( m_tempDirSelectionWidget->tempPath() + ".toc" ).isFile() ) {
if( KMessageBox::warningContinueCancel( this,
i18n("Do you want to overwrite %1?",m_tempDirSelectionWidget->tempPath() + ".toc"),
i18n("File Exists"),
KStandardGuiItem::overwrite() )
!= KMessageBox::Continue )
return;
}
K3b::CloneJob* job = new K3b::CloneJob( dlg, this );
job->setWriterDevice( m_writerSelectionWidget->writerDevice() );
job->setReaderDevice( m_comboSourceDevice->selectedDevice() );
job->setImagePath( m_tempDirSelectionWidget->tempPath() );
job->setNoCorrection( m_checkNoCorrection->isChecked() );
job->setRemoveImageFiles( m_checkDeleteImages->isChecked() && !m_checkOnlyCreateImage->isChecked() );
job->setOnlyCreateImage( m_checkOnlyCreateImage->isChecked() );
job->setSimulate( m_checkSimulate->isChecked() );
job->setWriteSpeed( m_writerSelectionWidget->writerSpeed() );
job->setCopies( m_checkSimulate->isChecked() ? 1 : m_spinCopies->value() );
job->setReadRetries( m_spinDataRetries->value() );
burnJob = job;
}
else if ( sourceMedium.diskInfo().mediaType() & K3b::Device::MEDIA_CD_ALL ) {
K3b::CdCopyJob* job = new K3b::CdCopyJob( dlg, this );
job->setWriterDevice( m_writerSelectionWidget->writerDevice() );
job->setReaderDevice( m_comboSourceDevice->selectedDevice() );
job->setSpeed( m_writerSelectionWidget->writerSpeed() );
job->setSimulate( m_checkSimulate->isChecked() );
job->setOnTheFly( !m_checkCacheImage->isChecked() );
job->setKeepImage( !m_checkDeleteImages->isChecked() || m_checkOnlyCreateImage->isChecked() );
job->setOnlyCreateImage( m_checkOnlyCreateImage->isChecked() );
job->setTempPath( m_tempDirSelectionWidget->plainTempPath() );
job->setCopies( m_checkSimulate->isChecked() ? 1 : m_spinCopies->value() );
job->setParanoiaMode( m_comboParanoiaMode->currentText().toInt() );
job->setDataReadRetries( m_spinDataRetries->value() );
job->setAudioReadRetries( m_spinAudioRetries->value() );
job->setCopyCdText( m_checkReadCdText->isChecked() );
job->setIgnoreDataReadErrors( m_checkIgnoreDataReadErrors->isChecked() );
job->setIgnoreAudioReadErrors( m_checkIgnoreAudioReadErrors->isChecked() );
job->setNoCorrection( m_checkNoCorrection->isChecked() );
job->setWritingMode( m_writingModeWidget->writingMode() );
burnJob = job;
}
else if ( sourceMedium.diskInfo().mediaType() & ( K3b::Device::MEDIA_DVD_ALL|K3b::Device::MEDIA_BD_ALL ) ) {
K3b::DvdCopyJob* job = new K3b::DvdCopyJob( dlg, this );
job->setWriterDevice( m_writerSelectionWidget->writerDevice() );
job->setReaderDevice( m_comboSourceDevice->selectedDevice() );
job->setImagePath( m_tempDirSelectionWidget->tempPath() );
job->setRemoveImageFiles( m_checkDeleteImages->isChecked() && !m_checkOnlyCreateImage->isChecked() );
job->setOnlyCreateImage( m_checkOnlyCreateImage->isChecked() );
job->setSimulate( m_checkSimulate->isChecked() );
job->setOnTheFly( !m_checkCacheImage->isChecked() );
job->setWriteSpeed( m_writerSelectionWidget->writerSpeed() );
job->setCopies( m_checkSimulate->isChecked() ? 1 : m_spinCopies->value() );
job->setWritingMode( m_writingModeWidget->writingMode() );
job->setIgnoreReadErrors( m_checkIgnoreDataReadErrors->isChecked() );
job->setReadRetries( m_spinDataRetries->value() );
job->setVerifyData( m_checkVerifyData->isChecked() );
burnJob = job;
}
else {
// do not translate this as it is not intended to be included in the stable version!
KMessageBox::sorry( this, "Ups", "No copy support for this source media type yet." );
return;
}
hide();
dlg->startJob( burnJob );
delete dlg;
delete burnJob;
if( KConfigGroup( KGlobal::config(), "General Options" ).readEntry( "keep action dialogs open", false ) )
show();
else
close();
}
void KonqPopupMenuPrivate::init(KonqPopupMenu::Flags kpf, KParts::BrowserExtension::PopupFlags flags)
{
m_itemFlags = flags;
q->setFont(KGlobalSettings::menuFont());
Q_ASSERT(m_popupItemProperties.items().count() >= 1);
bool bTrashIncluded = false;
const KFileItemList lstItems = m_popupItemProperties.items();
KFileItemList::const_iterator it = lstItems.constBegin();
const KFileItemList::const_iterator kend = lstItems.constEnd();
for ( ; it != kend; ++it )
{
const KUrl url = (*it).url();
if ( !bTrashIncluded && (
( url.protocol() == "trash" && url.path().length() <= 1 ) ) ) {
bTrashIncluded = true;
}
}
const bool isDirectory = m_popupItemProperties.isDirectory();
const bool sReading = m_popupItemProperties.supportsReading();
bool sDeleting = (m_itemFlags & KParts::BrowserExtension::NoDeletion) == 0
&& m_popupItemProperties.supportsDeleting();
const bool sWriting = m_popupItemProperties.supportsWriting();
const bool sMoving = sDeleting && m_popupItemProperties.supportsMoving();
const bool isLocal = m_popupItemProperties.isLocal();
KUrl url = m_sViewURL;
url.cleanPath();
bool isTrashLink = false;
bool isCurrentTrash = false;
bool currentDir = false;
bool isSymLink = false;
bool isSymLinkInSameDir = false; // true for "ln -s foo bar", false for links to foo/sub or /foo
//check if url is current directory
if ( lstItems.count() == 1 )
{
KFileItem firstPopupItem( lstItems.first() );
if (firstPopupItem.isLink()) {
isSymLink = true;
isSymLinkInSameDir = !firstPopupItem.linkDest().contains('/');
}
KUrl firstPopupURL( firstPopupItem.url() );
firstPopupURL.cleanPath();
//kDebug(1203) << "View path is " << url.url();
//kDebug(1203) << "First popup path is " << firstPopupURL.url();
currentDir = firstPopupURL.equals( url, KUrl::CompareWithoutTrailingSlash );
if ( firstPopupItem.isDesktopFile() ) {
KDesktopFile desktopFile( firstPopupItem.localPath() );
const KConfigGroup cfg = desktopFile.desktopGroup();
isTrashLink = ( cfg.readEntry("Type") == "Link" && cfg.readEntry("URL") == "trash:/" );
}
if (isTrashLink) {
sDeleting = false;
}
// isCurrentTrash: popup on trash:/ itself, or on the trash.desktop link
isCurrentTrash = (firstPopupURL.protocol() == "trash" && firstPopupURL.path().length() <= 1)
|| isTrashLink;
}
const bool isIntoTrash = (url.protocol() == "trash") && !isCurrentTrash; // trashed file, not trash:/ itself
const bool bIsLink = (m_itemFlags & KParts::BrowserExtension::IsLink);
//kDebug() << "isLocal=" << isLocal << " url=" << url << " isCurrentTrash=" << isCurrentTrash << " isIntoTrash=" << isIntoTrash << " bTrashIncluded=" << bTrashIncluded;
//////////////////////////////////////////////////////////////////////////
addGroup( "topactions" ); // used e.g. for ShowMenuBar. includes a separator at the end
KAction * act;
KAction *actNewWindow = 0;
#if 0 // TODO in the desktop code itself.
if (( flags & KParts::BrowserExtension::ShowProperties ) && isOnDesktop &&
!KAuthorized::authorizeKAction("editable_desktop_icons"))
{
flags &= ~KParts::BrowserExtension::ShowProperties; // remove flag
}
#endif
// Either 'newview' is in the actions we're given (probably in the tabhandling group)
// or we need to insert it ourselves (e.g. for the desktop).
// In the first case, actNewWindow must remain 0.
if ( ((kpf & KonqPopupMenu::ShowNewWindow) != 0) && sReading )
{
const QString openStr = i18n("&Open");
actNewWindow = new KAction(m_parentWidget /*for status tips*/);
m_ownActions.append(actNewWindow);
actNewWindow->setIcon( KIcon("window-new") );
actNewWindow->setText( openStr );
QObject::connect(actNewWindow, SIGNAL(triggered()), q, SLOT(slotPopupNewView()));
}
if ( isDirectory && sWriting && !isCurrentTrash ) // A dir, and we can create things into it
{
const bool mkdirRequested = m_itemFlags & KParts::BrowserExtension::ShowCreateDirectory;
if ( (currentDir || mkdirRequested) && m_pMenuNew ) // Current dir -> add the "new" menu
{
// As requested by KNewFileMenu :
m_pMenuNew->checkUpToDate();
m_pMenuNew->setPopupFiles(m_popupItemProperties.urlList());
q->addAction( m_pMenuNew );
q->addSeparator();
}
else if (mkdirRequested)
{
KAction *actNewDir = new KAction(m_parentWidget);
m_ownActions.append(actNewDir);
actNewDir->setIcon( KIcon("folder-new") );
actNewDir->setText( i18n( "Create &Folder..." ) );
QObject::connect(actNewDir, SIGNAL(triggered()), q, SLOT(slotPopupNewDir()));
q->addAction( actNewDir );
q->addSeparator();
}
} else if ( isIntoTrash ) {
// Trashed item, offer restoring
act = new KAction(m_parentWidget /*for status tips*/);
m_ownActions.append(act);
act->setText( i18n( "&Restore" ) );
act->setHelpText(i18n("Restores this file or directory, back to the location where it was deleted from initially"));
QObject::connect(act, SIGNAL(triggered()), q, SLOT(slotPopupRestoreTrashedItems()));
q->addAction(act);
}
if (m_itemFlags & KParts::BrowserExtension::ShowNavigationItems)
{
if (m_itemFlags & KParts::BrowserExtension::ShowUp)
addNamedAction( "go_up" );
addNamedAction( "go_back" );
addNamedAction( "go_forward" );
if (m_itemFlags & KParts::BrowserExtension::ShowReload)
addNamedAction( "reload" );
q->addSeparator();
}
if (!currentDir && isSymLink && !isSymLinkInSameDir) {
// #65151: offer to open the target's parent dir
act = new KAction(m_parentWidget);
m_ownActions.append(act);
act->setText(isDirectory ? i18n("Show Original Directory") : i18n("Show Original File"));
act->setHelpText(i18n("Opens a new file manager window showing the target of this link, in its parent directory."));
QObject::connect(act, SIGNAL(triggered()), q, SLOT(slotShowOriginalFile()));
q->addAction(act);
}
// "open in new window" is either provided by us, or by the tabhandling group
if (actNewWindow) {
q->addAction(actNewWindow);
q->addSeparator();
}
addGroup( "tabhandling" ); // includes a separator at the end
if (m_itemFlags & KParts::BrowserExtension::ShowUrlOperations) {
if ( !currentDir && sReading ) {
if ( sDeleting ) {
addNamedAction( "cut" );
}
addNamedAction( "copy" );
}
if ( isDirectory && sWriting ) {
if ( currentDir )
addNamedAction( "paste" );
else
addNamedAction( "pasteto" );
}
}
if ( isCurrentTrash )
{
act = new KAction(m_parentWidget);
m_ownActions.append(act);
act->setIcon( KIcon("trash-empty") );
act->setText( i18n( "&Empty Trash Bin" ) );
KConfig trashConfig( "trashrc", KConfig::SimpleConfig);
act->setEnabled( !trashConfig.group("Status").readEntry( "Empty", true ) );
QObject::connect(act, SIGNAL(triggered()), q, SLOT(slotPopupEmptyTrashBin()));
q->addAction(act);
}
if ( isCurrentTrash )
{
act = new KAction(m_parentWidget);
m_ownActions.append(act);
act->setIcon( KIcon("trash-empty") );
act->setText( i18n( "&Configure Trash Bin" ) );
QObject::connect(act, SIGNAL(triggered()), q, SLOT(slotConfigTrashBin()));
q->addAction(act);
}
// This is used by KHTML, see khtml_popupmenu.rc (copy, selectAll, searchProvider etc.)
// and by DolphinPart (rename, trash, delete)
addGroup( "editactions" );
if (m_itemFlags & KParts::BrowserExtension::ShowTextSelectionItems) {
// OK, we have to stop here.
// Anything else that is provided by the part
addGroup( "partactions" );
return;
}
if ( !isCurrentTrash && !isIntoTrash && (m_itemFlags & KParts::BrowserExtension::ShowBookmark))
{
QString caption;
if (currentDir)
{
const bool httpPage = m_sViewURL.protocol().startsWith("http", Qt::CaseInsensitive);
if (httpPage)
caption = i18n("&Bookmark This Page");
else
caption = i18n("&Bookmark This Location");
}
else if (isDirectory)
caption = i18n("&Bookmark This Folder");
else if (bIsLink)
caption = i18n("&Bookmark This Link");
else
caption = i18n("&Bookmark This File");
act = new KAction(m_parentWidget);
m_ownActions.append(act);
act->setObjectName( QLatin1String("bookmark_add" )); // for unittest
act->setIcon( KIcon("bookmark-new") );
act->setText( caption );
QObject::connect(act, SIGNAL(triggered()), q, SLOT(slotPopupAddToBookmark()));
if (lstItems.count() > 1)
act->setEnabled(false);
if (KAuthorized::authorizeKAction("bookmarks"))
q->addAction( act );
if (bIsLink)
addGroup( "linkactions" ); // see khtml
}
// "Open With" actions
m_menuActions.setItemListProperties(m_popupItemProperties);
if ( sReading ) {
m_menuActions.addOpenWithActionsTo(q, "DesktopEntryName != 'kfmclient' and DesktopEntryName != 'kfmclient_dir' and DesktopEntryName != 'kfmclient_html'");
QList<QAction *> previewActions = m_actionGroups.value("preview");
if (!previewActions.isEmpty()) {
if (previewActions.count() == 1) {
q->addAction(previewActions.first());
} else {
QMenu* subMenu = new QMenu(i18n("Preview In"), q);
subMenu->menuAction()->setObjectName( QLatin1String("preview_submenu" )); // for the unittest
q->addMenu(subMenu);
subMenu->addActions(previewActions);
}
}
}
// Second block, builtin + user
m_menuActions.addServiceActionsTo(q);
q->addSeparator();
// Use the Dolphin setting for showing the "Copy To" and "Move To" actions
KSharedConfig::Ptr dolphin = KSharedConfig::openConfig("dolphinrc");
// CopyTo/MoveTo menus
if (m_itemFlags & KParts::BrowserExtension::ShowUrlOperations &&
KConfigGroup(dolphin, "General").readEntry("ShowCopyMoveMenu", false)) {
m_copyToMenu.setItems(lstItems);
m_copyToMenu.setReadOnly(sMoving == false);
m_copyToMenu.addActionsTo(q);
q->addSeparator();
}
if (!isCurrentTrash && !isIntoTrash && sReading &&
(kpf & KonqPopupMenu::NoPlugins) == 0) {
addPlugins(); // now it's time to add plugins
}
if ( (m_itemFlags & KParts::BrowserExtension::ShowProperties) && KPropertiesDialog::canDisplay( lstItems ) ) {
act = new KAction(m_parentWidget);
m_ownActions.append(act);
act->setObjectName( QLatin1String("properties" )); // for unittest
act->setText( i18n( "&Properties" ) );
QObject::connect(act, SIGNAL(triggered()), q, SLOT(slotPopupProperties()));
q->addAction(act);
}
while ( !q->actions().isEmpty() &&
q->actions().last()->isSeparator() )
delete q->actions().last();
if ( isDirectory && isLocal ) {
if ( KFileShare::authorization() == KFileShare::Authorized ) {
q->addSeparator();
act = new KAction(m_parentWidget);
m_ownActions.append(act);
act->setText( i18n("Share") );
QObject::connect(act, SIGNAL(triggered()), q, SLOT(slotOpenShareFileDialog()));
q->addAction(act);
}
}
// Anything else that is provided by the part
addGroup( "partactions" );
}
/*
* Once upon a time...
*/
extern "C" Q_DECL_EXPORT int kdemain( int argc, char** argv )
{
// initpipe is used to keep the parent process around till the child
// has registered with dbus
#ifdef FORK_KSYSGUARD
int initpipe[ 2 ];
pipe( initpipe );
/* This forking will put ksysguard in it's own session not having a
* controlling terminal attached to it. This prevents ssh from
* using this terminal for password requests. Thus, you
* need a ssh with ssh-askpass support to popup an X dialog to
* enter the password. */
pid_t pid;
if ( ( pid = fork() ) < 0 )
return -1;
else
if ( pid != 0 ) {
close( initpipe[ 1 ] );
// wait till init is complete
char c;
while( read( initpipe[ 0 ], &c, 1 ) < 0 );
// then exit
close( initpipe[ 0 ] );
exit( 0 );
}
close( initpipe[ 0 ] );
setsid();
#endif
QApplication app(argc, argv);
KLocalizedString::setApplicationDomain("ksysguard");
KAboutData aboutData( QStringLiteral("ksysguard"), i18n( "System Monitor" ),
PROJECT_VERSION, i18n(Description), KAboutLicense::GPL,
i18n( "(c) 1996-2016 The KDE System Monitor Developers" ) );
aboutData.setOrganizationDomain(QByteArray("kde.org"));
aboutData.addAuthor( i18n("John Tapsell"), i18n("Current Maintainer"), QStringLiteral("*****@*****.**") );
aboutData.addAuthor( i18n("Chris Schlaeger"), i18n("Previous Maintainer"), QStringLiteral("*****@*****.**") );
aboutData.addAuthor( i18n("Greg Martyn"), QString(), QStringLiteral("*****@*****.**") );
aboutData.addAuthor( i18n("Tobias Koenig"), QString(), QStringLiteral("*****@*****.**") );
aboutData.addAuthor( i18n("Nicolas Leclercq"), QString(), QStringLiteral("*****@*****.**") );
aboutData.addAuthor( i18n("Alex Sanda"), QString(), QStringLiteral("*****@*****.**") );
aboutData.addAuthor( i18n("Bernd Johannes Wuebben"), QString(), QStringLiteral("*****@*****.**") );
aboutData.addAuthor( i18n("Ralf Mueller"), QString(), QStringLiteral("*****@*****.**") );
aboutData.addAuthor( i18n("Hamish Rodda"), QString(), QStringLiteral("*****@*****.**") );
aboutData.addAuthor( i18n("Torsten Kasch"), i18n( "Solaris Support\n"
"Parts derived (by permission) from the sunos5\n"
"module of William LeFebvre's \"top\" utility." ),
QStringLiteral("*****@*****.**") );
QCommandLineParser parser;
KAboutData::setApplicationData(aboutData);
parser.addVersionOption();
parser.addHelpOption();
parser.addPositionalArgument(QStringLiteral("[worksheet]"), i18n( "Optional worksheet files to load" ));
aboutData.setupCommandLine(&parser);
parser.process(app);
aboutData.processCommandLine(&parser);
app.setWindowIcon(QIcon::fromTheme(QStringLiteral("utilities-system-monitor")));
KSGRD::SensorMgr = new KSGRD::SensorManager();
KSGRD::Style = new KSGRD::StyleEngine();
#ifdef FORK_KSYSGUARD
char c = 0;
write( initpipe[ 1 ], &c, 1 );
close( initpipe[ 1 ] );
#endif
Toplevel = new TopLevel();
// create top-level widget
Toplevel->readProperties( KConfigGroup( KSharedConfig::openConfig(), "MainWindow" ) );
// setup the statusbar, toolbar etc.
// Note that this comes after creating the top-level widgets whcih also
// sets up the various QActions that the user may have added to the toolbar
Toplevel->initStatusBar();
//There seems to be some serious bugs with the session restore code. Disabling
// if ( app->isSessionRestored() )
// Toplevel->restore( 1 );
Toplevel->show();
KSGRD::SensorMgr->setBroadcaster( Toplevel ); // SensorMgr uses a QPointer for toplevel, so it is okay if Toplevel is deleted first
// register to DBus
const KDBusService dbusService(KDBusService::Multiple);
// run the application
int result = app.exec();
delete KSGRD::SensorMgr;
delete KSGRD::Style;
return result;
}
bool KNetAttach::validateCurrentPage()
{
if (currentPage() == _folderType){
_host->setFocus();
_connectionName->setFocus();
if (_webfolder->isChecked()) {
setInformationText("WebFolder");
updateForProtocol("WebFolder");
_port->setValue(80);
} else if (_fish->isChecked()) {
setInformationText("Fish");
updateForProtocol("Fish");
_port->setValue(22);
} else if (_ftp->isChecked()) {
setInformationText("FTP");
updateForProtocol("FTP");
_port->setValue(21);
if (_path->text().isEmpty()) {
_path->setText("/");
}
} else if (_smb->isChecked()) {
setInformationText("SMB");
updateForProtocol("SMB");
} else { //if (_recent->isChecked()) {
KConfig recent( "krecentconnections", KConfig::NoGlobals );
if (!recent.hasGroup(_recentConnectionName->currentText())) {
KConfigGroup group = recent.group("General");
QStringList idx = group.readEntry("Index",QStringList());
if (idx.isEmpty()) {
_recent->setEnabled(false);
if (_recent->isChecked()) {
_webfolder->setChecked(true);
}
} else {
_recent->setEnabled(true);
_recentConnectionName->addItems(idx);
}
return false;
}
KConfigGroup group = recent.group(_recentConnectionName->currentText());
_type = group.readEntry("Type");
setInformationText(_type);
if (!updateForProtocol(_type)) {
// FIXME: handle error
}
KUrl u(group.readEntry("URL"));
_host->setText(u.host());
_user->setText(u.user());
_path->setText(u.path());
if (group.hasKey("Port")) {
_port->setValue(group.readEntry("Port",0));
} else {
_port->setValue(u.port());
}
_connectionName->setText(_recentConnectionName->currentText());
_createIcon->setChecked(false);
}
updateParametersPageStatus();
}else{
button(BackButton)->setEnabled(false);
button(FinishButton)->setEnabled(false);
KUrl url;
if (_type == "WebFolder") {
if (_useEncryption->isChecked()) {
url.setProtocol("webdavs");
} else {
url.setProtocol("webdav");
}
url.setPort(_port->value());
} else if (_type == "Fish") {
KConfig config("kio_fishrc");
KConfigGroup cg(&config, _host->text().trimmed());
cg.writeEntry("Charset", KCharsets::charsets()->encodingForName(_encoding->currentText()));
url.setProtocol(_protocolText->currentText());
url.setPort(_port->value());
} else if (_type == "FTP") {
url.setProtocol("ftp");
url.setPort(_port->value());
KConfig config("kio_ftprc");
KConfigGroup cg(&config, _host->text().trimmed());
cg.writeEntry("Charset", KCharsets::charsets()->encodingForName(_encoding->currentText()));
config.sync();
} else if (_type == "SMB") {
url.setProtocol("smb");
} else { // recent
}
url.setHost(_host->text().trimmed());
url.setUser(_user->text().trimmed());
QString path = _path->text().trimmed();
#ifndef Q_WS_WIN
// could a relative path really be made absolute by simply prepending a '/' ?
if (!path.startsWith('/')) {
path = QString("/") + path;
}
#endif
url.setPath(path);
_folderParameters->setEnabled(false);
bool success = doConnectionTest(url);
_folderParameters->setEnabled(true);
if (!success) {
KMessageBox::sorry(this, i18n("Unable to connect to server. Please check your settings and try again."));
button(BackButton)->setEnabled(true);
return false;
}
KRun::runUrl(url, "inode/directory", this);
QString name = _connectionName->text().trimmed();
if (_createIcon->isChecked()) {
KGlobal::dirs()->addResourceType("remote_entries", "data", "remoteview");
QString path = KGlobal::dirs()->saveLocation("remote_entries");
path += name + ".desktop";
KConfig _desktopFile( path, KConfig::SimpleConfig );
KConfigGroup desktopFile(&_desktopFile, "Desktop Entry");
desktopFile.writeEntry("Icon", "folder-remote");
desktopFile.writeEntry("Name", name);
desktopFile.writeEntry("Type", "Link");
desktopFile.writeEntry("URL", url.prettyUrl());
desktopFile.writeEntry("Charset", url.fileEncoding());
desktopFile.sync();
org::kde::KDirNotify::emitFilesAdded( QUrl("remote:/") );
}
if (!name.isEmpty()) {
KConfig _recent("krecentconnections", KConfig::NoGlobals);
KConfigGroup recent(&_recent, "General");
QStringList idx = recent.readEntry("Index",QStringList());
_recent.deleteGroup(name); // erase anything stale
if (idx.contains(name)) {
idx.removeAll(name);
idx.prepend(name);
recent.writeEntry("Index", idx);
} else {
QString last;
if (!idx.isEmpty()) {
last = idx.last();
idx.pop_back();
}
idx.prepend(name);
_recent.deleteGroup(last);
recent.writeEntry("Index", idx);
}
recent = KConfigGroup(&_recent,name);
recent.writeEntry("URL", url.prettyUrl());
if (_type == "WebFolder" || _type == "Fish" || _type == "FTP") {
recent.writeEntry("Port", _port->value());
}
recent.writeEntry("Type", _type);
recent.sync();
}
}
return true;
}
KateMainWindow::KateMainWindow (KConfig *sconfig, const QString &sgroup)
: KateMDI::MainWindow (0)
{
setObjectName((QString("__KateMainWindow#%1").arg(uniqueID)).toLatin1());
// first the very important id
myID = uniqueID;
uniqueID++;
new KateMainWindowAdaptor( this );
m_dbusObjectPath = "/MainWindow/" + QString::number( myID );
QDBusConnection::sessionBus().registerObject( m_dbusObjectPath, this );
m_modignore = false;
// here we go, set some usable default sizes
if (!initialGeometrySet())
{
int scnum = QApplication::desktop()->screenNumber(parentWidget());
QRect desk = QApplication::desktop()->screenGeometry(scnum);
QSize size;
// try to load size
if (sconfig)
{
KConfigGroup cg( sconfig, sgroup );
size.setWidth (cg.readEntry( QString::fromLatin1("Width %1").arg(desk.width()), 0 ));
size.setHeight (cg.readEntry( QString::fromLatin1("Height %1").arg(desk.height()), 0 ));
}
// if thats fails, try to reuse size
if (size.isEmpty())
{
// first try to reuse size known from current or last created main window ;=)
if (KateApp::self()->mainWindows () > 0)
{
KateMainWindow *win = KateApp::self()->activeMainWindow ();
if (!win)
win = KateApp::self()->mainWindow (KateApp::self()->mainWindows () - 1);
size = win->size();
}
else // now fallback to hard defaults ;)
{
// first try global app config
KConfigGroup cg( KGlobal::config(), "MainWindow" );
size.setWidth (cg.readEntry( QString::fromLatin1("Width %1").arg(desk.width()), 0 ));
size.setHeight (cg.readEntry( QString::fromLatin1("Height %1").arg(desk.height()), 0 ));
if (size.isEmpty())
size = QSize (qMin (700, desk.width()), qMin(480, desk.height()));
}
resize (size);
}
}
// start session restore if needed
startRestore (sconfig, sgroup);
m_mainWindow = new Kate::MainWindow (this);
// setup most important actions first, needed by setupMainWindow
setupImportantActions ();
// setup the most important widgets
setupMainWindow();
// setup the actions
setupActions();
setStandardToolBarMenuEnabled( true );
setXMLFile( "kateui.rc" );
createShellGUI ( true );
//kDebug() << "****************************************************************************" << sconfig;
// register mainwindow in app
KateApp::self()->addMainWindow (this);
// enable plugin guis
KatePluginManager::self()->enableAllPluginsGUI (this, sconfig);
// caption update
for (uint i = 0; i < KateDocManager::self()->documents(); i++)
slotDocumentCreated (KateDocManager::self()->document(i));
connect(KateDocManager::self(), SIGNAL(documentCreated(KTextEditor::Document*)), this, SLOT(slotDocumentCreated(KTextEditor::Document*)));
readOptions();
if (sconfig)
m_viewManager->restoreViewConfiguration (KConfigGroup(sconfig, sgroup) );
finishRestore ();
fileOpenRecent->loadEntries( KConfigGroup(sconfig, "Recent Files" ) );
setAcceptDrops(true);
connect(KateSessionManager::self(), SIGNAL(sessionChanged()), this, SLOT(updateCaption()));
connect(this,SIGNAL(sigShowPluginConfigPage(Kate::PluginConfigPageInterface *,uint)),this,SLOT(showPluginConfigPage(Kate::PluginConfigPageInterface *,uint)));
}
View::View(QWindow *)
: PlasmaQuick::Dialog(),
m_offset(.5),
m_floating(false)
{
setClearBeforeRendering(true);
setColor(QColor(Qt::transparent));
setFlags(Qt::FramelessWindowHint);
KCrash::setFlags(KCrash::AutoRestart);
m_config = KConfigGroup(KSharedConfig::openConfig(QStringLiteral("krunnerrc")), "General");
setFreeFloating(m_config.readEntry("FreeFloating", false));
reloadConfig();
new AppAdaptor(this);
QDBusConnection::sessionBus().registerObject(QStringLiteral("/App"), this);
if (KAuthorized::authorize(QStringLiteral("run_command"))) {
QAction *a = new QAction(0);
QObject::connect(a, &QAction::triggered, this, &View::displayOrHide);
a->setText(i18n("Run Command"));
a->setObjectName(QStringLiteral("run command"));
KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << QKeySequence(Qt::ALT + Qt::Key_Space), KGlobalAccel::NoAutoloading);
KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << QKeySequence(Qt::ALT + Qt::Key_Space) << QKeySequence(Qt::ALT + Qt::Key_F2) << Qt::Key_Search);
a = new QAction(0);
QObject::connect(a, &QAction::triggered, this, &View::displayWithClipboardContents);
a->setText(i18n("Run Command on clipboard contents"));
a->setObjectName(QStringLiteral("run command on clipboard contents"));
KGlobalAccel::self()->setDefaultShortcut(a, QList<QKeySequence>() << QKeySequence(Qt::ALT+Qt::SHIFT+Qt::Key_F2));
KGlobalAccel::self()->setShortcut(a, QList<QKeySequence>() << QKeySequence(Qt::ALT+Qt::SHIFT+Qt::Key_F2));
}
m_qmlObj = new KDeclarative::QmlObject(this);
m_qmlObj->setInitializationDelayed(true);
connect(m_qmlObj, &KDeclarative::QmlObject::finished, this, &View::objectIncubated);
KPackage::Package package = KPackage::PackageLoader::self()->loadPackage(QStringLiteral("Plasma/LookAndFeel"));
KConfigGroup cg(KSharedConfig::openConfig(QStringLiteral("kdeglobals")), "KDE");
const QString packageName = cg.readEntry("LookAndFeelPackage", QString());
if (!packageName.isEmpty()) {
package.setPath(packageName);
}
m_qmlObj->setSource(QUrl::fromLocalFile(package.filePath("runcommandmainscript")));
m_qmlObj->engine()->rootContext()->setContextProperty(QStringLiteral("runnerWindow"), this);
m_qmlObj->completeInitialization();
auto screenRemoved = [=](QScreen* screen) {
if (screen == this->screen()) {
setScreen(qGuiApp->primaryScreen());
hide();
}
};
auto screenAdded = [=](QScreen* screen) {
connect(screen, &QScreen::geometryChanged, this, &View::screenGeometryChanged);
screenGeometryChanged();
};
foreach(QScreen* s, QGuiApplication::screens())
screenAdded(s);
connect(qApp, &QGuiApplication::screenAdded, this, screenAdded);
connect(qApp, &QGuiApplication::screenRemoved, this, screenRemoved);
connect(KWindowSystem::self(), &KWindowSystem::workAreaChanged, this, &View::resetScreenPos);
connect(this, &View::visibleChanged, this, &View::resetScreenPos);
KDirWatch::self()->addFile(m_config.name());
// Catch both, direct changes to the config file ...
connect(KDirWatch::self(), &KDirWatch::dirty, this, &View::reloadConfig);
connect(KDirWatch::self(), &KDirWatch::created, this, &View::reloadConfig);
if (m_qmlObj->rootObject()) {
connect(m_qmlObj->rootObject(), SIGNAL(widthChanged()), this, SLOT(resetScreenPos()));
}
if (m_floating) {
setLocation(Plasma::Types::Floating);
} else {
setLocation(Plasma::Types::TopEdge);
}
connect(qGuiApp, &QGuiApplication::focusWindowChanged, this, &View::slotFocusWindowChanged);
}
int PlasmaApp::newInstance()
{
KCmdLineArgs* args = KCmdLineArgs::parsedArgs();
if (args->count() == 0) {
KCmdLineArgs::usage();
return 0;
}
QString pluginName;
if (args->count() > 0) {
pluginName = args->arg(0);
}
//is the applet already running?
if (m_viewForPlugin.contains(pluginName)) {
m_viewForPlugin.value(pluginName)->activateWindow();
m_viewForPlugin.value(pluginName)->raise();
return 0;
}
QVariantList appletArgs;
for (int i = 1; i < args->count(); ++i) {
appletArgs << args->arg(i);
}
int appletId;
Plasma::Containment *containment = m_corona->addContainment("null");
containment->setFormFactor(Plasma::Planar);
containment->setLocation(Plasma::Floating);
appletId = ++m_maxId;
if (m_storedApplets.contains(pluginName)) {
int storedAppletId = m_storedApplets.values(pluginName).first();
KConfigGroup config = storedConfig(storedAppletId);
KConfigGroup actualConfig(containment->config());
actualConfig = KConfigGroup(&actualConfig, "Applets");
actualConfig = KConfigGroup(&actualConfig, QString::number(appletId));
config.copyTo(&actualConfig);
config.deleteGroup();
m_storedApplets.remove(pluginName, storedAppletId);
}
SingleView *view = new SingleView(m_corona, containment, pluginName, appletId, appletArgs);
if (!view->applet()) {
delete view;
return 0;
}
connect(view, SIGNAL(storeApplet(Plasma::Applet*)), this, SLOT(storeApplet(Plasma::Applet*)));
connect(view, SIGNAL(destroyed(QObject*)), this, SLOT(viewDestroyed(QObject*)));
if (args->isSet("border")) {
view->setBackgroundBrush(KColorUtils::mix(Plasma::Theme::defaultTheme()->color(Plasma::Theme::BackgroundColor), Plasma::Theme::defaultTheme()->color(Plasma::Theme::TextColor), 0.15));
connect(Plasma::Theme::defaultTheme(), SIGNAL(themeChanged()), SLOT(themeChanged()));
view->applet()->setBackgroundHints(Plasma::Applet::NoBackground);
} else {
view->setWindowFlags(Qt::FramelessWindowHint);
view->setAttribute(Qt::WA_TranslucentBackground);
view->setAutoFillBackground(false);
view->viewport()->setAutoFillBackground(false);
view->setAttribute(Qt::WA_NoSystemBackground);
view->viewport()->setAttribute(Qt::WA_NoSystemBackground);
Plasma::WindowEffects::overrideShadow(view->winId(), true);
}
if (args->isSet("fullscreen")) {
view->setWindowState(Qt::WindowFullScreen);
}
args->clear();
m_viewForPlugin[pluginName] = view;
m_pluginForView[view] = pluginName;
KWindowSystem::setOnDesktop(view->winId(), KWindowSystem::currentDesktop());
view->show();
view->raise();
return 0;
}
void K3bIsoImageWritingDialog::slotStartClicked()
{
if( !d->isIsoImage ) {
if( KMessageBox::warningContinueCancel( this,
i18n("The image you selected is not a valid ISO9660 image. "
"Are you sure you want to burn it anyway? "
"(There may exist other valid image types that are not detected by K3b but "
"will work fine.)"), i18n("Burn") ) == KMessageBox::Cancel )
return;
}
K3bIso9660 isoFs( imagePath() );
if( isoFs.open() ) {
if( K3b::imageFilesize( KURL::fromPathOrURL( imagePath() ) ) < (KIO::filesize_t)(isoFs.primaryDescriptor().volumeSpaceSize*2048) ) {
if( KMessageBox::questionYesNo( this,
i18n("<p>This image has an invalid file size."
"If it has been downloaded make sure the download is complete."
"<p>Only continue if you know what you are doing."),
i18n("Warning"),
i18n("Continue"),
i18n("Cancel") ) == KMessageBox::No )
return;
}
}
m_md5Job->cancel();
// save the path
KConfig* c = k3bcore->config();
c->setGroup( configGroup() );
if( c->readPathEntry( "last written image" ).isEmpty() )
c->writePathEntry( "last written image", imagePath() );
// create a progresswidget
K3bBurnProgressDialog dlg( kapp->mainWidget(), "burnProgress", true );
// create the job
K3bIso9660ImageWritingJob* job = new K3bIso9660ImageWritingJob( &dlg );
job->setBurnDevice( m_writerSelectionWidget->writerDevice() );
job->setSpeed( m_writerSelectionWidget->writerSpeed() );
job->setSimulate( m_checkDummy->isChecked() );
job->setWritingMode( m_writingModeWidget->writingMode() );
job->setVerifyData( m_checkVerify->isChecked() );
job->setCopies( m_checkDummy->isChecked() ? 1 : m_spinCopies->value() );
job->setImagePath( imagePath() );
// HACK (needed since if the medium is forced the stupid K3bIso9660ImageWritingJob defaults to cd writing)
job->setWritingApp( K3b::GROWISOFS );
if( !exitLoopOnHide() )
hide();
dlg.startJob( job );
delete job;
if( KConfigGroup( k3bcore->config(), "General Options" ).readBoolEntry( "keep action dialogs open", false ) &&
!exitLoopOnHide() )
show();
else
close();
}
KConfigGroup KHangMan::config(const QString &group)
{
return KConfigGroup(KSharedConfig::openConfig(qApp->applicationName() + "rc"), group);
}
