← Back to branch summary

~ubuntu-branches/ubuntu/breezy/kdemultimedia/breezy

« back to all changes in this revision

Viewing changes to noatun/modules/metatag/edit.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2005-03-24 04:48:58 UTC
  • mfrom: (1.2.1 upstream) (2.1.1 sarge)
  • Revision ID: james.westby@ubuntu.com-20050324044858-8ff88o9jxej6ii3d
Tags: 4:3.4.0-0ubuntu3
Add kubuntu_02_hide_arts_menu_entries.diff to hide artsbuilder and artscontrol k-menu entries

Show diffs side-by-side

added added

removed removed

Lines of Context:
noatun/modules/metatag/edit.cpp
 
1
#include <klocale.h>
 
2
#include <qlayout.h>
 
3
#include <klineedit.h>
 
4
#include <qlabel.h>
 
5
#include <qptrlist.h>
 
6
 
 
7
#include <kmimetype.h>
 
8
#include <kicontheme.h>
 
9
#include <qtooltip.h>
 
10
#include <kstringvalidator.h>
 
11
#include <qspinbox.h>
 
12
#include <qhbox.h>
 
13
#include <qfile.h>
 
14
#include <qfileinfo.h>
 
15
#include <qcombobox.h>
 
16
#include <qpushbutton.h>
 
17
#include <kdialogbase.h>
 
18
#include <kdebug.h>
 
19
#include <kseparator.h>
 
20
#include <kfilemetainfo.h>
 
21
#include <qvalidator.h>
 
22
 
 
23
#include "metatag.h"
 
24
#include "edit.h"
 
25
 
 
26
Editor::Editor()
 
27
:  KDialogBase((QWidget*)0L, 0, false, i18n("Tag Editor"), Ok | Cancel)
 
28
{
 
29
    mMainWidget = makeMainWidget();
 
30
//    mMainWidget->setMinimumWidth(325);
 
31
 
 
32
    mGrid = new QGridLayout(mMainWidget, 1, 1, 0, spacingHint(), "Editor::mGrid");
 
33
 
 
34
    mGrid->setColStretch(1, 1);
 
35
    mGrid->setColStretch(2, 1);
 
36
 
 
37
    QHBox *heading = new QHBox(mMainWidget, "Editor::heading");
 
38
    heading->setSpacing(4);
 
39
    mFileIcon = new QLabel(heading);
 
40
    mFileIcon->setAlignment(AlignVCenter | AlignLeft);
 
41
    mFile = new QLabel(heading);
 
42
    mFile->setAlignment(AlignVCenter | AlignLeft);
 
43
    heading->setStretchFactor(mFile, 2);
 
44
    mGrid->addMultiCellWidget(heading, 0, 0, 0, 2);
 
45
 
 
46
    KSeparator *sep = new KSeparator(KSeparator::HLine, mMainWidget);
 
47
    mGrid->addMultiCellWidget(sep, 1, 1, 0, 2);
 
48
 
 
49
    mControls.setAutoDelete(true);
 
50
    mNextRow = 2;
 
51
 
 
52
    connect(this, SIGNAL(closeClicked()), SLOT(delayedDestruct()));
 
53
    connect(this, SIGNAL(okClicked()), SLOT(save()));
 
54
 
 
55
    enableButtonSeparator(true);
 
56
    setFixedHeight(sizeHint().height());
 
57
}
 
58
 
 
59
void Editor::open(const PlaylistItem & file)
 
