diff options
author | Timothy Pearson <kb9vqf@pearsoncomputing.net> | 2011-11-06 15:56:40 -0600 |
---|---|---|
committer | Timothy Pearson <kb9vqf@pearsoncomputing.net> | 2011-11-06 15:56:40 -0600 |
commit | e16866e072f94410321d70daedbcb855ea878cac (patch) | |
tree | ee3f52eabde7da1a0e6ca845fb9c2813cf1558cf /tdeprint/management/kxmlcommanddlg.cpp | |
parent | a58c20c1a7593631a1b50213c805507ebc16adaf (diff) | |
download | tdelibs-e16866e072f94410321d70daedbcb855ea878cac.tar.gz tdelibs-e16866e072f94410321d70daedbcb855ea878cac.zip |
Actually move the kde files that were renamed in the last commit
Diffstat (limited to 'tdeprint/management/kxmlcommanddlg.cpp')
-rw-r--r-- | tdeprint/management/kxmlcommanddlg.cpp | 1059 |
1 files changed, 1059 insertions, 0 deletions
diff --git a/tdeprint/management/kxmlcommanddlg.cpp b/tdeprint/management/kxmlcommanddlg.cpp new file mode 100644 index 000000000..3b42b71d7 --- /dev/null +++ b/tdeprint/management/kxmlcommanddlg.cpp @@ -0,0 +1,1059 @@ +/* + * This file is part of the KDE libraries + * Copyright (c) 2001 Michael Goffioul <tdeprint@swing.be> + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library General Public + * License version 2 as published by the Free Software Foundation. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public License + * along with this library; see the file COPYING.LIB. If not, write to + * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, + * Boston, MA 02110-1301, USA. + **/ + +#include "kxmlcommanddlg.h" +#include "driver.h" +#include "kxmlcommand.h" + +#include <tqlayout.h> +#include <tqheader.h> +#include <tqlabel.h> +#include <tqlineedit.h> +#include <tqcombobox.h> +#include <tqgroupbox.h> +#include <tqwidgetstack.h> +#include <tqtoolbutton.h> +#include <kpushbutton.h> +#include <tqtooltip.h> +#include <tqcheckbox.h> +#include <ktextedit.h> +#include <tqregexp.h> +#include <tqwhatsthis.h> +#include <tqapplication.h> + +#include <klistview.h> +#include <klocale.h> +#include <kiconloader.h> +#include <kdialogbase.h> +#include <kseparator.h> +#include <klistbox.h> +#include <kmimetype.h> +#include <kmessagebox.h> +#include <kapplication.h> +#include <kdebug.h> +#include <kguiitem.h> + +TQString generateId(const TQMap<TQString, DrBase*>& map) +{ + int index(-1); + while (map.contains(TQString::tqfromLatin1("item%1").arg(++index))) ; + return TQString::tqfromLatin1("item%1").arg(index); +} + +TQListViewItem* findPrev(TQListViewItem *item) +{ + TQListViewItem *prev = item->itemAbove(); + while (prev && prev->depth() > item->depth()) + prev = prev->itemAbove(); + if (prev && prev->depth() == item->depth()) + return prev; + else + return 0; +} + +TQListViewItem* findNext(TQListViewItem *item) +{ + TQListViewItem *next = item->itemBelow(); + while (next && next->depth() > item->depth()) + next = next->itemBelow(); + if (next && next->depth() == item->depth()) + return next; + else + return 0; +} + +KXmlCommandAdvancedDlg::KXmlCommandAdvancedDlg(TQWidget *parent, const char *name) +: TQWidget(parent, name) +{ + m_xmlcmd = 0; + + m_command = new TQLineEdit(this); + m_view = new KListView(this); + m_view->addColumn(""); + m_view->header()->hide(); + m_view->setSorting(-1); + m_apply = new TQToolButton(this); + m_apply->setIconSet( TQApplication::reverseLayout()? SmallIconSet( "forward" ) : SmallIconSet("back")); + m_addgrp = new TQToolButton(this); + m_addgrp->setIconSet(SmallIconSet("folder")); + m_addopt = new TQToolButton(this); + m_addopt->setIconSet(SmallIconSet("document")); + m_delopt = new TQToolButton(this); + m_delopt->setIconSet(SmallIconSet("editdelete")); + m_up = new TQToolButton(this); + m_up->setIconSet(SmallIconSet("up")); + m_down = new TQToolButton(this); + m_down->setIconSet(SmallIconSet("down")); + m_dummy = new TQWidget(this); + m_desc = new TQLineEdit(m_dummy); + m_name = new TQLineEdit(m_dummy); + m_type = new TQComboBox(m_dummy); + m_type->insertItem(i18n("String")); + m_type->insertItem(i18n("Integer")); + m_type->insertItem(i18n("Float")); + m_type->insertItem(i18n("List")); + m_type->insertItem(i18n("Boolean")); + m_format = new TQLineEdit(m_dummy); + m_default = new TQLineEdit(m_dummy); + TQLabel *m_namelab = new TQLabel(i18n("&Name:"), m_dummy); + TQLabel *m_desclab = new TQLabel(i18n("&Description:"), m_dummy); + TQLabel *m_formatlab = new TQLabel(i18n("&Format:"), m_dummy); + TQLabel *m_typelab = new TQLabel(i18n("&Type:"), m_dummy); + TQLabel *m_defaultlab = new TQLabel(i18n("Default &value:"), m_dummy); + TQLabel *m_commandlab = new TQLabel(i18n("Co&mmand:"), this); + m_namelab->setBuddy(m_name); + m_desclab->setBuddy(m_desc); + m_formatlab->setBuddy(m_format); + m_typelab->setBuddy(m_type); + m_defaultlab->setBuddy(m_default); + m_commandlab->setBuddy(m_command); + m_persistent = new TQCheckBox( i18n( "&Persistent option" ), m_dummy ); + + TQGroupBox *gb = new TQGroupBox(0, Qt::Horizontal, i18n("Va&lues"), m_dummy); + m_stack = new TQWidgetStack(gb); + TQWidget *w1 = new TQWidget(m_stack), *w2 = new TQWidget(m_stack), *w3 = new TQWidget(m_stack); + m_stack->addWidget(w1, 1); + m_stack->addWidget(w2, 2); + m_stack->addWidget(w3, 3); + m_edit1 = new TQLineEdit(w1); + m_edit2 = new TQLineEdit(w1); + TQLabel *m_editlab1 = new TQLabel(i18n("Minimum v&alue:"), w1); + TQLabel *m_editlab2 = new TQLabel(i18n("Ma&ximum value:"), w1); + m_editlab1->setBuddy(m_edit1); + m_editlab2->setBuddy(m_edit2); + m_values = new KListView(w2); + m_values->addColumn(i18n("Name")); + m_values->addColumn(i18n("Description")); + m_values->setAllColumnsShowFocus(true); + m_values->setSorting(-1); + m_values->setMaximumHeight(110); + m_addval = new TQToolButton(w2); + m_addval->setIconSet(SmallIconSet("editcopy")); + m_delval = new TQToolButton(w2); + m_delval->setIconSet(SmallIconSet("editdelete")); + TQToolTip::add(m_addval, i18n("Add value")); + TQToolTip::add(m_delval, i18n("Delete value")); + + TQToolTip::add(m_apply, i18n("Apply changes")); + TQToolTip::add(m_addgrp, i18n("Add group")); + TQToolTip::add(m_addopt, i18n("Add option")); + TQToolTip::add(m_delopt, i18n("Delete item")); + TQToolTip::add(m_up, i18n("Move up")); + TQToolTip::add(m_down, i18n("Move down")); + + KSeparator *sep1 = new KSeparator(KSeparator::HLine, m_dummy); + + TQGroupBox *gb_input = new TQGroupBox(0, Qt::Horizontal, i18n("&Input From"), this); + TQGroupBox *gb_output = new TQGroupBox(0, Qt::Horizontal, i18n("O&utput To"), this); + TQLabel *m_inputfilelab = new TQLabel(i18n("File:"), gb_input); + TQLabel *m_inputpipelab = new TQLabel(i18n("Pipe:"), gb_input); + TQLabel *m_outputfilelab = new TQLabel(i18n("File:"), gb_output); + TQLabel *m_outputpipelab = new TQLabel(i18n("Pipe:"), gb_output); + m_inputfile = new TQLineEdit(gb_input); + m_inputpipe = new TQLineEdit(gb_input); + m_outputfile = new TQLineEdit(gb_output); + m_outputpipe = new TQLineEdit(gb_output); + + m_comment = new KTextEdit( this ); + m_comment->setTextFormat(TQt::RichText ); + m_comment->setReadOnly(true); + TQLabel *m_commentlab = new TQLabel( i18n( "Comment:" ), this ); + + TQVBoxLayout *l2 = new TQVBoxLayout(this, 0, KDialog::spacingHint()); + TQHBoxLayout *l3 = new TQHBoxLayout(0, 0, KDialog::spacingHint()); + TQVBoxLayout *l7 = new TQVBoxLayout(0, 0, 0); + l2->addLayout(l3, 0); + l3->addWidget(m_commandlab); + l3->addWidget(m_command); + TQHBoxLayout *l0 = new TQHBoxLayout(0, 0, KDialog::spacingHint()); + TQGridLayout *l10 = new TQGridLayout(0, 2, 2, 0, KDialog::spacingHint()); + l2->addLayout(l0, 1); + l0->addLayout(TQT_TQLAYOUT(l10)); + l10->addMultiCellWidget(m_view, 0, 0, 0, 1); + l10->addWidget(gb_input, 1, 0); + l10->addWidget(gb_output, 1, 1); + l10->setRowStretch(0, 1); + l0->addLayout(l7); + l7->addWidget(m_apply); + l7->addSpacing(5); + l7->addWidget(m_addgrp); + l7->addWidget(m_addopt); + l7->addWidget(m_delopt); + l7->addSpacing(5); + l7->addWidget(m_up); + l7->addWidget(m_down); + l7->addStretch(1); + l0->addWidget(m_dummy, 1); + TQGridLayout *l1 = new TQGridLayout(m_dummy, 9, 2, 0, KDialog::spacingHint()); + l1->addWidget(m_desclab, 0, 0, Qt::AlignRight|Qt::AlignVCenter); + l1->addWidget(m_desc, 0, 1); + l1->addMultiCellWidget(sep1, 1, 1, 0, 1); + l1->addWidget(m_namelab, 2, 0, Qt::AlignRight|Qt::AlignVCenter); + l1->addWidget(m_name, 2, 1); + l1->addWidget(m_typelab, 3, 0, Qt::AlignRight|Qt::AlignVCenter); + l1->addWidget(m_type, 3, 1); + l1->addWidget(m_formatlab, 4, 0, Qt::AlignRight|Qt::AlignVCenter); + l1->addWidget(m_format, 4, 1); + l1->addWidget(m_defaultlab, 5, 0, Qt::AlignRight|Qt::AlignVCenter); + l1->addWidget(m_default, 5, 1); + l1->addWidget( m_persistent, 6, 1 ); + l1->addMultiCellWidget(gb, 7, 7, 0, 1); + l1->setRowStretch(8, 1); + + TQHBoxLayout *l4 = new TQHBoxLayout(w2, 0, KDialog::spacingHint()); + l4->addWidget(m_values); + TQVBoxLayout *l6 = new TQVBoxLayout(0, 0, 0); + l4->addLayout(l6); + l6->addWidget(m_addval); + l6->addWidget(m_delval); + l6->addStretch(1); + TQGridLayout *l5 = new TQGridLayout(w1, 3, 2, 0, KDialog::spacingHint()); + l5->setRowStretch(2, 1); + l5->addWidget(m_editlab1, 0, 0, Qt::AlignRight|Qt::AlignVCenter); + l5->addWidget(m_editlab2, 1, 0, Qt::AlignRight|Qt::AlignVCenter); + l5->addWidget(m_edit1, 0, 1); + l5->addWidget(m_edit2, 1, 1); + + TQGridLayout *l8 = new TQGridLayout(gb_input->tqlayout(), 2, 2, + KDialog::spacingHint()); + TQGridLayout *l9 = new TQGridLayout(gb_output->tqlayout(), 2, 2, + KDialog::spacingHint()); + l8->addWidget(m_inputfilelab, 0, 0); + l8->addWidget(m_inputpipelab, 1, 0); + l8->addWidget(m_inputfile, 0, 1); + l8->addWidget(m_inputpipe, 1, 1); + l9->addWidget(m_outputfilelab, 0, 0); + l9->addWidget(m_outputpipelab, 1, 0); + l9->addWidget(m_outputfile, 0, 1); + l9->addWidget(m_outputpipe, 1, 1); + + TQVBoxLayout *l11 = new TQVBoxLayout(TQT_TQLAYOUT(gb->tqlayout())); + l11->addWidget(m_stack); + + TQVBoxLayout *l12 = new TQVBoxLayout( 0, 0, 0 ); + l2->addSpacing( 10 ); + l2->addLayout( l12 ); + l12->addWidget( m_commentlab ); + l12->addWidget( m_comment ); + + connect(m_view, TQT_SIGNAL(selectionChanged(TQListViewItem*)), TQT_SLOT(slotSelectionChanged(TQListViewItem*))); + connect(m_values, TQT_SIGNAL(selectionChanged(TQListViewItem*)), TQT_SLOT(slotValueSelected(TQListViewItem*))); + connect(m_type, TQT_SIGNAL(activated(int)), TQT_SLOT(slotTypeChanged(int))); + connect(m_addval, TQT_SIGNAL(clicked()), TQT_SLOT(slotAddValue())); + connect(m_delval, TQT_SIGNAL(clicked()), TQT_SLOT(slotRemoveValue())); + connect(m_apply, TQT_SIGNAL(clicked()), TQT_SLOT(slotApplyChanges())); + connect(m_addgrp, TQT_SIGNAL(clicked()), TQT_SLOT(slotAddGroup())); + connect(m_addopt, TQT_SIGNAL(clicked()), TQT_SLOT(slotAddOption())); + connect(m_delopt, TQT_SIGNAL(clicked()), TQT_SLOT(slotRemoveItem())); + connect(m_up, TQT_SIGNAL(clicked()), TQT_SLOT(slotMoveUp())); + connect(m_down, TQT_SIGNAL(clicked()), TQT_SLOT(slotMoveDown())); + connect(m_command, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotCommandChanged(const TQString&))); + connect(m_view, TQT_SIGNAL(itemRenamed(TQListViewItem*,int)), TQT_SLOT(slotOptionRenamed(TQListViewItem*,int))); + connect(m_desc, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotChanged())); + connect(m_name, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotChanged())); + connect(m_format, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotChanged())); + connect(m_default, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotChanged())); + connect(m_edit1, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotChanged())); + connect(m_edit2, TQT_SIGNAL(textChanged(const TQString&)), TQT_SLOT(slotChanged())); + connect(m_type, TQT_SIGNAL(activated(int)), TQT_SLOT(slotChanged())); + connect(m_addval, TQT_SIGNAL(clicked()), TQT_SLOT(slotChanged())); + connect(m_delval, TQT_SIGNAL(clicked()), TQT_SLOT(slotChanged())); + connect( m_persistent, TQT_SIGNAL( toggled(bool) ), TQT_SLOT( slotChanged() ) ); + m_dummy->setEnabled(false); + viewItem(0); + + /** + * Add some short help for the normal (non expert) user + */ + TQWhatsThis::add( m_name, i18n( + "An identification string. Use only alphanumeric characters except spaces. " + "The string <b>__root__</b> is reserved for internal use." ) ); + TQWhatsThis::add( m_namelab, TQWhatsThis::textFor( m_name ) ); + TQWhatsThis::add( m_desc, i18n( + "A description string. This string is shown in the interface, and should " + "be explicit enough about the role of the corresponding option." ) ); + TQWhatsThis::add( m_desclab, TQWhatsThis::textFor( m_desc ) ); + TQWhatsThis::add( m_type, i18n( + "The type of the option. This determines how the option is presented " + "graphically to the user." ) ); + TQWhatsThis::add( m_typelab, TQWhatsThis::textFor( m_type ) ); + TQWhatsThis::add( m_format, i18n( + "The format of the option. This determines how the option is formatted " + "for inclusion in the global command line. The tag <b>%value</b> can be used " + "to represent the user selection. This tag will be replaced at run-time by a " + "string representation of the option value." ) ); + TQWhatsThis::add( m_formatlab, TQWhatsThis::textFor( m_format ) ); + TQWhatsThis::add( m_default, i18n( + "The default value of the option. For non persistent options, nothing is " + "added to the command line if the option has that default value. If this " + "value does not correspond to the actual default value of the underlying " + "utility, make the option persistent to avoid unwanted effects." ) ); + TQWhatsThis::add( m_defaultlab, TQWhatsThis::textFor( m_default ) ); + TQWhatsThis::add( m_persistent, i18n( + "Make the option persistent. A persistent option is always written to the " + "command line, whatever its value. This is useful when the chosen default " + "value does not match with the actual default value of the underlying utility." ) ); + TQWhatsThis::add( m_command, i18n( + "The full command line to execute the associated underlying utility. This " + "command line is based on a mechanism of tags that are replaced at run-time. " + "The supported tags are:<ul>" + "<li><b>%filterargs</b>: command options</li>" + "<li><b>%filterinput</b>: input specification</li>" + "<li><b>%filteroutput</b>: output specification</li>" + "<li><b>%psu</b>: the page size in upper case</li>" + "<li><b>%psl</b>: the page size in lower case</li></ul>" ) ); + TQWhatsThis::add( m_commandlab, TQWhatsThis::textFor( m_command ) ); + TQWhatsThis::add( m_inputfile, i18n( + "Input specification when the underlying utility reads input data from a file. Use " + "the tag <b>%in</b> to represent the input filename." ) ); + TQWhatsThis::add( m_inputfilelab, TQWhatsThis::textFor( m_inputfile ) ); + TQWhatsThis::add( m_outputfile, i18n( + "Output specification when the underlying utility writes output data to a file. Use " + "the tag <b>%out</b> to represent the output filename." ) ); + TQWhatsThis::add( m_outputfilelab, TQWhatsThis::textFor( m_outputfile ) ); + TQWhatsThis::add( m_inputpipe, i18n( + "Input specification when the underlying utility reads input data from its " + "standard input." ) ); + TQWhatsThis::add( m_inputpipelab, TQWhatsThis::textFor( m_inputpipe ) ); + TQWhatsThis::add( m_outputpipe, i18n( + "Output specification when the underlying utility writes output data to its " + "standard output." ) ); + TQWhatsThis::add( m_outputpipelab, TQWhatsThis::textFor( m_outputpipe ) ); + TQWhatsThis::add( m_comment, i18n( + "A comment about the underlying utility, which can be viewed by the user " + "from the interface. This comment string supports basic HTML tags like " + "<a>, <b> or <i>." ) ); + TQWhatsThis::add( m_commentlab, TQWhatsThis::textFor( m_comment ) ); + + resize(660, 200); +} + +KXmlCommandAdvancedDlg::~KXmlCommandAdvancedDlg() +{ + if (m_opts.count() > 0) + { + kdDebug() << "KXmlCommandAdvancedDlg: " << m_opts.count() << " items remaining" << endl; + for (TQMap<TQString,DrBase*>::ConstIterator it=m_opts.begin(); it!=m_opts.end(); ++it) + { + //kdDebug() << "Item: name=" << (*it)->name() << endl; + delete (*it); + } + } +} + +void KXmlCommandAdvancedDlg::setCommand(KXmlCommand *xmlcmd) +{ + m_xmlcmd = xmlcmd; + if (m_xmlcmd) + parseXmlCommand(m_xmlcmd); +} + +void KXmlCommandAdvancedDlg::parseXmlCommand(KXmlCommand *xmlcmd) +{ + m_view->clear(); + TQListViewItem *root = new TQListViewItem(m_view, xmlcmd->name(), xmlcmd->name()); + DrMain *driver = xmlcmd->driver(); + + root->setPixmap(0, SmallIcon("fileprint")); + root->setOpen(true); + if (driver) + { + DrMain *clone = driver->cloneDriver(); + if (!clone->get("text").isEmpty()) + root->setText(0, clone->get("text")); + root->setText(1, "__root__"); + clone->setName("__root__"); + m_opts["__root__"] = clone; + parseGroupItem(clone, root); + clone->flatten(); + } + m_command->setText(xmlcmd->command()); + m_inputfile->setText(xmlcmd->io(true, false)); + m_inputpipe->setText(xmlcmd->io(true, true)); + m_outputfile->setText(xmlcmd->io(false, false)); + m_outputpipe->setText(xmlcmd->io(false, true)); + m_comment->setText( xmlcmd->comment() ); + + viewItem(0); +} + +void KXmlCommandAdvancedDlg::parseGroupItem(DrGroup *grp, TQListViewItem *parent) +{ + TQListViewItem *item(0); + + TQPtrListIterator<DrGroup> git(grp->groups()); + for (; git.current(); ++git) + { + TQString namestr = git.current()->name(); + if (namestr.isEmpty()) + { + namestr = "group_"+kapp->randomString(4); + } + git.current()->setName(namestr); + item = new TQListViewItem(parent, item, git.current()->get("text"), git.current()->name()); + item->setPixmap(0, SmallIcon("folder")); + item->setOpen(true); + item->setRenameEnabled(0, true); + parseGroupItem(git.current(), item); + m_opts[namestr] = git.current(); + } + + TQPtrListIterator<DrBase> oit(grp->options()); + for (; oit.current(); ++oit) + { + TQString namestr = oit.current()->name().mid(m_xmlcmd->name().length()+6); + if (namestr.isEmpty()) + { + namestr = "option_"+kapp->randomString(4); + } + oit.current()->setName(namestr); + item = new TQListViewItem(parent, item, oit.current()->get("text"), namestr); + item->setPixmap(0, SmallIcon("document")); + item->setRenameEnabled(0, true); + m_opts[namestr] = oit.current(); + } +} + +void KXmlCommandAdvancedDlg::slotSelectionChanged(TQListViewItem *item) +{ + if (item && item->depth() == 0) + item = 0; + viewItem(item); +} + +void KXmlCommandAdvancedDlg::viewItem(TQListViewItem *item) +{ + m_dummy->setEnabled((item != 0)); + m_name->setText(""); + m_desc->setText(""); + m_format->setText(""); + m_default->setText(""); + m_values->clear(); + m_edit1->setText(""); + m_edit2->setText(""); + m_persistent->setChecked( false ); + int typeId(-1); + if (item) + { + m_name->setText(item->text(1)); + m_desc->setText(item->text(0)); + + DrBase *opt = (m_opts.contains(item->text(1)) ? m_opts[item->text(1)] : 0); + if (opt) + { + bool isgroup = (opt->type() < DrBase::String); + if (!isgroup) + { + m_type->setCurrentItem(opt->type() - DrBase::String); + typeId = m_type->currentItem(); + m_format->setText(opt->get("format")); + m_default->setText(opt->get("default")); + } + m_type->setEnabled(!isgroup); + m_default->setEnabled(!isgroup); + m_format->setEnabled(!isgroup); + m_stack->setEnabled(!isgroup); + + switch (opt->type()) + { + case DrBase::Float: + case DrBase::Integer: + m_edit1->setText(opt->get("minval")); + m_edit2->setText(opt->get("maxval")); + break; + case DrBase::Boolean: + case DrBase::List: + { + TQPtrListIterator<DrBase> it(*(static_cast<DrListOption*>(opt)->choices())); + TQListViewItem *item(0); + for (; it.current(); ++it) + { + item = new TQListViewItem(m_values, item, it.current()->name(), it.current()->get("text")); + item->setRenameEnabled(0, true); + item->setRenameEnabled(1, true); + } + break; + } + default: + break; + } + + m_addgrp->setEnabled(isgroup); + m_addopt->setEnabled(isgroup); + + TQListViewItem *prevItem = findPrev(item), *nextItem = findNext(item); + DrBase *prevOpt = (prevItem && m_opts.contains(prevItem->text(1)) ? m_opts[prevItem->text(1)] : 0); + DrBase *nextOpt = (nextItem && m_opts.contains(nextItem->text(1)) ? m_opts[nextItem->text(1)] : 0); + m_up->setEnabled(prevOpt && !(prevOpt->type() < DrBase::String && opt->type() >= DrBase::String)); + m_down->setEnabled(nextOpt && !(isgroup && nextOpt->type() >= DrBase::String)); + + m_persistent->setChecked( opt->get( "persistent" ) == "1" ); + } + + m_delopt->setEnabled(true); + m_dummy->setEnabled(opt); + } + else + { + m_delopt->setEnabled(false); + m_addopt->setEnabled(m_view->currentItem() && m_view->isEnabled()); + m_addgrp->setEnabled(m_view->currentItem() && m_view->isEnabled()); + m_up->setEnabled(false); + m_down->setEnabled(false); + } + slotTypeChanged(typeId); + m_apply->setEnabled(false); +} + +void KXmlCommandAdvancedDlg::slotTypeChanged(int ID) +{ + int wId(3); + ID += DrBase::String; + switch (ID) + { + case DrBase::Float: + case DrBase::Integer: + wId = 1; + break; + case DrBase::Boolean: + case DrBase::List: + wId = 2; + slotValueSelected(m_values->currentItem()); + break; + } + m_stack->raiseWidget(wId); +} + +void KXmlCommandAdvancedDlg::slotAddValue() +{ + TQListViewItem *item = new TQListViewItem(m_values, m_values->lastItem(), i18n("Name"), i18n("Description")); + item->setRenameEnabled(0, true); + item->setRenameEnabled(1, true); + m_values->ensureItemVisible(item); + slotValueSelected(item); + item->startRename(0); +} + +void KXmlCommandAdvancedDlg::slotRemoveValue() +{ + TQListViewItem *item = m_values->currentItem(); + if (item) + delete item; + slotValueSelected(m_values->currentItem()); +} + +void KXmlCommandAdvancedDlg::slotApplyChanges() +{ + TQListViewItem *item = m_view->currentItem(); + if (item) + { + if (m_name->text().isEmpty() || m_name->text() == "__root__") + { + KMessageBox::error(this, i18n("Invalid identification name. Empty strings and \"__root__\" are not allowed.")); + return; + } + + m_apply->setEnabled(false); + + DrBase *opt = (m_opts.contains(item->text(1)) ? m_opts[item->text(1)] : 0); + m_opts.remove(item->text(1)); + delete opt; + + // update tree item + item->setText(0, m_desc->text()); + item->setText(1, m_name->text()); + + // recreate option + if (m_type->isEnabled()) + { + int type = m_type->currentItem() + DrBase::String; + switch (type) + { + case DrBase::Integer: + case DrBase::Float: + if (type == DrBase::Integer) + opt = new DrIntegerOption; + else + opt = new DrFloatOption; + opt->set("minval", m_edit1->text()); + opt->set("maxval", m_edit2->text()); + break; + case DrBase::List: + case DrBase::Boolean: + { + if (type == DrBase::List) + opt = new DrListOption; + else + opt = new DrBooleanOption; + DrListOption *lopt = static_cast<DrListOption*>(opt); + TQListViewItem *item = m_values->firstChild(); + while (item) + { + DrBase *choice = new DrBase; + choice->setName(item->text(0)); + choice->set("text", item->text(1)); + lopt->addChoice(choice); + item = item->nextSibling(); + } + break; + } + case DrBase::String: + opt = new DrStringOption; + break; + + } + opt->set("format", m_format->text()); + opt->set("default", m_default->text()); + opt->setValueText(opt->get("default")); + } + else + opt = new DrGroup; + + opt->setName((m_name->text().isEmpty() ? generateId(m_opts) : m_name->text())); + opt->set("text", m_desc->text()); + opt->set( "persistent", m_persistent->isChecked() ? "1" : "0" ); + + m_opts[opt->name()] = opt; + } +} + +void KXmlCommandAdvancedDlg::slotChanged() +{ + m_apply->setEnabled(true); +} + +void KXmlCommandAdvancedDlg::slotAddGroup() +{ + if (m_view->currentItem()) + { + TQString ID = generateId(m_opts); + + DrGroup *grp = new DrGroup; + grp->setName(ID); + grp->set("text", i18n("New Group")); + m_opts[ID] = grp; + + TQListViewItem *item = new TQListViewItem(m_view->currentItem(), i18n("New Group"), ID); + item->setRenameEnabled(0, true); + item->setPixmap(0, SmallIcon("folder")); + m_view->ensureItemVisible(item); + item->startRename(0); + } +} + +void KXmlCommandAdvancedDlg::slotAddOption() +{ + if (m_view->currentItem()) + { + TQString ID = generateId(m_opts); + + DrBase *opt = new DrStringOption; + opt->setName(ID); + opt->set("text", i18n("New Option")); + m_opts[ID] = opt; + + TQListViewItem *item = new TQListViewItem(m_view->currentItem(), i18n("New Option"), ID); + item->setRenameEnabled(0, true); + item->setPixmap(0, SmallIcon("document")); + m_view->ensureItemVisible(item); + item->startRename(0); + } +} + +void KXmlCommandAdvancedDlg::slotRemoveItem() +{ + TQListViewItem *item = m_view->currentItem(); + if (item) + { + TQListViewItem *newCurrent(item->nextSibling()); + if (!newCurrent) + newCurrent = item->parent(); + removeItem(item); + delete item; + m_view->setSelected(newCurrent, true); + } +} + +void KXmlCommandAdvancedDlg::removeItem(TQListViewItem *item) +{ + delete m_opts[item->text(1)]; + m_opts.remove(item->text(1)); + TQListViewItem *child = item->firstChild(); + while (child && item) + { + removeItem(child); + if ( item ) + item = item->nextSibling(); + } +} + +void KXmlCommandAdvancedDlg::slotMoveUp() +{ + TQListViewItem *item = m_view->currentItem(), *prev = 0; + if (item && (prev=findPrev(item))) + { + TQListViewItem *after(0); + if ((after=findPrev(prev)) != 0) + item->moveItem(after); + else + { + TQListViewItem *parent = item->parent(); + parent->takeItem(item); + parent->insertItem(item); + } + m_view->setSelected(item, true); + slotSelectionChanged(item); + } +} + +void KXmlCommandAdvancedDlg::slotMoveDown() +{ + TQListViewItem *item = m_view->currentItem(), *next = 0; + if (item && (next=findNext(item))) + { + item->moveItem(next); + m_view->setSelected(item, true); + slotSelectionChanged(item); + } +} + +void KXmlCommandAdvancedDlg::slotCommandChanged(const TQString& cmd) +{ + m_inputfile->parentWidget()->setEnabled(cmd.find("%filterinput") != -1); + m_outputfile->parentWidget()->setEnabled(cmd.find("%filteroutput") != -1); + m_view->setEnabled(cmd.find("%filterargs") != -1); + m_name->parentWidget()->setEnabled(m_view->isEnabled()); + slotSelectionChanged((m_view->isEnabled() ? m_view->currentItem() : 0)); + m_view->setOpen(m_view->firstChild(), m_view->isEnabled()); +} + +void KXmlCommandAdvancedDlg::slotValueSelected(TQListViewItem *item) +{ + m_addval->setEnabled(m_type->currentItem() != 4 || m_values->childCount() < 2); + m_delval->setEnabled(item != 0); +} + +void KXmlCommandAdvancedDlg::slotOptionRenamed(TQListViewItem *item, int) +{ + if (item && m_opts.contains(item->text(1))) + { + DrBase *opt = m_opts[item->text(1)]; + opt->set("text", item->text(0)); + slotSelectionChanged(item); + } +} + +void KXmlCommandAdvancedDlg::recreateGroup(TQListViewItem *item, DrGroup *grp) +{ + if (!item) + return; + + TQListViewItem *child = item->firstChild(); + while (child) + { + DrBase *opt = (m_opts.contains(child->text(1)) ? m_opts[child->text(1)] : 0); + if (opt) + { + if (opt->type() == DrBase::Group) + { + DrGroup *childGroup = static_cast<DrGroup*>(opt); + recreateGroup(child, childGroup); + grp->addGroup(childGroup); + } + else + { + opt->setName("_kde-"+m_xmlcmd->name()+"-"+opt->name()); + grp->addOption(opt); + } + m_opts.remove(child->text(1)); + } + child = child->nextSibling(); + } +} + +bool KXmlCommandAdvancedDlg::editCommand(KXmlCommand *xmlcmd, TQWidget *parent) +{ + if (!xmlcmd) + return false; + + KDialogBase dlg(parent, 0, true, i18n("Command Edit for %1").arg(xmlcmd->name()), KDialogBase::Ok|KDialogBase::Cancel, KDialogBase::Ok, false); + KXmlCommandAdvancedDlg *xmldlg = new KXmlCommandAdvancedDlg(&dlg); + dlg.setMainWidget(xmldlg); + //dlg.enableButton(KDialogBase::Ok, false); + xmldlg->setCommand(xmlcmd); + if (dlg.exec()) + { + xmlcmd->setCommand(xmldlg->m_command->text()); + xmlcmd->setIo(xmldlg->m_inputfile->text(), true, false); + xmlcmd->setIo(xmldlg->m_inputpipe->text(), true, true); + xmlcmd->setIo(xmldlg->m_outputfile->text(), false, false); + xmlcmd->setIo(xmldlg->m_outputpipe->text(), false, true); + xmlcmd->setComment( xmldlg->m_comment->text().replace( TQRegExp( "\n" ), " " ) ); + + // need to recreate the driver tree structure + DrMain *driver = (xmldlg->m_opts.contains("__root__") ? static_cast<DrMain*>(xmldlg->m_opts["__root__"]) : 0); + if (!driver && xmldlg->m_opts.count() > 0) + { + kdDebug() << "KXmlCommandAdvancedDlg: driver structure not found, creating one" << endl; + driver = new DrMain; + driver->setName(xmlcmd->name()); + } + xmldlg->recreateGroup(xmldlg->m_view->firstChild(), driver); + xmldlg->m_opts.remove("__root__"); + xmlcmd->setDriver(driver); + + // remaining options will be removed in destructor + + return true; + } + return false; +} + +//----------------------------------------------------------------------------------------------------- + +KXmlCommandDlg::KXmlCommandDlg(TQWidget *parent, const char *name) +: KDialogBase(parent, name, true, TQString::null, Ok|Cancel|Details, Ok, true) +{ + setButtonText(Details, i18n("&Mime Type Settings")); + m_cmd = 0; + + TQWidget *dummy = new TQWidget(this, "TopDetail"); + TQWidget *topmain = new TQWidget(this, "TopMain"); + + TQGroupBox *m_gb1 = new TQGroupBox(0, Qt::Horizontal, i18n("Supported &Input Formats"), dummy); + TQGroupBox *m_gb2 = new TQGroupBox(0, Qt::Horizontal, i18n("Requirements"), topmain); + + m_description = new TQLineEdit(topmain); + m_idname = new TQLabel(topmain); + m_requirements = new KListView(m_gb2); + m_requirements->addColumn(""); + m_requirements->header()->hide(); + m_addreq = new TQToolButton(m_gb2); + m_addreq->setIconSet(SmallIconSet("filenew")); + m_removereq = new TQToolButton(m_gb2); + m_removereq->setIconSet(SmallIconSet("editdelete")); + TQPushButton *m_edit = new KPushButton(KGuiItem(i18n("&Edit Command..."), "edit"), topmain); + m_mimetype = new TQComboBox(dummy); + m_availablemime = new KListBox(m_gb1); + m_selectedmime = new KListBox(m_gb1); + m_addmime = new TQToolButton(m_gb1); + m_addmime->setIconSet(TQApplication::reverseLayout()? SmallIconSet("forward") : SmallIconSet("back")); + m_removemime = new TQToolButton(m_gb1); + m_removemime->setIconSet(TQApplication::reverseLayout()? SmallIconSet("back" ) : SmallIconSet("forward")); + m_gb2->setMinimumWidth(380); + m_gb1->setMinimumHeight(180); + m_requirements->setMaximumHeight(80); + m_removereq->setEnabled(false); + m_addmime->setEnabled(false); + m_removemime->setEnabled(false); + + TQLabel *m_desclab = new TQLabel(i18n("&Description:"), topmain); + m_desclab->setBuddy(m_description); + TQLabel *m_mimetypelab = new TQLabel(i18n("Output &format:"), dummy); + m_mimetypelab->setBuddy(m_mimetype); + TQLabel *m_idnamelab = new TQLabel(i18n("ID name:"), topmain); + + TQFont f(m_idname->font()); + f.setBold(true); + m_idname->setFont(f); + + KSeparator *sep1 = new KSeparator(TQFrame::HLine, dummy); + + TQVBoxLayout *l0 = new TQVBoxLayout(topmain, 0, 10); + TQGridLayout *l5 = new TQGridLayout(0, 2, 2, 0, 5); + l0->addLayout(TQT_TQLAYOUT(l5)); + l5->addWidget(m_idnamelab, 0, 0); + l5->addWidget(m_idname, 0, 1); + l5->addWidget(m_desclab, 1, 0); + l5->addWidget(m_description, 1, 1); + l0->addWidget(m_gb2); + TQHBoxLayout *l3 = new TQHBoxLayout(0, 0, 0); + l0->addLayout(l3); + l3->addWidget(m_edit); + l3->addStretch(1); + + TQVBoxLayout *l7 = new TQVBoxLayout(dummy, 0, 10); + TQHBoxLayout *l6 = new TQHBoxLayout(0, 0, 5); + l7->addWidget(sep1); + l7->addLayout(l6); + l6->addWidget(m_mimetypelab, 0); + l6->addWidget(m_mimetype, 1); + l7->addWidget(m_gb1); + TQGridLayout *l2 = new TQGridLayout(TQT_TQLAYOUT(m_gb1->tqlayout()), 4, 3, 10); + l2->addMultiCellWidget(m_availablemime, 0, 3, 2, 2); + l2->addMultiCellWidget(m_selectedmime, 0, 3, 0, 0); + l2->addWidget(m_addmime, 1, 1); + l2->addWidget(m_removemime, 2, 1); + l2->setRowStretch(0, 1); + l2->setRowStretch(3, 1); + TQHBoxLayout *l4 = new TQHBoxLayout(TQT_TQLAYOUT(m_gb2->tqlayout()), 10); + l4->addWidget(m_requirements); + TQVBoxLayout *l8 = new TQVBoxLayout(0, 0, 0); + l4->addLayout(l8); + l8->addWidget(m_addreq); + l8->addWidget(m_removereq); + l8->addStretch(1); + + connect(m_addmime, TQT_SIGNAL(clicked()), TQT_SLOT(slotAddMime())); + connect(m_removemime, TQT_SIGNAL(clicked()), TQT_SLOT(slotRemoveMime())); + connect(m_edit, TQT_SIGNAL(clicked()), TQT_SLOT(slotEditCommand())); + connect(m_requirements, TQT_SIGNAL(selectionChanged(TQListViewItem*)), TQT_SLOT(slotReqSelected(TQListViewItem*))); + connect(m_availablemime, TQT_SIGNAL(selectionChanged(TQListBoxItem*)), TQT_SLOT(slotAvailableSelected(TQListBoxItem*))); + connect(m_selectedmime, TQT_SIGNAL(selectionChanged(TQListBoxItem*)), TQT_SLOT(slotSelectedSelected(TQListBoxItem*))); + connect(m_addreq, TQT_SIGNAL(clicked()), TQT_SLOT(slotAddReq())); + connect(m_removereq, TQT_SIGNAL(clicked()), TQT_SLOT(slotRemoveReq())); + + KMimeType::List list = KMimeType::allMimeTypes(); + for (TQValueList<KMimeType::Ptr>::ConstIterator it=list.begin(); it!=list.end(); ++it) + { + TQString mimetype = (*it)->name(); + m_mimelist << mimetype; + } + + m_mimelist.sort(); + m_mimetype->insertStringList(m_mimelist); + m_availablemime->insertStringList(m_mimelist); + + setMainWidget(topmain); + setDetailsWidget(dummy); +} + +void KXmlCommandDlg::setCommand(KXmlCommand *xmlCmd) +{ + setCaption(i18n("Command Edit for %1").arg(xmlCmd->name())); + + m_cmd = xmlCmd; + m_description->setText(i18n(xmlCmd->description().utf8())); + m_idname->setText(xmlCmd->name()); + + m_requirements->clear(); + TQStringList list = xmlCmd->requirements(); + TQListViewItem *item(0); + for (TQStringList::ConstIterator it=list.begin(); it!=list.end(); ++it) + { + item = new TQListViewItem(m_requirements, item, *it); + item->setRenameEnabled(0, true); + } + + int index = m_mimelist.findIndex(xmlCmd->mimeType()); + if (index != -1) + m_mimetype->setCurrentItem(index); + else + m_mimetype->setCurrentItem(0); + + list = xmlCmd->inputMimeTypes(); + m_selectedmime->clear(); + m_availablemime->clear(); + m_availablemime->insertStringList(m_mimelist); + for (TQStringList::ConstIterator it=list.begin(); it!=list.end(); ++it) + { + m_selectedmime->insertItem(*it); + delete m_availablemime->findItem(*it, TQt::ExactMatch); + } +} + +void KXmlCommandDlg::slotOk() +{ + if (m_cmd) + { + m_cmd->setMimeType((m_mimetype->currentText() == "all/all" ? TQString::null : m_mimetype->currentText())); + m_cmd->setDescription(m_description->text()); + TQStringList l; + TQListViewItem *item = m_requirements->firstChild(); + while (item) + { + l << item->text(0); + item = item->nextSibling(); + } + m_cmd->setRequirements(l); + l.clear(); + for (uint i=0; i<m_selectedmime->count(); i++) + l << m_selectedmime->text(i); + m_cmd->setInputMimeTypes(l); + } + KDialogBase::slotOk(); +} + +bool KXmlCommandDlg::editCommand(KXmlCommand *xmlCmd, TQWidget *parent) +{ + if (!xmlCmd) + return false; + + KXmlCommandDlg xmldlg(parent, 0); + xmldlg.setCommand(xmlCmd); + + return (xmldlg.exec() == Accepted); +} + +void KXmlCommandDlg::slotAddMime() +{ + int index = m_availablemime->currentItem(); + if (index != -1) + { + m_selectedmime->insertItem(m_availablemime->currentText()); + m_availablemime->removeItem(index); + m_selectedmime->sort(); + } +} + +void KXmlCommandDlg::slotRemoveMime() +{ + int index = m_selectedmime->currentItem(); + if (index != -1) + { + m_availablemime->insertItem(m_selectedmime->currentText()); + m_selectedmime->removeItem(index); + m_availablemime->sort(); + } +} + +void KXmlCommandDlg::slotEditCommand() +{ + KXmlCommandAdvancedDlg::editCommand(m_cmd, parentWidget()); +} + +void KXmlCommandDlg::slotAddReq() +{ + TQListViewItem *item = new TQListViewItem(m_requirements, m_requirements->lastItem(), i18n("exec:/")); + item->setRenameEnabled(0, true); + m_requirements->ensureItemVisible(item); + item->startRename(0); +} + +void KXmlCommandDlg::slotRemoveReq() +{ + delete m_requirements->currentItem(); +} + +void KXmlCommandDlg::slotReqSelected(TQListViewItem *item) +{ + m_removereq->setEnabled(item); +} + +void KXmlCommandDlg::slotAvailableSelected(TQListBoxItem *item) +{ + m_addmime->setEnabled(item); +} + +void KXmlCommandDlg::slotSelectedSelected(TQListBoxItem *item) +{ + m_removemime->setEnabled(item); +} + +#include "kxmlcommanddlg.moc" |