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