60
{
 
61
    KFileMetaInfo file_meta_info(file.file(), file.mimetype());
 
62
    KFileMetaInfoItem info_item;
 
63
 
 
64
    item = file;
 
65
    mDirty = false;
 
66
 
 
67
    mFile->setText("<nobr><b>" + file.url().fileName(false) + "</b></nobr>");
 
68
    QToolTip::add(mFile, file.url().prettyURL());
 
69
    mFileIcon->
 
70
        setPixmap(KMimeType::pixmapForURL(file.url(), 0, KIcon::Small));
 
71
 
 
72
    if (file.url().isLocalFile()) {
 
73
        QFileInfo file_info(file.file());
 
74
        mFileWritable = file_info.isWritable();
 
75
    }
 
76
    else {
 
77
        // KFileMetaInfo doesn't work on remote files
 
78
        mFileWritable = false;
 
79
    }
 
80
 
 
81
    if ( !file_meta_info.isValid() ) // go ahead people, nothing to see here
 
82
        return;
 
83
 
 
84
    mControls.append(createControl(file_meta_info, i18n("&Title"), "Title", QVariant::String, false, mMainWidget));
 
85
    mControls.append(createControl(file_meta_info, i18n("&Artist"), "Artist", QVariant::String, false, mMainWidget));
 
86
    mControls.append(createControl(file_meta_info, i18n("A&lbum"), "Album", QVariant::String, false, mMainWidget));
 
87
    mControls.append(createControl(file_meta_info, i18n("&Date"), "Date", QVariant::String, false, mMainWidget));
 
88
    mControls.append(createControl(file_meta_info, i18n("T&rack"), "Tracknumber", QVariant::UInt, false, mMainWidget));
 
89
    mControls.append(createControl(file_meta_info, i18n("&Genre"), "Genre", QVariant::String, false, mMainWidget));
 
90
    mControls.append(createControl(file_meta_info, i18n("Co&mment"), "Comment", QVariant::String, false, mMainWidget));
 
91
}
 
92
 
 
93
void Editor::save()
 
94
{
 
95
    // Only write to disk if something actually changed
 
96
    if (!mDirty)
 
97
    {
 
98
        delayedDestruct();
 
99
        return;
 
100
    }
 
101
 
 
102
    KFileMetaInfo meta_info(item.file(), item.mimetype());
 
103
    if ( !meta_info.isValid() )
 
104
    {
 
105
        delayedDestruct();
 
106
        return;
 
107
    }
 
108
 
 
109
    for (MetaWidget *meta_widget = mControls.first(); meta_widget; meta_widget = mControls.next() )
 
110
        saveControl(meta_info, *meta_widget);
 
111
 
 
112
    meta_info.applyChanges();
 
113
 
 
114
    emit(saved(item));
 
115
    delayedDestruct();
 
116
}
 
117
 
 
118
void Editor::saveControl(KFileMetaInfo& meta_info, const MetaWidget &meta_widget) {
 
119
    QVariant value;
 
120
    const KFileMimeTypeInfo *info = KFileMetaInfoProvider::self()->mimeTypeInfo( meta_info.mimeType() );
 
121
 
 
122
     if (!meta_widget.widget->isEnabled())
 
123
         return;
 
124
 
 
125
     if (meta_widget.widget->inherits("QSpinBox"))
 
126
         value = static_cast<QSpinBox *>(meta_widget.widget)->value();
 
127
     else if (meta_widget.widget->inherits("QComboBox"))
 
128
         value = static_cast<QComboBox *>(meta_widget.widget)->currentText();
 
129
     else if (meta_widget.widget->inherits("QLineEdit"))
 
130
         value = static_cast<QLineEdit *>(meta_widget.widget)->text();
 
131
 
 
132
     QString group = keyGroup(meta_info, meta_widget.key);
 
133
 
 
134
     if (group.isNull()) {
 
135
         kdWarning() << "Cannot find group for " << meta_widget.key << endl;
 
136
         return;
 
137
     }
 
138
 
 
139
     if (info->groupInfo(group)->itemInfo(meta_widget.key)) {
 
140
        if (info->groupInfo(group)->attributes() & KFileMimeTypeInfo::Addable) {
 
141
            kdDebug(66666) << "Adding group " << group << endl;
 
142
            if (!meta_info.addGroup(group))
 
143
                kdWarning() << "Adding group \"" << group << "\" failed!" << endl;
 
144
        }
 
145
 
 
146
        if (info->groupInfo(group)->itemInfo(meta_widget.key)->attributes() & KFileMimeTypeInfo::Addable) {
 
147
            kdDebug(66666) << "Adding key " << meta_widget.key << endl;
 
148
            if (!meta_info.group(group).addItem(meta_widget.key).isValid())
 
149
                kdWarning() << "Adding key \"" << meta_widget.key << "\" failed!" << endl;
 
150
        }
 
151
     }
 
152
 
 
153
    if (value.cast(meta_info.item(meta_widget.key).type())) {
 
154
        if (!meta_info.item(meta_widget.key).setValue(value))
 
155
            kdWarning() << "setValue() failed on " << group << "/" << meta_widget.key << endl;
 
156
    }
 
157
    else
 
158
         kdWarning() << "Cannot save " << meta_widget.key << " as required type." << endl;
 
159
}
 
