workspace/kmenuedit/treeview.cpp

   1 /*
   2  *   Copyright (C) 2000 Matthias Elter <elter@kde.org>
   3  *   Copyright (C) 2001-2002 Raffaele Sandrini <sandrini@kde.org>
   4  *   Copyright (C) 2003 Waldo Bastian <bastian@kde.org>
   5  *
   6  *   This program is free software; you can redistribute it and/or modify
   7  *   it under the terms of the GNU General Public License as published by
   8  *   the Free Software Foundation; either version 2 of the License, or
   9  *   (at your option) any later version.
  10  *
  11  *   This program is distributed in the hope that it will be useful,
  12  *   but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *   GNU General Public License for more details.
  15  *
  16  *   You should have received a copy of the GNU General Public License
  17  *   along with this program; if not, write to the Free Software
  18  *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  19  *
  20  */
  21
  22 #include <unistd.h>
  23
  24 #include <QCursor>
  25 #include <QDataStream>
  26 #include <QDir>
  27 #include <Qt3Support/Q3ColorDrag>
  28 #include <QEvent>
  29 #include <QFileInfo>
  30 #include <Qt3Support/Q3Header>
  31 #include <QPainter>
  32 #include <QRegExp>
  33 //Added by qt3to4:
  34 #include <QPixmap>
  35 #include <Q3PtrList>
  36 #include <QFrame>
  37 #include <QDropEvent>
  38 #include <QMenu>
  39
  40 #include <kaction.h>
  41 #include <kactioncollection.h>
  42 #include <kapplication.h>
  43 #include <kbuildsycocaprogressdialog.h>
  44 #include <kdebug.h>
  45 #include <kdesktopfile.h>
  46 #include <kglobal.h>
  47 #include <kiconloader.h>
  48 #include <kinputdialog.h>
  49 #include <klocale.h>
  50 #include <kmessagebox.h>
  51 #include <kservice.h>
  52 #include <kservicegroup.h>
  53 #include <kconfig.h>
  54 #include <kconfiggroup.h>
  55 #include <kstandarddirs.h>
  56 #include <k3multipledrag.h>
  57 #include <k3urldrag.h>
  58
  59 #include "treeview.h"
  60 #include "treeview.moc"
  61 #include "khotkeys.h"
  62 #include "menufile.h"
  63 #include "menuinfo.h"
  64
  65 #define MOVE_FOLDER 'M'
  66 #define COPY_FOLDER 'C'
  67 #define MOVE_FILE   'm'
  68 #define COPY_FILE   'c'
  69 #define COPY_SEPARATOR 'S'
  70
  71 TreeItem::TreeItem(Q3ListViewItem *parent, Q3ListViewItem *after, const QString& menuId, bool __init)
  72     :Q3ListViewItem(parent, after), _hidden(false), _init(__init), _layoutDirty(false), _menuId(menuId),
  73      m_folderInfo(0), m_entryInfo(0) {}
  74
  75 TreeItem::TreeItem(Q3ListView *parent, Q3ListViewItem *after, const QString& menuId, bool __init)
  76     : Q3ListViewItem(parent, after), _hidden(false), _init(__init), _layoutDirty(false), _menuId(menuId),
  77      m_folderInfo(0), m_entryInfo(0) {}
  78
  79 void TreeItem::setName(const QString &name)
  80 {
  81     _name = name;
  82     update();
  83 }
  84
  85 void TreeItem::setHidden(bool b)
  86 {
  87     if (_hidden == b) return;
  88     _hidden = b;
  89     update();
  90 }
  91
  92 void TreeItem::update()
  93 {
  94     QString s = _name;
  95     if (_hidden)
  96        s += i18n(" [Hidden]");
  97     setText(0, s);
  98 }
  99
 100 void TreeItem::setOpen(bool o)
 101 {
 102     if (o)
 103        load();
 104
 105     Q3ListViewItem::setOpen(o);
 106 }
 107
 108 void TreeItem::load()
 109 {
 110     if (m_folderInfo && !_init)
 111     {
 112        _init = true;
 113        TreeView *tv = static_cast<TreeView *>(listView());
 114        tv->fillBranch(m_folderInfo, this);
 115     }
 116 }
 117
 118 void TreeItem::paintCell ( QPainter * p, const QColorGroup & cg, int column, int width, int align )
 119 {
 120     Q3ListViewItem::paintCell(p, cg, column, width, align);
 121
 122     if (!m_folderInfo && !m_entryInfo)
 123     {
 124        // Draw Separator
 125        int h = (height() / 2) -1;
 126        if (isSelected())
 127            p->setPen( cg.color( QPalette::HighlightedText ) );
 128        else
 129            p->setPen( cg.color( QPalette::Text ) );
 130        p->drawLine(0, h,
 131                    width, h);
 132     }
 133 }
 134
 135 void TreeItem::setup()
 136 {
 137     Q3ListViewItem::setup();
 138     if (!m_folderInfo && !m_entryInfo)
 139        setHeight(8);
 140 }
 141
 142 static QPixmap appIcon(const QString &iconName)
 143 {
 144     QPixmap normal = KIconLoader::global()->loadIcon(iconName, KIconLoader::Small, 0, KIconLoader::DefaultState, QStringList(), 0L, true);
 145     // make sure they are not larger than 20x20
 146     if (normal.width() > 20 || normal.height() > 20)
 147     {
 148        QImage tmp = normal.toImage();
 149        tmp = tmp.scaled(20, 20, Qt::IgnoreAspectRatio, Qt::SmoothTransformation);
 150        normal = QPixmap::fromImage(tmp);
 151     }
 152     return normal;
 153 }
 154
 155
 156 TreeView::TreeView( bool controlCenter, KActionCollection *ac, QWidget *parent, const char *name )
 157     : K3ListView(parent), m_ac(ac), m_rmb(0), m_clipboard(0),
 158       m_clipboardFolderInfo(0), m_clipboardEntryInfo(0),
 159       m_controlCenter(controlCenter), m_layoutDirty(false)
 160 {
 161     setObjectName(name);
 162         setFrameStyle(QFrame::WinPanel | QFrame::Sunken);
 163     setAllColumnsShowFocus(true);
 164     setRootIsDecorated(true);
 165     setSorting(-1);
 166     setAcceptDrops(true);
 167     setDropVisualizer(true);
 168     setDragEnabled(true);
 169     setMinimumWidth(240);
 170
 171     addColumn("");
 172     header()->hide();
 173
 174     connect(this, SIGNAL(dropped(QDropEvent*, Q3ListViewItem*, Q3ListViewItem*)),
 175             SLOT(slotDropped(QDropEvent*, Q3ListViewItem*, Q3ListViewItem*)));
 176
 177     connect(this, SIGNAL(clicked( Q3ListViewItem* )),
 178             SLOT(itemSelected( Q3ListViewItem* )));
 179
 180     connect(this,SIGNAL(selectionChanged ( Q3ListViewItem * )),
 181             SLOT(itemSelected( Q3ListViewItem* )));
 182
 183     connect(this, SIGNAL(rightButtonPressed(Q3ListViewItem*, const QPoint&, int)),
 184             SLOT(slotRMBPressed(Q3ListViewItem*, const QPoint&)));
 185
 186     // connect actions
 187     connect(m_ac->action("newitem"), SIGNAL(activated()), SLOT(newitem()));
 188     connect(m_ac->action("newsubmenu"), SIGNAL(activated()), SLOT(newsubmenu()));
 189     if (m_ac->action("newsep"))
 190         connect(m_ac->action("newsep"), SIGNAL(activated()), SLOT(newsep()));
 191
 192     m_menuFile = new MenuFile( KStandardDirs::locateLocal("xdgconf-menu", "applications-kmenuedit.menu"));
 193     m_rootFolder = new MenuFolderInfo;
 194     m_separator = new MenuSeparatorInfo;
 195     m_drag = 0;
 196
 197     //  Read menu format configuration information
 198     KSharedConfig::Ptr pConfig = KSharedConfig::openConfig("kickerrc");
 199     KConfigGroup cg(pConfig, "menus");
 200     m_detailedMenuEntries = cg.readEntry("DetailedMenuEntries", true);
 201     if (m_detailedMenuEntries)
 202     {
 203         m_detailedEntriesNamesFirst = cg.readEntry("DetailedEntriesNamesFirst", false);
 204     }
 205 }
 206
 207 TreeView::~TreeView() {
 208     cleanupClipboard();
 209     delete m_rootFolder;
 210     delete m_separator;
 211 }
 212
 213 void TreeView::setViewMode(bool showHidden)
 214 {
 215     delete m_rmb;
 216
 217     // setup rmb menu
 218     m_rmb = new QMenu(this);
 219     QAction *action;
 220
 221     action = m_ac->action("edit_cut");
 222     if(action) {
 223         m_rmb->addAction( action );
 224         action->setEnabled(false);
 225         connect(action, SIGNAL(activated()), SLOT(cut()));
 226     }
 227
 228     action = m_ac->action("edit_copy");
 229     if(action) {
 230         m_rmb->addAction( action );
 231         action->setEnabled(false);
 232         connect(action, SIGNAL(activated()), SLOT(copy()));
 233     }
 234
 235     action = m_ac->action("edit_paste");
 236     if(action) {
 237         m_rmb->addAction( action );
 238         action->setEnabled(false);
 239         connect(action, SIGNAL(activated()), SLOT(paste()));
 240     }
 241
 242     m_rmb->addSeparator();
 243
 244     action = m_ac->action("delete");
 245     if(action) {
 246         m_rmb->addAction( action );
 247         action->setEnabled(false);
 248         connect(action, SIGNAL(activated()), SLOT(del()));
 249     }
 250
 251     m_rmb->addSeparator();
 252
 253     if(m_ac->action("newitem"))
 254         m_rmb->addAction( m_ac->action("newitem") );
 255     if(m_ac->action("newsubmenu"))
 256         m_rmb->addAction( m_ac->action("newsubmenu") );
 257     if(m_ac->action("newsep"))
 258         m_rmb->addAction( m_ac->action("newsep") );
 259
 260     m_showHidden = showHidden;
 261     readMenuFolderInfo();
 262     fill();
 263 }
 264
 265 void TreeView::readMenuFolderInfo(MenuFolderInfo *folderInfo, KServiceGroup::Ptr folder, const QString &prefix)
 266 {
 267     if (!folderInfo)
 268     {
 269        folderInfo = m_rootFolder;
 270        if (m_controlCenter)
 271           folder = KServiceGroup::baseGroup("settings");
 272        else
 273           folder = KServiceGroup::root();
 274     }
 275
 276     if (!folder || !folder->isValid())
 277         return;
 278
 279     folderInfo->caption = folder->caption();
 280     folderInfo->comment = folder->comment();
 281
 282     // Item names may contain ampersands. To avoid them being converted
 283     // to accelerators, replace them with two ampersands.
 284     folderInfo->hidden = folder->noDisplay();
 285     folderInfo->directoryFile = folder->directoryEntryPath();
 286     folderInfo->icon = folder->icon();
 287     QString id = folder->relPath();
 288     int i = id.lastIndexOf('/', -2);
 289     id = id.mid(i+1);
 290     folderInfo->id = id;
 291     folderInfo->fullId = prefix + id;
 292
 293     foreach(const KSycocaEntry::Ptr &e, folder->entries(true, !m_showHidden, true, m_detailedMenuEntries && !m_detailedEntriesNamesFirst))
 294     {
 295         if (e->isType(KST_KServiceGroup))
 296         {
 297             KServiceGroup::Ptr g(KServiceGroup::Ptr::staticCast(e));
 298             MenuFolderInfo *subFolderInfo = new MenuFolderInfo();
 299             readMenuFolderInfo(subFolderInfo, g, folderInfo->fullId);
 300             folderInfo->add(subFolderInfo, true);
 301         }
 302         else if (e->isType(KST_KService))
 303         {
 304             folderInfo->add(new MenuEntryInfo(KService::Ptr::staticCast(e)), true);
 305         }
 306         else if (e->isType(KST_KServiceSeparator))
 307         {
 308             folderInfo->add(m_separator, true);
 309         }
 310     }
 311 }
 312
 313 void TreeView::fill()
 314 {
 315     QApplication::setOverrideCursor(Qt::WaitCursor);
 316     clear();
 317     fillBranch(m_rootFolder, 0);
 318     QApplication::restoreOverrideCursor();
 319 }
 320
 321 QString TreeView::findName(KDesktopFile *df, bool deleted)
 322 {
 323     QString name = df->readName();
 324     if (deleted)
 325     {
 326        if (name == "empty")
 327           name.clear();
 328        if (name.isEmpty())
 329        {
 330           QString file = df->fileName();
 331           QString res = df->resource();
 332
 333           bool isLocal = true;
 334           QStringList files = KGlobal::dirs()->findAllResources(res.toLatin1(), file);
 335           for(QStringList::ConstIterator it = files.begin();
 336               it != files.end();
 337               ++it)
 338           {
 339              if (isLocal)
 340              {
 341                 isLocal = false;
 342                 continue;
 343              }
 344
 345              KDesktopFile df2(*it);
 346              name = df2.readName();
 347
 348              if (!name.isEmpty() && (name != "empty"))
 349                 return name;
 350           }
 351        }
 352     }
 353     return name;
 354 }
 355
 356 TreeItem *TreeView::createTreeItem(TreeItem *parent, Q3ListViewItem *after, MenuFolderInfo *folderInfo, bool _init)
 357 {
 358    TreeItem *item;
 359    if (parent == 0)
 360      item = new TreeItem(this, after, QString(), _init);
 361    else
 362      item = new TreeItem(parent, after, QString(), _init);
 363
 364    item->setMenuFolderInfo(folderInfo);
 365    item->setName(folderInfo->caption);
 366    item->setPixmap(0, appIcon(folderInfo->icon));
 367    item->setDirectoryPath(folderInfo->fullId);
 368    item->setHidden(folderInfo->hidden);
 369    item->setExpandable(true);
 370    return item;
 371 }
 372
 373 TreeItem *TreeView::createTreeItem(TreeItem *parent, Q3ListViewItem *after, MenuEntryInfo *entryInfo, bool _init)
 374 {
 375    bool hidden = entryInfo->hidden;
 376
 377    TreeItem* item;
 378    if (parent == 0)
 379      item = new TreeItem(this, after, entryInfo->menuId(), _init);
 380    else
 381      item = new TreeItem(parent, after, entryInfo->menuId(),_init);
 382
 383    QString      name;
 384
 385    if (m_detailedMenuEntries && entryInfo->description.length() != 0)
 386    {
 387       if (m_detailedEntriesNamesFirst)
 388       {
 389          name = entryInfo->caption + " (" + entryInfo->description + ')';
 390       }
 391       else
 392       {
 393          name = entryInfo->description + " (" + entryInfo->caption + ')';
 394       }
 395    }
 396    else
 397    {
 398       name = entryInfo->caption;
 399    }
 400    item->setMenuEntryInfo(entryInfo);
 401    item->setName(name);
 402    item->setPixmap(0, appIcon(entryInfo->icon));
 403
 404    item->setHidden(hidden);
 405    return item;
 406 }
 407
 408 TreeItem *TreeView::createTreeItem(TreeItem *parent, Q3ListViewItem *after, MenuSeparatorInfo *, bool _init)
 409 {
 410    TreeItem* item;
 411    if (parent == 0)
 412      item = new TreeItem(this, after, QString(), _init);
 413    else
 414      item = new TreeItem(parent, after, QString(),_init);
 415
 416    return item;
 417 }
 418
 419 void TreeView::fillBranch(MenuFolderInfo *folderInfo, TreeItem *parent)
 420 {
 421     QString relPath = parent ? parent->directory() : QString();
 422     Q3PtrListIterator<MenuInfo> it( folderInfo->initialLayout );
 423     TreeItem *after = 0;
 424     for (MenuInfo *info; (info = it.current()); ++it)
 425     {
 426        MenuEntryInfo *entry = dynamic_cast<MenuEntryInfo*>(info);
 427        if (entry)
 428        {
 429           after = createTreeItem(parent, after, entry);
 430           continue;
 431        }
 432
 433        MenuFolderInfo *subFolder = dynamic_cast<MenuFolderInfo*>(info);
 434        if (subFolder)
 435        {
 436           after = createTreeItem(parent, after, subFolder);
 437           continue;
 438        }
 439        MenuSeparatorInfo *separator = dynamic_cast<MenuSeparatorInfo*>(info);
 440        if (separator)
 441        {
 442           after = createTreeItem(parent, after, separator);
 443           continue;
 444        }
 445     }
 446 }
 447
 448 void TreeView::closeAllItems(Q3ListViewItem *item)
 449 {
 450     if (!item) return;
 451     while(item)
 452     {
 453        item->setOpen(false);
 454        closeAllItems(item->firstChild());
 455        item = item->nextSibling();
 456     }
 457 }
 458
 459 void TreeView::selectMenu(const QString &menu)
 460 {
 461    closeAllItems(firstChild());
 462
 463    if (menu.length() <= 1)
 464    {
 465       setCurrentItem(firstChild());
 466       clearSelection();
 467       return; // Root menu
 468    }
 469
 470    QString restMenu = menu.mid(1);
 471    if (!restMenu.endsWith('/'))
 472       restMenu += '/';
 473
 474    TreeItem *item = 0;
 475    do
 476    {
 477       int i = restMenu.indexOf("/");
 478       QString subMenu = restMenu.left(i+1);
 479       restMenu = restMenu.mid(i+1);
 480
 481       item = (TreeItem*)(item ? item->firstChild() : firstChild());
 482       while(item)
 483       {
 484          MenuFolderInfo *folderInfo = item->folderInfo();
 485          if (folderInfo && (folderInfo->id == subMenu))
 486          {
 487             item->setOpen(true);
 488             break;
 489          }
 490          item = (TreeItem*) item->nextSibling();
 491       }
 492    }
 493    while( item && !restMenu.isEmpty());
 494
 495    if (item)
 496    {
 497       setCurrentItem(item);
 498       ensureItemVisible(item);
 499    }
 500 }
 501
 502 void TreeView::selectMenuEntry(const QString &menuEntry)
 503 {
 504    TreeItem *item = (TreeItem *) selectedItem();
 505    if (!item)
 506    {
 507       item = (TreeItem *) currentItem();
 508       while (item && item->isDirectory())
 509           item = (TreeItem*) item->nextSibling();
 510    }
 511    else
 512        item = (TreeItem *) item->firstChild();
 513
 514    while(item)
 515    {
 516       MenuEntryInfo *entry = item->entryInfo();
 517       if (entry && (entry->menuId() == menuEntry))
 518       {
 519          setCurrentItem(item);
 520          ensureItemVisible(item);
 521          return;
 522       }
 523       item = (TreeItem*) item->nextSibling();
 524    }
 525 }
 526
 527 void TreeView::itemSelected(Q3ListViewItem *item)
 528 {
 529     TreeItem *_item = (TreeItem*)item;
 530     bool selected = false;
 531     bool dselected = false;
 532     if (_item) {
 533         selected = true;
 534         dselected = _item->isHidden();
 535     }
 536
 537     m_ac->action("edit_cut")->setEnabled(selected);
 538     m_ac->action("edit_copy")->setEnabled(selected);
 539
 540     if (m_ac->action("delete"))
 541         m_ac->action("delete")->setEnabled(selected && !dselected);
 542
 543     if(!item)
 544     {
 545         emit disableAction();
 546         return;
 547     }
 548
 549     if (_item->isDirectory())
 550        emit entrySelected(_item->folderInfo());
 551     else
 552        emit entrySelected(_item->entryInfo());
 553 }
 554
 555 void TreeView::currentChanged(MenuFolderInfo *folderInfo)
 556 {
 557     TreeItem *item = (TreeItem*)selectedItem();
 558     if (item == 0) return;
 559     if (folderInfo == 0) return;
 560
 561     item->setName(folderInfo->caption);
 562     item->setPixmap(0, appIcon(folderInfo->icon));
 563 }
 564
 565 void TreeView::currentChanged(MenuEntryInfo *entryInfo)
 566 {
 567     TreeItem *item = (TreeItem*)selectedItem();
 568     if (item == 0) return;
 569     if (entryInfo == 0) return;
 570
 571     QString     name;
 572
 573     if (m_detailedMenuEntries && entryInfo->description.length() != 0)
 574     {
 575         if (m_detailedEntriesNamesFirst)
 576          {
 577             name = entryInfo->caption + " (" + entryInfo->description + ')';
 578         }
 579          else
 580         {
 581             name = entryInfo->description + " (" + entryInfo->caption + ')';
 582         }
 583     }
 584     else
 585     {
 586         name = entryInfo->caption;
 587     }
 588     item->setName(name);
 589     item->setPixmap(0, appIcon(entryInfo->icon));
 590 }
 591
 592 QStringList TreeView::fileList(const QString& rPath)
 593 {
 594     QString relativePath = rPath;
 595
 596     // truncate "/.directory"
 597     int pos = relativePath.lastIndexOf("/.directory");
 598     if (pos > 0) relativePath.truncate(pos);
 599
 600     QStringList filelist;
 601
 602     // loop through all resource dirs and build a file list
 603     QStringList resdirlist = KGlobal::dirs()->resourceDirs("apps");
 604     for (QStringList::ConstIterator it = resdirlist.begin(); it != resdirlist.end(); ++it)
 605     {
 606         QDir dir((*it) + '/' + relativePath);
 607         if(!dir.exists()) continue;
 608
 609         dir.setFilter(QDir::Files);
 610         dir.setNameFilters(QStringList() << "*.desktop;*.kdelnk");
 611
 612         // build a list of files
 613         QStringList files = dir.entryList();
 614         for (QStringList::ConstIterator it = files.begin(); it != files.end(); ++it) {
 615             // does not work?!
 616             //if (filelist.contains(*it)) continue;
 617
 618             if (relativePath.isEmpty()) {
 619                 filelist.removeAll(*it); // hack
 620                 filelist.append(*it);
 621             }
 622             else {
 623                 filelist.removeAll(relativePath + '/' + *it); //hack
 624                 filelist.append(relativePath + '/' + *it);
 625             }
 626         }
 627     }
 628     return filelist;
 629 }
 630
 631 QStringList TreeView::dirList(const QString& rPath)
 632 {
 633     QString relativePath = rPath;
 634
 635     // truncate "/.directory"
 636     int pos = relativePath.lastIndexOf("/.directory");
 637     if (pos > 0) relativePath.truncate(pos);
 638
 639     QStringList dirlist;
 640
 641     // loop through all resource dirs and build a subdir list
 642     QStringList resdirlist = KGlobal::dirs()->resourceDirs("apps");
 643     for (QStringList::ConstIterator it = resdirlist.begin(); it != resdirlist.end(); ++it)
 644     {
 645         QDir dir((*it) + '/' + relativePath);
 646         if(!dir.exists()) continue;
 647         dir.setFilter(QDir::Dirs);
 648
 649         // build a list of subdirs
 650         QStringList subdirs = dir.entryList();
 651         for (QStringList::ConstIterator it = subdirs.begin(); it != subdirs.end(); ++it) {
 652             if ((*it) == "." || (*it) == "..") continue;
 653             // does not work?!
 654             // if (dirlist.contains(*it)) continue;
 655
 656             if (relativePath.isEmpty()) {
 657                 dirlist.removeAll(*it); //hack
 658                 dirlist.append(*it);
 659             }
 660             else {
 661                 dirlist.removeAll(relativePath + '/' + *it); //hack
 662                 dirlist.append(relativePath + '/' + *it);
 663             }
 664         }
 665     }
 666     return dirlist;
 667 }
 668
 669 bool TreeView::acceptDrag(QDropEvent* e) const
 670 {
 671     if (e->provides("application/x-kmenuedit-internal") &&
 672            (e->source() == const_cast<TreeView *>(this)))
 673        return true;
 674     KUrl::List urls;
 675     if (K3URLDrag::decode(e, urls) && (urls.count() == 1) &&
 676         urls[0].isLocalFile() && urls[0].path().endsWith(".desktop"))
 677        return true;
 678     return false;
 679 }
 680
 681
 682 static QString createDesktopFile(const QString &file, QString *menuId, QStringList *excludeList)
 683 {
 684    QString base = file.mid(file.lastIndexOf('/')+1);
 685    base = base.left(base.lastIndexOf('.'));
 686
 687    QRegExp r("(.*)(?=-\\d+)");
 688    base = (r.indexIn(base) > -1) ? r.cap(1) : base;
 689
 690    QString result = KService::newServicePath(true, base, menuId, excludeList);
 691    excludeList->append(*menuId);
 692    // Todo for Undo-support: Undo menuId allocation:
 693
 694    return result;
 695 }
 696
 697 static KDesktopFile *copyDesktopFile(MenuEntryInfo *entryInfo, QString *menuId, QStringList *excludeList)
 698 {
 699    QString result = createDesktopFile(entryInfo->file(), menuId, excludeList);
 700    KDesktopFile *df = entryInfo->desktopFile()->copyTo(result);
 701    df->desktopGroup().deleteEntry("Categories"); // Don't set any categories!
 702
 703    return df;
 704 }
 705
 706 static QString createDirectoryFile(const QString &file, QStringList *excludeList)
 707 {
 708    QString base = file.mid(file.lastIndexOf('/')+1);
 709    base = base.left(base.lastIndexOf('.'));
 710
 711    QString result;
 712    int i = 1;
 713    while(true)
 714    {
 715       if (i == 1)
 716          result = base + ".directory";
 717       else
 718          result = base + QString("-%1.directory").arg(i);
 719
 720       if (!excludeList->contains(result))
 721       {
 722          if (KStandardDirs::locate("xdgdata-dirs", result).isEmpty())
 723             break;
 724       }
 725       i++;
 726    }
 727    excludeList->append(result);
 728    result = KStandardDirs::locateLocal("xdgdata-dirs", result);
 729    return result;
 730 }
 731
 732
 733 void TreeView::slotDropped (QDropEvent * e, Q3ListViewItem *parent, Q3ListViewItem*after)
 734 {
 735    if(!e) return;
 736
 737    // get destination folder
 738    TreeItem *parentItem = static_cast<TreeItem*>(parent);
 739    QString folder = parentItem ? parentItem->directory() : QString();
 740    MenuFolderInfo *parentFolderInfo = parentItem ? parentItem->folderInfo() : m_rootFolder;
 741
 742    if (e->source() != this)
 743    {
 744      // External drop
 745      KUrl::List urls;
 746      if (!K3URLDrag::decode(e, urls) || (urls.count() != 1) || !urls[0].isLocalFile())
 747         return;
 748      QString path = urls[0].path();
 749      if (!path.endsWith(".desktop"))
 750         return;
 751
 752      QString menuId;
 753      QString result = createDesktopFile(path, &menuId, &m_newMenuIds);
 754      KDesktopFile orig_df(path);
 755      KDesktopFile *df = orig_df.copyTo(result);
 756      df->desktopGroup().deleteEntry("Categories"); // Don't set any categories!
 757
 758      KService::Ptr s(new KService(df));
 759      s->setMenuId(menuId);
 760
 761      MenuEntryInfo *entryInfo = new MenuEntryInfo(s, df);
 762
 763      QString oldCaption = entryInfo->caption;
 764      QString newCaption = parentFolderInfo->uniqueItemCaption(oldCaption, oldCaption);
 765      entryInfo->setCaption(newCaption);
 766
 767      // Add file to menu
 768      // m_menuFile->addEntry(folder, menuId);
 769      m_menuFile->pushAction(MenuFile::ADD_ENTRY, folder, menuId);
 770
 771      // create the TreeItem
 772      if(parentItem)
 773         parentItem->setOpen(true);
 774
 775      // update fileInfo data
 776      parentFolderInfo->add(entryInfo);
 777
 778      TreeItem *newItem = createTreeItem(parentItem, after, entryInfo, true);
 779
 780      setSelected ( newItem, true);
 781      itemSelected( newItem);
 782
 783      m_drag = 0;
 784      setLayoutDirty(parentItem);
 785      return;
 786    }
 787
 788    // is there content in the clipboard?
 789    if (!m_drag) return;
 790
 791    if (m_dragItem == after) return; // Nothing to do
 792
 793    int command = m_drag;
 794    if (command == MOVE_FOLDER)
 795    {
 796       MenuFolderInfo *folderInfo = m_dragInfo;
 797       if (e->action() == QDropEvent::Copy)
 798       {
 799          // Ugh.. this is hard :)
 800          // * Create new .directory file
 801          // Add
 802       }
 803       else
 804       {
 805           TreeItem *tmpItem = static_cast<TreeItem*>(parentItem);
 806           while (  tmpItem )
 807           {
 808               if (  tmpItem == m_dragItem )
 809               {
 810                   m_drag = 0;
 811                   return;
 812               }
 813               tmpItem = static_cast<TreeItem*>(tmpItem->parent() );
 814           }
 815
 816          // Remove MenuFolderInfo
 817          TreeItem *oldParentItem = static_cast<TreeItem*>(m_dragItem->parent());
 818          MenuFolderInfo *oldParentFolderInfo = oldParentItem ? oldParentItem->folderInfo() : m_rootFolder;
 819          oldParentFolderInfo->take(folderInfo);
 820
 821          // Move menu
 822          QString oldFolder = folderInfo->fullId;
 823          QString folderName = folderInfo->id;
 824          QString newFolder = m_menuFile->uniqueMenuName(folder, folderName, parentFolderInfo->existingMenuIds());
 825          folderInfo->id = newFolder;
 826
 827          // Add file to menu
 828          //m_menuFile->moveMenu(oldFolder, folder + newFolder);
 829          m_menuFile->pushAction(MenuFile::MOVE_MENU, oldFolder, folder + newFolder);
 830
 831          // Make sure caption is unique
 832          QString newCaption = parentFolderInfo->uniqueMenuCaption(folderInfo->caption);
 833          if (newCaption != folderInfo->caption)
 834          {
 835             folderInfo->setCaption(newCaption);
 836          }
 837
 838          // create the TreeItem
 839          if(parentItem)
 840            parentItem->setOpen(true);
 841
 842          // update fileInfo data
 843          folderInfo->updateFullId(parentFolderInfo->fullId);
 844          folderInfo->setInUse(true);
 845          parentFolderInfo->add(folderInfo);
 846
 847          if ((parentItem != oldParentItem) || !after)
 848          {
 849             if (oldParentItem)
 850                oldParentItem->takeItem(m_dragItem);
 851             else
 852                takeItem(m_dragItem);
 853             if (parentItem)
 854                parentItem->insertItem(m_dragItem);
 855             else
 856                insertItem(m_dragItem);
 857          }
 858          m_dragItem->moveItem(after);
 859          m_dragItem->setName(folderInfo->caption);
 860          m_dragItem->setDirectoryPath(folderInfo->fullId);
 861          setSelected(m_dragItem, true);
 862          itemSelected(m_dragItem);
 863       }
 864    }
 865    else if (command == MOVE_FILE)
 866    {
 867       MenuEntryInfo *entryInfo = m_dragItem->entryInfo();
 868       QString menuId = entryInfo->menuId();
 869
 870       if (e->action() == QDropEvent::Copy)
 871       {
 872
 873          // Need to copy file and then add it
 874          KDesktopFile *df = copyDesktopFile(entryInfo, &menuId, &m_newMenuIds); // Duplicate
 875 //UNDO-ACTION: NEW_MENU_ID (menuId)
 876
 877          KService::Ptr s(new KService(df));
 878          s->setMenuId(menuId);
 879
 880          entryInfo = new MenuEntryInfo(s, df);
 881
 882          QString oldCaption = entryInfo->caption;
 883          QString newCaption = parentFolderInfo->uniqueItemCaption(oldCaption, oldCaption);
 884          entryInfo->setCaption(newCaption);
 885       }
 886       else
 887       {
 888          del(m_dragItem, false);
 889          QString oldCaption = entryInfo->caption;
 890          QString newCaption = parentFolderInfo->uniqueItemCaption(oldCaption);
 891          entryInfo->setCaption(newCaption);
 892          entryInfo->setInUse(true);
 893       }
 894       // Add file to menu
 895       // m_menuFile->addEntry(folder, menuId);
 896       m_menuFile->pushAction(MenuFile::ADD_ENTRY, folder, menuId);
 897
 898       // create the TreeItem
 899       if(parentItem)
 900          parentItem->setOpen(true);
 901
 902       // update fileInfo data
 903       parentFolderInfo->add(entryInfo);
 904
 905       TreeItem *newItem = createTreeItem(parentItem, after, entryInfo, true);
 906
 907       setSelected ( newItem, true);
 908       itemSelected( newItem);
 909    }
 910    else if (command == COPY_SEPARATOR)
 911    {
 912       if (e->action() != QDropEvent::Copy)
 913          del(m_dragItem, false);
 914
 915       TreeItem *newItem = createTreeItem(parentItem, after, m_separator, true);
 916
 917       setSelected ( newItem, true);
 918       itemSelected( newItem);
 919    }
 920    else
 921    {
 922       // Error
 923    }
 924    m_drag = 0;
 925    setLayoutDirty(parentItem);
 926 }
 927
 928
 929 void TreeView::startDrag()
 930 {
 931   Q3DragObject *drag = dragObject();
 932
 933   if (!drag)
 934      return;
 935
 936   drag->dragMove();
 937 }
 938
 939 Q3DragObject *TreeView::dragObject()
 940 {
 941     m_dragPath.clear();
 942     TreeItem *item = (TreeItem*)selectedItem();
 943     if(item == 0) return 0;
 944
 945     K3MultipleDrag *drag = new K3MultipleDrag( this );
 946
 947     if (item->isDirectory())
 948     {
 949        m_drag = MOVE_FOLDER;
 950        m_dragInfo = item->folderInfo();
 951        m_dragItem = item;
 952     }
 953     else if (item->isEntry())
 954     {
 955        m_drag = MOVE_FILE;
 956        m_dragInfo = 0;
 957        m_dragItem = item;
 958        QString menuId = item->menuId();
 959        m_dragPath = item->entryInfo()->service->entryPath();
 960        if (!m_dragPath.isEmpty())
 961           m_dragPath = KStandardDirs::locate("apps", m_dragPath);
 962        if (!m_dragPath.isEmpty())
 963        {
 964           KUrl url;
 965           url.setPath(m_dragPath);
 966           drag->addDragObject( new K3URLDrag(url, 0));
 967        }
 968     }
 969     else
 970     {
 971        m_drag = COPY_SEPARATOR;
 972        m_dragInfo = 0;
 973        m_dragItem = item;
 974     }
 975
 976     drag->addDragObject( new Q3StoredDrag("application/x-kmenuedit-internal", 0));
 977     if ( item->pixmap(0) )
 978         drag->setPixmap(*item->pixmap(0));
 979     return drag;
 980 }
 981
 982 void TreeView::slotRMBPressed(Q3ListViewItem*, const QPoint& p)
 983 {
 984     TreeItem *item = (TreeItem*)selectedItem();
 985     if(item == 0) return;
 986
 987     if(m_rmb) m_rmb->exec(p);
 988 }
 989
 990 void TreeView::newsubmenu()
 991 {
 992    TreeItem *parentItem = 0;
 993    TreeItem *item = (TreeItem*)selectedItem();
 994
 995    bool ok;
 996    QString caption = KInputDialog::getText( i18n( "New Submenu" ),
 997         i18n( "Submenu name:" ), QString(), &ok, this );
 998
 999    if (!ok) return;
1000
1001    QString file = caption;
1002    file.replace('/', '-');
1003
1004    file = createDirectoryFile(file, &m_newDirectoryList); // Create
1005
1006    // get destination folder
1007    QString folder;
1008
1009    if(!item)
1010    {
1011       parentItem = 0;
1012       folder.clear();
1013    }
1014    else if(item->isDirectory())
1015    {
1016       parentItem = item;
1017       item = 0;
1018       folder = parentItem->directory();
1019    }
1020    else
1021    {
1022       parentItem = static_cast<TreeItem*>(item->parent());
1023       folder = parentItem ? parentItem->directory() : QString();
1024    }
1025
1026    MenuFolderInfo *parentFolderInfo = parentItem ? parentItem->folderInfo() : m_rootFolder;
1027    MenuFolderInfo *folderInfo = new MenuFolderInfo();
1028    folderInfo->caption = parentFolderInfo->uniqueMenuCaption(caption);
1029    folderInfo->id = m_menuFile->uniqueMenuName(folder, caption, parentFolderInfo->existingMenuIds());
1030    folderInfo->directoryFile = file;
1031    folderInfo->icon = "package";
1032    folderInfo->hidden = false;
1033    folderInfo->setDirty();
1034
1035    KDesktopFile *df = new KDesktopFile(file);
1036    KConfigGroup desktopGroup = df->desktopGroup();
1037    desktopGroup.writeEntry("Name", folderInfo->caption);
1038    desktopGroup.writeEntry("Icon", folderInfo->icon);
1039    df->sync();
1040    delete df;
1041    // Add file to menu
1042    // m_menuFile->addMenu(folder + folderInfo->id, file);
1043    m_menuFile->pushAction(MenuFile::ADD_MENU, folder + folderInfo->id, file);
1044
1045    folderInfo->fullId = parentFolderInfo->fullId + folderInfo->id;
1046
1047    // create the TreeItem
1048    if(parentItem)
1049       parentItem->setOpen(true);
1050
1051    // update fileInfo data
1052    parentFolderInfo->add(folderInfo);
1053
1054    TreeItem *newItem = createTreeItem(parentItem, item, folderInfo, true);
1055
1056    setSelected ( newItem, true);
1057    itemSelected( newItem);
1058
1059    setLayoutDirty(parentItem);
1060 }
1061
1062 void TreeView::newitem()
1063 {
1064    TreeItem *parentItem = 0;
1065    TreeItem *item = (TreeItem*)selectedItem();
1066
1067    bool ok;
1068    QString caption = KInputDialog::getText( i18n( "New Item" ),
1069         i18n( "Item name:" ), QString(), &ok, this );
1070
1071    if (!ok) return;
1072
1073    QString menuId;
1074    QString file = caption;
1075    file.replace('/', '-');
1076
1077    file = createDesktopFile(file, &menuId, &m_newMenuIds); // Create
1078
1079    KDesktopFile *df = new KDesktopFile(file);
1080    KConfigGroup desktopGroup = df->desktopGroup();
1081    desktopGroup.writeEntry("Name", caption);
1082    desktopGroup.writeEntry("Type", "Application");
1083
1084    // get destination folder
1085    QString folder;
1086
1087    if(!item)
1088    {
1089       parentItem = 0;
1090       folder.clear();
1091    }
1092    else if(item->isDirectory())
1093    {
1094       parentItem = item;
1095       item = 0;
1096       folder = parentItem->directory();
1097    }
1098    else
1099    {
1100       parentItem = static_cast<TreeItem*>(item->parent());
1101       folder = parentItem ? parentItem->directory() : QString();
1102    }
1103
1104    MenuFolderInfo *parentFolderInfo = parentItem ? parentItem->folderInfo() : m_rootFolder;
1105
1106    // Add file to menu
1107    // m_menuFile->addEntry(folder, menuId);
1108    m_menuFile->pushAction(MenuFile::ADD_ENTRY, folder, menuId);
1109
1110    KService::Ptr s(new KService(df));
1111    s->setMenuId(menuId);
1112
1113    MenuEntryInfo *entryInfo = new MenuEntryInfo(s, df);
1114
1115    // create the TreeItem
1116    if(parentItem)
1117       parentItem->setOpen(true);
1118
1119    // update fileInfo data
1120    parentFolderInfo->add(entryInfo);
1121
1122    TreeItem *newItem = createTreeItem(parentItem, item, entryInfo, true);
1123
1124    setSelected ( newItem, true);
1125    itemSelected( newItem);
1126
1127    setLayoutDirty(parentItem);
1128 }
1129
1130 void TreeView::newsep()
1131 {
1132    TreeItem *parentItem = 0;
1133    TreeItem *item = (TreeItem*)selectedItem();
1134
1135    if(!item)
1136    {
1137       parentItem = 0;
1138    }
1139    else if(item->isDirectory())
1140    {
1141       parentItem = item;
1142       item = 0;
1143    }
1144    else
1145    {
1146       parentItem = static_cast<TreeItem*>(item->parent());
1147    }
1148
1149    // create the TreeItem
1150    if(parentItem)
1151       parentItem->setOpen(true);
1152
1153    TreeItem *newItem = createTreeItem(parentItem, item, m_separator, true);
1154
1155    setSelected ( newItem, true);
1156    itemSelected( newItem);
1157
1158    setLayoutDirty(parentItem);
1159 }
1160
1161 void TreeView::cut()
1162 {
1163     copy( true );
1164
1165     m_ac->action("edit_cut")->setEnabled(false);
1166     m_ac->action("edit_copy")->setEnabled(false);
1167     m_ac->action("delete")->setEnabled(false);
1168
1169     // Select new current item
1170     setSelected( currentItem(), true );
1171     // Switch the UI to show that item
1172     itemSelected( selectedItem() );
1173 }
1174
1175 void TreeView::copy()
1176 {
1177     copy( false );
1178 }
1179
1180 void TreeView::copy( bool cutting )
1181 {
1182     TreeItem *item = (TreeItem*)selectedItem();
1183
1184     // nil selected? -> nil to copy
1185     if (item == 0) return;
1186
1187     if (cutting)
1188        setLayoutDirty((TreeItem*)item->parent());
1189
1190     // clean up old stuff
1191     cleanupClipboard();
1192
1193     // is item a folder or a file?
1194     if(item->isDirectory())
1195     {
1196         QString folder = item->directory();
1197         if (cutting)
1198         {
1199            // Place in clipboard
1200            m_clipboard = MOVE_FOLDER;
1201            m_clipboardFolderInfo = item->folderInfo();
1202
1203            del(item, false);
1204         }
1205         else
1206         {
1207            // Place in clipboard
1208            m_clipboard = COPY_FOLDER;
1209            m_clipboardFolderInfo = item->folderInfo();
1210         }
1211     }
1212     else if (item->isEntry())
1213     {
1214         if (cutting)
1215         {
1216            // Place in clipboard
1217            m_clipboard = MOVE_FILE;
1218            m_clipboardEntryInfo = item->entryInfo();
1219
1220            del(item, false);
1221         }
1222         else
1223         {
1224            // Place in clipboard
1225            m_clipboard = COPY_FILE;
1226            m_clipboardEntryInfo = item->entryInfo();
1227         }
1228     }
1229     else
1230     {
1231         // Place in clipboard
1232         m_clipboard = COPY_SEPARATOR;
1233         if (cutting)
1234            del(item, false);
1235     }
1236
1237     m_ac->action("edit_paste")->setEnabled(true);
1238 }
1239
1240
1241 void TreeView::paste()
1242 {
1243    TreeItem *parentItem = 0;
1244    TreeItem *item = (TreeItem*)selectedItem();
1245
1246    // nil selected? -> nil to paste to
1247    if (item == 0) return;
1248
1249    // is there content in the clipboard?
1250    if (!m_clipboard) return;
1251
1252    // get destination folder
1253    QString folder;
1254
1255    if(item->isDirectory())
1256    {
1257       parentItem = item;
1258       item = 0;
1259       folder = parentItem->directory();
1260    }
1261    else
1262    {
1263       parentItem = static_cast<TreeItem*>(item->parent());
1264       folder = parentItem ? parentItem->directory() : QString();
1265    }
1266
1267    MenuFolderInfo *parentFolderInfo = parentItem ? parentItem->folderInfo() : m_rootFolder;
1268    int command = m_clipboard;
1269    if ((command == COPY_FOLDER) || (command == MOVE_FOLDER))
1270    {
1271       MenuFolderInfo *folderInfo = m_clipboardFolderInfo;
1272       if (command == COPY_FOLDER)
1273       {
1274          // Ugh.. this is hard :)
1275          // * Create new .directory file
1276          // Add
1277       }
1278       else if (command == MOVE_FOLDER)
1279       {
1280          // Move menu
1281          QString oldFolder = folderInfo->fullId;
1282          QString folderName = folderInfo->id;
1283          QString newFolder = m_menuFile->uniqueMenuName(folder, folderName, parentFolderInfo->existingMenuIds());
1284          folderInfo->id = newFolder;
1285
1286          // Add file to menu
1287          // m_menuFile->moveMenu(oldFolder, folder + newFolder);
1288          m_menuFile->pushAction(MenuFile::MOVE_MENU, oldFolder, folder + newFolder);
1289
1290          // Make sure caption is unique
1291          QString newCaption = parentFolderInfo->uniqueMenuCaption(folderInfo->caption);
1292          if (newCaption != folderInfo->caption)
1293          {
1294             folderInfo->setCaption(newCaption);
1295          }
1296          // create the TreeItem
1297          if(parentItem)
1298              parentItem->setOpen(true);
1299
1300          // update fileInfo data
1301          folderInfo->fullId = parentFolderInfo->fullId + folderInfo->id;
1302          folderInfo->setInUse(true);
1303          parentFolderInfo->add(folderInfo);
1304
1305          TreeItem *newItem = createTreeItem(parentItem, item, folderInfo);
1306
1307          setSelected ( newItem, true);
1308          itemSelected( newItem);
1309       }
1310
1311       m_clipboard = COPY_FOLDER; // Next one copies.
1312    }
1313    else if ((command == COPY_FILE) || (command == MOVE_FILE))
1314    {
1315       MenuEntryInfo *entryInfo = m_clipboardEntryInfo;
1316       QString menuId;
1317
1318       if (command == COPY_FILE)
1319       {
1320          // Need to copy file and then add it
1321          KDesktopFile *df = copyDesktopFile(entryInfo, &menuId, &m_newMenuIds); // Duplicate
1322
1323          KService::Ptr s(new KService(df));
1324          s->setMenuId(menuId);
1325          entryInfo = new MenuEntryInfo(s, df);
1326
1327          QString oldCaption = entryInfo->caption;
1328          QString newCaption = parentFolderInfo->uniqueItemCaption(oldCaption, oldCaption);
1329          entryInfo->setCaption(newCaption);
1330       }
1331       else if (command == MOVE_FILE)
1332       {
1333          menuId = entryInfo->menuId();
1334          m_clipboard = COPY_FILE; // Next one copies.
1335
1336          QString oldCaption = entryInfo->caption;
1337          QString newCaption = parentFolderInfo->uniqueItemCaption(oldCaption);
1338          entryInfo->setCaption(newCaption);
1339          entryInfo->setInUse(true);
1340       }
1341       // Add file to menu
1342       // m_menuFile->addEntry(folder, menuId);
1343       m_menuFile->pushAction(MenuFile::ADD_ENTRY, folder, menuId);
1344
1345       // create the TreeItem
1346       if(parentItem)
1347          parentItem->setOpen(true);
1348
1349       // update fileInfo data
1350       parentFolderInfo->add(entryInfo);
1351
1352       TreeItem *newItem = createTreeItem(parentItem, item, entryInfo, true);
1353
1354       setSelected ( newItem, true);
1355       itemSelected( newItem);
1356    }
1357    else
1358    {
1359       // create separator
1360       if(parentItem)
1361          parentItem->setOpen(true);
1362
1363       TreeItem *newItem = createTreeItem(parentItem, item, m_separator, true);
1364
1365       setSelected ( newItem, true);
1366       itemSelected( newItem);
1367    }
1368    setLayoutDirty(parentItem);
1369 }
1370
1371 void TreeView::del()
1372 {
1373     TreeItem *item = (TreeItem*)selectedItem();
1374
1375     // nil selected? -> nil to delete
1376     if (item == 0) return;
1377
1378     del(item, true);
1379
1380     m_ac->action("edit_cut")->setEnabled(false);
1381     m_ac->action("edit_copy")->setEnabled(false);
1382     m_ac->action("delete")->setEnabled(false);
1383     // Select new current item
1384     setSelected( currentItem(), true );
1385     // Switch the UI to show that item
1386     itemSelected( selectedItem() );
1387 }
1388
1389 void TreeView::del(TreeItem *item, bool deleteInfo)
1390 {
1391     TreeItem *parentItem = static_cast<TreeItem*>(item->parent());
1392     // is file a .directory or a .desktop file
1393     if(item->isDirectory())
1394     {
1395         MenuFolderInfo *folderInfo = item->folderInfo();
1396
1397         // Remove MenuFolderInfo
1398         MenuFolderInfo *parentFolderInfo = parentItem ? parentItem->folderInfo() : m_rootFolder;
1399         parentFolderInfo->take(folderInfo);
1400         folderInfo->setInUse(false);
1401
1402         if (m_clipboard == COPY_FOLDER && (m_clipboardFolderInfo == folderInfo))
1403         {
1404            // Copy + Del == Cut
1405            m_clipboard = MOVE_FOLDER; // Clipboard now owns folderInfo
1406
1407         }
1408         else
1409         {
1410            if (folderInfo->takeRecursive(m_clipboardFolderInfo))
1411               m_clipboard = MOVE_FOLDER; // Clipboard now owns m_clipboardFolderInfo
1412
1413            if (deleteInfo)
1414               delete folderInfo; // Delete folderInfo
1415         }
1416
1417         // Remove from menu
1418         // m_menuFile->removeMenu(item->directory());
1419         m_menuFile->pushAction(MenuFile::REMOVE_MENU, item->directory(), QString());
1420
1421         // Remove tree item
1422         delete item;
1423     }
1424     else if (item->isEntry())
1425     {
1426         MenuEntryInfo *entryInfo = item->entryInfo();
1427         QString menuId = entryInfo->menuId();
1428
1429         // Remove MenuFolderInfo
1430         MenuFolderInfo *parentFolderInfo = parentItem ? parentItem->folderInfo() : m_rootFolder;
1431         parentFolderInfo->take(entryInfo);
1432         entryInfo->setInUse(false);
1433
1434         if (m_clipboard == COPY_FILE && (m_clipboardEntryInfo == entryInfo))
1435         {
1436            // Copy + Del == Cut
1437            m_clipboard = MOVE_FILE; // Clipboard now owns entryInfo
1438         }
1439         else
1440         {
1441            if (deleteInfo)
1442               delete entryInfo; // Delete entryInfo
1443         }
1444
1445         // Remove from menu
1446         QString folder = parentItem ? parentItem->directory() : QString();
1447         // m_menuFile->removeEntry(folder, menuId);
1448         m_menuFile->pushAction(MenuFile::REMOVE_ENTRY, folder, menuId);
1449
1450         // Remove tree item
1451         delete item;
1452     }
1453     else
1454     {
1455         // Remove separator
1456         delete item;
1457     }
1458     setLayoutDirty(parentItem);
1459 }
1460
1461 void TreeView::cleanupClipboard() {
1462     if (m_clipboard == MOVE_FOLDER)
1463        delete m_clipboardFolderInfo;
1464     m_clipboardFolderInfo = 0;
1465
1466     if (m_clipboard == MOVE_FILE)
1467        delete m_clipboardEntryInfo;
1468     m_clipboardEntryInfo = 0;
1469
1470     m_clipboard = 0;
1471 }
1472
1473 static QStringList extractLayout(TreeItem *item)
1474 {
1475     bool firstFolder = true;
1476     bool firstEntry = true;
1477     QStringList layout;
1478     for(;item; item = static_cast<TreeItem*>(item->nextSibling()))
1479     {
1480        if (item->isDirectory())
1481        {
1482           if (firstFolder)
1483           {
1484              firstFolder = false;
1485              layout << ":M"; // Add new folders here...
1486           }
1487           layout << (item->folderInfo()->id);
1488        }
1489        else if (item->isEntry())
1490        {
1491           if (firstEntry)
1492           {
1493              firstEntry = false;
1494              layout << ":F"; // Add new entries here...
1495           }
1496           layout << (item->entryInfo()->menuId());
1497        }
1498        else
1499        {
1500           layout << ":S";
1501        }
1502     }
1503     return layout;
1504 }
1505
1506 QStringList TreeItem::layout()
1507 {
1508     QStringList layout = extractLayout(static_cast<TreeItem*>(firstChild()));
1509     _layoutDirty = false;
1510     return layout;
1511 }
1512
1513 void TreeView::saveLayout()
1514 {
1515     if (m_layoutDirty)
1516     {
1517        QStringList layout = extractLayout(static_cast<TreeItem*>(firstChild()));
1518        m_menuFile->setLayout(m_rootFolder->fullId, layout);
1519        m_layoutDirty = false;
1520     }
1521
1522     Q3PtrList<Q3ListViewItem> lst;
1523     Q3ListViewItemIterator it( this );
1524     while ( it.current() ) {
1525        TreeItem *item = static_cast<TreeItem*>(it.current());
1526        if ( item->isLayoutDirty() )
1527        {
1528           m_menuFile->setLayout(item->folderInfo()->fullId, item->layout());
1529        }
1530        ++it;
1531     }
1532 }
1533
1534 bool TreeView::save()
1535 {
1536     saveLayout();
1537     m_rootFolder->save(m_menuFile);
1538
1539     bool success = m_menuFile->performAllActions();
1540
1541     m_newMenuIds.clear();
1542     m_newDirectoryList.clear();
1543
1544     if (success)
1545     {
1546        KBuildSycocaProgressDialog::rebuildKSycoca(this);
1547     }
1548     else
1549     {
1550        KMessageBox::sorry(this, "<qt>"+i18n("Menu changes could not be saved because of the following problem:")+"<br><br>"+
1551                                 m_menuFile->error()+"</qt>");
1552     }
1553     return success;
1554 }
1555
1556 void TreeView::setLayoutDirty(TreeItem *parentItem)
1557 {
1558     if (parentItem)
1559        parentItem->setLayoutDirty();
1560     else
1561        m_layoutDirty = true;
1562 }
1563
1564 bool TreeView::isLayoutDirty()
1565 {
1566     Q3PtrList<Q3ListViewItem> lst;
1567     Q3ListViewItemIterator it( this );
1568     while ( it.current() ) {
1569        if ( static_cast<TreeItem*>(it.current())->isLayoutDirty() )
1570           return true;
1571        ++it;
1572     }
1573     return false;
1574 }
1575
1576 bool TreeView::dirty()
1577 {
1578     return m_layoutDirty || m_rootFolder->hasDirt() || m_menuFile->dirty() || isLayoutDirty();
1579 }
1580
1581 void TreeView::findServiceShortcut(const KShortcut&cut, KService::Ptr &service)
1582 {
1583     service = m_rootFolder->findServiceShortcut(cut);
1584 }
1585