160
 
 
161
MetaWidget* Editor::createControl(KFileMetaInfo& meta_info, const QString &label, const QString &key, QVariant::Type default_type, bool optional, QWidget *parent) {
 
162
    QLabel *tmp_label = 0L;
 
163
    KFileMetaInfoItem info_item = meta_info.item(key);
 
164
    QVariant::Type type;
 
165
    MetaWidget *meta_widget = 0L;
 
166
    QValidator *validator = 0L;
 
167
    QString groupName = keyGroup(meta_info, key);
 
168
    bool known_key = ((!groupName.isNull()) && meta_info.group(groupName).contains(key));
 
169
    bool addable = keyAddable(meta_info, key);
 
170
    const KFileMimeTypeInfo *info = KFileMetaInfoProvider::self()->mimeTypeInfo( meta_info.mimeType() );
 
171
 
 
172
    // This key isn't a real thing, and we can't even create it
 
173
    if ((!info_item.isEditable()) && (!addable) && optional)
 
174
        return 0;
 
175
 
 
176
    if (!groupName.isNull()) {
 
177
         type = info->groupInfo(groupName)->itemInfo(key)->type();
 
178
    }
 
179
    else {
 
180
         type = default_type;
 
181
    }
 
182
 
 
183
    // Get the correct validator
 
184
    if ( info && !groupName.isNull() )
 
185
        validator = info->createValidator( groupName, key, parent );
 
186
 
 
187
    // meta_widget is used for book-keeping internally
 
188
    meta_widget = new MetaWidget;
 
189
    meta_widget->key = key;
 
190
 
 
191
    if ((type == QVariant::Int) || (type == QVariant::UInt)) {
 
192
        // We're an int, make a spin box
 
193
        QSpinBox *box = new QSpinBox(parent);
 
194
 
 
195
        // Well, normally metatag doesn't care that much about suffixes
 
196
        // and prefixes, but this is just too easy.
 
197
        box->setPrefix(info_item.prefix());
 
198
        box->setSuffix(info_item.suffix());
 
199
        // Kinda a hack... display " " instead of "0" (think track numbers)
 
200
        box->setSpecialValueText(" ");
 
201
 
 
202
        // Do we have a validator?
 
203
        if (validator) {
 
204
            box->setValidator(validator);
 
205
 
 
206
            // Is it an integer validator
 
207
            if (validator->inherits("QIntValidator")) {
 
208
                QIntValidator *int_validator = static_cast<QIntValidator *>(validator);
 
209
 
 
210
                // FIXME: Why the -hell- doesn't QSpinBox::setValidator() do this??
 
211
                box->setMinValue(int_validator->bottom());
 
212
                box->setMaxValue(int_validator->top());
 
213
            }
 
214
        }
 
215
 
 
216
        box->setValue(info_item.value().toInt());
 
217
 
 
218
        connect(box, SIGNAL(valueChanged(int)), this, SLOT(modified()));
 
219
        meta_widget->widget = box;
 
220
    }
 
221
    else {
 
222
        // We're not an int, make a KLineEdit/QComboBox, depending on our validator
 
223
        bool combo_box = false;
 
224
 
 
225
        if (validator)
 
226
           combo_box = validator->isA("KStringListValidator");
 
227
 
 
228
        if (combo_box) {
 
229
             QComboBox *combo = new QComboBox(parent);
 
230
 
 
231
             combo->clear();
 
232
             combo->insertStringList(static_cast<
 
233
                                     KStringListValidator *
 
234
                                     >(validator)->stringList());
 
235
 
 
236
             combo->setCurrentText(info_item.value().toString());
 
237
             connect(combo, SIGNAL(activated(int)), this, SLOT(modified()));
 
238
 
 
239
             meta_widget->widget = combo;
 
240
        }
 
241
        else {
 
242
             KLineEdit *edit;
 
243
 
 
244
             edit = new KLineEdit(parent);
 
245
             edit->setText(info_item.value().toString());
 
246
             edit->setValidator(validator);
 
247
             connect(edit, SIGNAL(textChanged(const QString &)), this, SLOT(modified()));
 
248
 
 
249
             meta_widget->widget = edit;
 
250
        }
 
251
    }
 
252
 
 
253
    if (known_key)
 
254
        meta_widget->widget->setEnabled(info_item.isEditable() && mFileWritable);
 
255
    else
 
256
        meta_widget->widget->setEnabled(addable && mFileWritable);
 
257
 
 
258
    mGrid->addMultiCellWidget(meta_widget->widget, mNextRow, mNextRow, 1, 2);
 
259
 
 
260
    // Add our label. This is the easy part
 
261
    tmp_label = new QLabel(meta_widget->widget, label + ":", parent);
 
262
    mGrid->addWidget(tmp_label, mNextRow, 0);
 
263
 
 
264
 
 
265
    mNextRow++;
 
266
 
 
267
    return meta_widget;
 
268
}
 
269
 
 
270
QString Editor::keyGroup(const KFileMetaInfo& i, QString key) {
 
271
    const KFileMimeTypeInfo *info = KFileMetaInfoProvider::self()->mimeTypeInfo( i.mimeType() );
 
272
    QStringList groups = info->supportedGroups();
 
273
 
 
274
    for (QStringList::Iterator it = groups.begin();it != groups.end();++it) {
 
275
        if (info->groupInfo(*it)->itemInfo(key)) {
 
276
            return *it;
 
277
        }
 
278
    }
 
279
 
 
280
    return QString::null;
 
281
}
 
282
 
 
283
bool Editor::keyAddable(const KFileMetaInfo &i, QString key) {
 
284
    const KFileMimeTypeInfo *info = KFileMetaInfoProvider::self()->mimeTypeInfo( i.mimeType() );
 
285
    QStringList groups = info->supportedGroups();
 
286
 
 
287
    kdDebug(66666) << "Testing if " << key << " is addable" << endl;
 
288
    for (QStringList::Iterator it = groups.begin();it != groups.end();++it) {
 
289
        if (info->groupInfo(*it)->supportsVariableKeys()) {
 
290
            kdDebug(66666) << "Group " << *it << " supports variable keys" << endl;
 
291
            return true;
 
292
        }
 
293
 
 
294
        if (info->groupInfo(*it)->itemInfo(key)) {
 
295
            if (info->groupInfo(*it)->attributes() & KFileMimeTypeInfo::Addable) {
 
296
                 kdDebug(66666) << "Group " << *it << " is addable" << endl;
 
297
                 return true;
 
298
            }
 
299
 
 
300
            if (info->groupInfo(*it)->itemInfo(key)->attributes() & KFileMimeTypeInfo::Addable)
 
301
                return true;
 
302
        }
 
303
    }
 
304
 
 
305
    return false;
 
306
}
 
307
 
 
308
void Editor::modified() {
 
309
        mDirty = true;
 
310
}
 
311
 
 
312
#include "edit.moc"