diff options
Diffstat (limited to 'opensuse/tdebase/kickoff.diff')
| -rw-r--r-- | opensuse/tdebase/kickoff.diff | 9812 |
1 files changed, 9812 insertions, 0 deletions
diff --git a/opensuse/tdebase/kickoff.diff b/opensuse/tdebase/kickoff.diff new file mode 100644 index 000000000..e2d73f567 --- /dev/null +++ b/opensuse/tdebase/kickoff.diff @@ -0,0 +1,9812 @@ +--- taskbar/taskcontainer.cpp (Revision 849788) ++++ taskbar/taskcontainer.cpp (Revision 849791) +@@ -67,7 +67,11 @@ + discardNextMouseEvent(false), + aboutToActivate(false), + m_mouseOver(false), +- m_paintEventCompression(false) ++ animationTimer(0, "TaskContainer::animationTimer"), ++ dragSwitchTimer(0, "TaskContainer::dragSwitchTimer"), ++ attentionTimer(0, "TaskContainer::attentionTimer"), ++ m_paintEventCompression(false), ++ m_paintEventCompressionTimer(0, "TaskContainer::paintEventCompressionTimer") + { + init(); + setAcceptDrops(true); // Always enabled to activate task during drag&drop. +@@ -95,7 +99,11 @@ + discardNextMouseEvent(false), + aboutToActivate(false), + m_mouseOver(false), +- m_paintEventCompression(false) ++ animationTimer(0, "TaskContainer::animationTimer"), ++ dragSwitchTimer(0, "TaskContainer::dragSwitchTimer"), ++ attentionTimer(0, "TaskContainer::attentionTimer"), ++ m_paintEventCompression(false), ++ m_paintEventCompressionTimer(0, "TaskContainer::paintEventCompressionTimer") + { + init(); + setEnabled(false); +--- taskbar/taskbar.cpp 2009/11/20 21:00:26 1.1 ++++ taskbar/taskbar.cpp 2009/11/20 21:00:38 +@@ -59,7 +59,8 @@ + m_showIcon(false), + m_showOnlyIconified(false), + m_textShadowEngine(0), +- m_ignoreUpdates(false) ++ m_ignoreUpdates(false), ++ m_relayoutTimer(0, "TaskBar::m_relayoutTimer") + { + arrowType = LeftArrow; + blocklayout = true; +--- libkicker/panelbutton.h (Revision 849788) ++++ libkicker/panelbutton.h (Revision 849791) +@@ -254,9 +254,11 @@ + /** + * Sets the direction to pop up the contents of the button. + */ +- void setPopupDirection(KPanelApplet::Direction d); ++ virtual void setPopupDirection(KPanelApplet::Direction d); + + protected: ++ ++ void setIconAlignment(AlignmentFlags align); + /** + * Subclasses must implement this to define the name of the button which is + * used to identify this button for saving and loading. It must be unique +@@ -391,6 +393,7 @@ + QPixmap m_iconz; // mouse over + KPanelExtension::Position m_arrowDirection; + KPanelApplet::Direction m_popupDirection; ++ AlignmentFlags m_iconAlignment; + Orientation m_orientation; + int m_size; + double m_fontPercent; +@@ -419,12 +422,12 @@ + * Sets the button's popup menu. + * @param popup the menu to pop up + */ +- void setPopup(QPopupMenu *popup); ++ void setPopup(QWidget *popup); + + /** + * @return the button's popup menu + */ +- QPopupMenu *popup() const; ++ QWidget *popup() const; + + bool eventFilter(QObject *, QEvent *); + virtual void showMenu(); +@@ -459,8 +462,8 @@ + private slots: + void menuAboutToHide(); + +-private: +- QPopupMenu *m_popup; ++protected: ++ QWidget *m_popup; + bool m_pressedDuringPopup; + bool m_initialized; + +--- libkicker/kickerSettings.kcfg (Revision 849788) ++++ libkicker/kickerSettings.kcfg (Revision 849791) +@@ -98,6 +98,70 @@ + <label>A list of extensions that have been loaded at runtime. In the case of a crash these extensions will not be loaded at the next Kicker start, in case they caused the crash</label> + </entry> + ++<entry name="LegacyKMenu" type="Bool" > ++ <label>When this option is enabled, the classic K Menu is used.</label> ++ <default>false</default> ++ </entry> ++ ++<entry name="OpenOnHover" type="Bool" > ++ <label>When this option is enabled, the SUSE Menu does open on mouse hover.</label> ++ <default>true</default> ++ </entry> ++ ++<entry name="ScrollFlipView" type="Bool" > ++ <label>When this option is enabled, the SUSE Menu application view switching will scroll.</label> ++ <default>true</default> ++ </entry> ++ ++<entry name="KMenuWidth" type="Int"> ++ <label>Preferred width of the KMenu</label> ++ <default>0</default> ++ </entry> ++ ++<entry name="KMenuHeight" type="Int"> ++ <label>Preferred width of the KMenu</label> ++ <default>0</default> ++ </entry> ++ ++<entry name="KickoffFontPointSizeOffset" type="Int" > ++ <label>With this option the scale of the fonts Kickoff uses can be influenced</label> ++ <default>0</default> ++ <min>-100</min> ++ <max>100</max> ++ </entry> ++ ++<entry name="KickoffSearchAddressBook" type="Bool" > ++ <label>When this option is enabled, kabc is utilized to search for addresses. This may start KMail.</label> ++ <default>false</default> ++ </entry> ++ ++<entry name="KickoffDrawGeekoEye" type="Bool" > ++ <label>When this option is enabled, the Geeko eye moves when the mouse hovers the start menu button</label> ++ <default>false</default> ++ </entry> ++ ++<entry name="KickoffTabBarFormat" type="Enum" > ++ <choices> ++ <choice name="LabelAndIcon"> ++ <label>Show names and icons on tabs</label> ++ </choice> ++ <choice name="LabelOnly"> ++ <label>Show only the names</label> ++ </choice> ++ <choice name="IconOnly"> ++ <label>Show only the icons</label> ++ </choice> ++ </choices> ++ <default>LabelAndIcon</default> ++ <label>Appearace of the Kickoff tabbar</label> ++ </entry> ++ ++<entry name="KickoffSwitchTabsOnHover" type="Bool" > ++ <label>When this option is enabled, the tabs in the Kickoff menu will switch without the need to click</label> ++ <default>true</default> ++ </entry> ++ ++ + </group> + + <group name="menus"> +@@ -172,6 +236,19 @@ + <default>false</default> + </entry> + ++<entry name="Favorites" type="StringList"> ++ <label>The menu entries shown in the Favorites tab</label> ++ </entry> ++ ++<entry name="FirstRun" type="Bool" > ++ <label>Whether the panel has been started before or not</label> ++ <default>false</default> ++ </entry> ++ ++<entry name="FirstSeenApps" type="StringList"> ++ <label>When the applications were first seen by Kickoff</label> ++ </entry> ++ + </group> + + <group name="button_tiles"> +@@ -337,6 +414,29 @@ + + </group> + ++ <group name="SearchField"> ++ <entry key="History" type="PathList"> ++ <default></default> ++ <label></label> ++ <whatsthis></whatsthis> ++ </entry> ++ <entry key="HistoryLength" type="Int"> ++ <default>50</default> ++ <label></label> ++ <whatsthis></whatsthis> ++ </entry> ++ <entry key="CompletionItems" type="PathList"> ++ <default></default> ++ <label></label> ++ <whatsthis></whatsthis> ++ </entry> ++ <entry key="CompletionMode" type="Int"> ++ <default>2</default> ++ <label></label> ++ <whatsthis></whatsthis> ++ </entry> ++ </group> ++ + </kcfg> + + +--- libkicker/kickertip.cpp (Revision 849788) ++++ libkicker/kickertip.cpp (Revision 849791) +@@ -38,6 +38,7 @@ + + // putting this #include higher results in compile errors + #include <netwm.h> ++#include <assert.h> + + static const int DEFAULT_FRAMES_PER_SECOND = 30; + +@@ -71,14 +72,16 @@ + m_dissolveDelta(-1), + m_direction(KPanelApplet::Up), + m_dirty(false), +- m_toolTipsEnabled(KickerSettings::showToolTips()), +- m_tippingFor(0) ++ m_tippingFor(0), ++ m_timer(0, "KickerTip::m_timer"), ++ m_frameTimer(0, "KickerTip::m_frameTimer") + { + setFocusPolicy(NoFocus); + setBackgroundMode(NoBackground); + resize(0, 0); + hide(); + connect(&m_frameTimer, SIGNAL(timeout()), SLOT(internalUpdate())); ++ connect(kapp, SIGNAL(settingsChanged(SettingsCategory)), SLOT(slotSettingsChanged())); + } + + KickerTip::~KickerTip() +@@ -87,6 +90,11 @@ + delete m_mimeFactory; + } + ++void KickerTip::slotSettingsChanged() ++{ ++ QToolTip::setGloballyEnabled(KickerSettings::showToolTips()); ++} ++ + void KickerTip::display() + { + if (!tippingEnabled()) +@@ -192,9 +200,7 @@ + + void KickerTip::mousePressEvent(QMouseEvent * /*e*/) + { +- QToolTip::setGloballyEnabled(m_toolTipsEnabled); + m_timer.stop(); +- m_frameTimer.stop(); + hide(); + } + +@@ -395,8 +401,11 @@ + m_tippingEnabled--; + } + ++ assert(m_tippingEnabled >= -1); ++ + if (m_tippingEnabled < 1 && m_self) + { ++ m_self->m_timer.stop(); + m_self->hide(); + } + } +@@ -411,6 +420,8 @@ + m_tippingFor = 0; + m_frameTimer.stop(); + QWidget::hide(); ++ ++ QToolTip::setGloballyEnabled(KickerSettings::showToolTips()); + } + + bool KickerTip::eventFilter(QObject *object, QEvent *event) +@@ -439,7 +450,6 @@ + !qApp->activePopupWidget() && + !isTippingFor(widget)) + { +- m_toolTipsEnabled = QToolTip::isGloballyEnabled(); + QToolTip::setGloballyEnabled(false); + + tipFor(widget); +@@ -461,8 +471,6 @@ + } + break; + case QEvent::Leave: +- QToolTip::setGloballyEnabled(m_toolTipsEnabled); +- + m_timer.stop(); + + if (isTippingFor(widget) && isVisible()) +@@ -475,9 +483,7 @@ + tipFor(0); + break; + case QEvent::MouseButtonPress: +- QToolTip::setGloballyEnabled(m_toolTipsEnabled); + m_timer.stop(); +- m_frameTimer.stop(); + hide(); + default: + break; +--- libkicker/kickertip.h (Revision 849788) ++++ libkicker/kickertip.h (Revision 849791) +@@ -92,6 +92,7 @@ + void tipperDestroyed(QObject* o); + void internalUpdate(); + void display(); ++ void slotSettingsChanged(); + + private: + QBitmap m_mask; +@@ -108,7 +109,6 @@ + QTimer m_timer; + QTimer m_frameTimer; + bool m_dirty; +- bool m_toolTipsEnabled; + + const QWidget* m_tippingFor; + +--- libkicker/panelbutton.cpp (Revision 849788) ++++ libkicker/panelbutton.cpp (Revision 849791) +@@ -42,6 +42,7 @@ + #include <kipc.h> + #include <kstandarddirs.h> + #include <klocale.h> ++#include <kdebug.h> + + #include "global.h" + +@@ -65,6 +66,7 @@ + m_hasAcceptedDrag(false), + m_arrowDirection(KPanelExtension::Bottom), + m_popupDirection(KPanelApplet::Up), ++ m_iconAlignment(AlignCenter), + m_orientation(Horizontal), + m_size((KIcon::StdSizes)-1), + m_fontPercent(0.40) +@@ -186,6 +188,12 @@ + setArrowDirection(KickerLib::directionToPopupPosition(d)); + } + ++void PanelButton::setIconAlignment(AlignmentFlags align) ++{ ++ m_iconAlignment = align; ++ update(); ++} ++ + void PanelButton::setOrientation(Orientation o) + { + m_orientation = o; +@@ -300,7 +308,9 @@ + + int PanelButton::heightForWidth(int width) const + { +- return preferredDimension(width); ++ int rc=preferredDimension(width); ++ ++ return rc; + } + + const QPixmap& PanelButton::labelIcon() const +@@ -556,11 +566,16 @@ + icon.height() - 2); + } + ++ int y = 0; ++ if (m_iconAlignment & AlignVCenter) ++ y = (height() - icon.height()) / 2; ++ else if (m_iconAlignment & AlignBottom) ++ y = (height() - icon.height()); ++ + if (!m_buttonText.isEmpty() && orientation() == Horizontal) + { + int h = height(); + int w = width(); +- int y = (h - icon.height())/2; + p->save(); + QFont f = font(); + +@@ -629,8 +644,11 @@ + } + else if (!icon.isNull()) + { +- int y = (height() - icon.height()) / 2; +- int x = (width() - icon.width()) / 2; ++ int x = 0; ++ if (m_iconAlignment & AlignHCenter) ++ x = (width() - icon.width()) / 2; ++ else if (m_iconAlignment & AlignRight) ++ x = (width() - icon.width()); + p->drawPixmap(x, y, icon); + } + +@@ -792,7 +810,19 @@ + QString nm = m_iconName; + KIcon::States defaultState = isEnabled() ? KIcon::DefaultState : + KIcon::DisabledState; +- m_icon = ldr->loadIcon(nm, KIcon::Panel, m_size, defaultState, 0L, true); ++ if (nm=="kmenu-suse") ++ { ++ QString pth = locate( "data", "kicker/pics/kmenu_basic.mng" ); ++ if (!pth.isEmpty()) ++ { ++ m_icon = QImage(pth); ++ m_iconh = QPixmap(m_icon); ++ m_iconz = QPixmap(m_icon); ++ return; ++ } ++ } ++ else ++ m_icon = ldr->loadIcon(nm, KIcon::Panel, m_size, defaultState, 0L, true); + + if (m_icon.isNull()) + { +@@ -857,7 +887,7 @@ + connect(this, SIGNAL(pressed()), SLOT(slotExecMenu())); + } + +-void PanelPopupButton::setPopup(QPopupMenu *popup) ++void PanelPopupButton::setPopup(QWidget *popup) + { + if (m_popup) + { +@@ -875,7 +905,7 @@ + } + } + +-QPopupMenu *PanelPopupButton::popup() const ++QWidget *PanelPopupButton::popup() const + { + return m_popup; + } +@@ -954,7 +984,9 @@ + } + + m_popup->adjustSize(); +- m_popup->exec(KickerLib::popupPosition(popupDirection(), m_popup, this)); ++ if(dynamic_cast<QPopupMenu*>(m_popup)) ++ static_cast<QPopupMenu*>(m_popup)->exec(KickerLib::popupPosition(popupDirection(), m_popup, this)); ++ // else.. hmm. some derived class has to fix it. + } + + void PanelPopupButton::menuAboutToHide() +@@ -964,8 +996,10 @@ + return; + } + +- setDown(false); +- KickerTip::enableTipping(true); ++ if (isDown()) { ++ setDown(false); ++ KickerTip::enableTipping(true); ++ } + } + + void PanelPopupButton::triggerDrag() +@@ -983,3 +1017,5 @@ + m_initialized = initialized; + } + ++ ++ +--- extensions/kasbar/kasbar.cpp (Revision 849788) ++++ extensions/kasbar/kasbar.cpp (Revision 849791) +@@ -719,7 +719,7 @@ + i->setText( "Animated" ); + i->setIcon( KGlobal::iconLoader()->loadIcon( "icons", KIcon::NoGroup, KIcon::SizeMedium ) ); + i->setAnimation( resources()->startupAnimation() ); +- QTimer *aniTimer = new QTimer( i ); ++ QTimer *aniTimer = new QTimer( i, "aniTimer" ); + connect( aniTimer, SIGNAL( timeout() ), i, SLOT( advanceAnimation() ) ); + aniTimer->start( 100 ); + i->setShowAnimation( true ); +--- extensions/kasbar/kasclockitem.cpp (Revision 849788) ++++ extensions/kasbar/kasclockitem.cpp (Revision 849791) +@@ -38,7 +38,7 @@ + { + setCustomPopup( true ); + +- QTimer *t = new QTimer( this ); ++ QTimer *t = new QTimer( this, "t" ); + connect( t, SIGNAL( timeout() ), SLOT( updateTime() ) ); + t->start( 1000 ); + +--- extensions/kasbar/kasstartupitem.cpp (Revision 849788) ++++ extensions/kasbar/kasstartupitem.cpp (Revision 849791) +@@ -79,7 +79,7 @@ + setShowFrame( false ); + setAnimation( resources()->startupAnimation() ); + +- aniTimer = new QTimer( this ); ++ aniTimer = new QTimer( this, "aniTimer" ); + connect( aniTimer, SIGNAL( timeout() ), SLOT( aniTimerFired() ) ); + aniTimer->start( 100 ); + } +--- extensions/kasbar/kasloaditem.cpp (Revision 849788) ++++ extensions/kasbar/kasloaditem.cpp (Revision 849791) +@@ -33,7 +33,7 @@ + KasLoadItem::KasLoadItem( KasBar *parent ) + : KasItem( parent ) + { +- QTimer *t = new QTimer( this ); ++ QTimer *t = new QTimer( this, "KasLoadItem::t" ); + connect( t, SIGNAL( timeout() ), SLOT( updateDisplay() ) ); + t->start( 1000 ); + updateDisplay(); +--- kicker/interfaces/kickoff-search-plugin.h (Revision 0) ++++ kicker/interfaces/kickoff-search-plugin.h (Revision 849791) +@@ -0,0 +1,106 @@ ++/*************************************************************************** ++ * Copyright (C) 2006 by Stephan Binner <binner@kde.org> * ++ * Copyright (c) 2006 Debajyoti Bera <dbera.web@gmail.com> * ++ * * ++ * This program is free software; you can redistribute it and/or modify * ++ * it under the terms of the GNU General Public License as published by * ++ * the Free Software Foundation; either version 2 of the License, or * ++ * (at your option) any later version. * ++ * * ++ * This program is distributed in the hope that it will be useful, * ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of * ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * ++ * GNU General Public License for more details. * ++ * * ++ * You should have received a copy of the GNU General Public License * ++ * along with this program; if not, write to the * ++ * Free Software Foundation, Inc., * ++ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * ++ ***************************************************************************/ ++ ++#ifndef KICKOFF_SEARCH_PLUGIN_H ++#define KICKOFF_SEARCH_PLUGIN_H ++ ++#include "kickoffsearchinterface.h" ++ ++#include <qobject.h> ++#include <kurl.h> ++#include <kservice.h> ++ ++typedef enum { ++ ACTIONS = 0, ++ APPS, ++ BOOKMARKS, ++ NOTES, ++ MAILS, ++ FILES, ++ MUSIC, ++ WEBHIST, ++ CHATS, ++ FEEDS, ++ PICS, ++ VIDEOS, ++ DOCS, ++ OTHER, ++ num_categories ++} CATEGORY; ++ ++class HitMenuItem ++{ ++public: ++ HitMenuItem (int id, int category) ++ : id (id), category (category),score(0) { } /* dummy */ ++ HitMenuItem (QString name, QString info, KURL uri, QString mimetype, int id, int category, QString icon=QString::null, int score = 0) ++ : display_name (name) ++ , display_info (info) ++ , uri (uri) ++ , mimetype (mimetype) ++ , id (id) ++ , category (category) ++ , icon (icon) ++ , score (score) ++ , service (NULL) { } ++ ++ ~HitMenuItem () { } ++ ++ bool operator< (HitMenuItem item) ++ { ++ return ((category == item.category && score > item.score) || (category == item.category && id < item.id) || ++ (category < item.category)); ++ } ++ ++ // FIXME: We dont really need to store display_name and display_info ++ QString display_name; // name to display ++ QString display_info; // other information to display ++ KURL uri; // uri to open when clicked ++ QString mimetype; ++ int id; // id of the item in the menu ++ int category; ++ QString icon; ++ int score; ++ KService::Ptr service; ++ ++ QString quotedPath () const ++ { ++ return uri.path ().replace ('"', "\\\""); ++ } ++}; ++ ++namespace KickoffSearch { ++ ++ class Plugin : public QObject ++ { ++ Q_OBJECT ++ ++ public: ++ Plugin(QObject *parent, const char* name=0); ++ virtual ~Plugin(); ++ ++ virtual bool daemonRunning()=0; ++ virtual void query(QString,bool)=0; ++ ++ KickoffSearchInterface * kickoffSearchInterface(); ++ }; ++}; ++ ++#endif /* KICKOFF_SEARCH_PLUGIN_H */ +--- kicker/interfaces/kickoffsearchinterface.cpp (Revision 0) ++++ kicker/interfaces/kickoffsearchinterface.cpp (Revision 849791) +@@ -0,0 +1,27 @@ ++/*************************************************************************** ++ * Copyright (C) 2006 by Stephan Binner <binner@kde.org> * ++ * * ++ * This program is free software; you can redistribute it and/or modify * ++ * it under the terms of the GNU General Public License as published by * ++ * the Free Software Foundation; either version 2 of the License, or * ++ * (at your option) any later version. * ++ * * ++ * This program is distributed in the hope that it will be useful, * ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of * ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * ++ * GNU General Public License for more details. * ++ * * ++ * You should have received a copy of the GNU General Public License * ++ * along with this program; if not, write to the * ++ * Free Software Foundation, Inc., * ++ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * ++ ***************************************************************************/ ++ ++#include "kickoffsearchinterface.h" ++ ++KickoffSearch::KickoffSearchInterface::KickoffSearchInterface( QObject* parent, const char* name ) ++ :QObject( parent, name ) ++{ ++} ++ ++#include "kickoffsearchinterface.moc" +--- kicker/interfaces/Makefile.am (Revision 0) ++++ kicker/interfaces/Makefile.am (Revision 849791) +@@ -0,0 +1,12 @@ ++METASOURCES = AUTO ++INCLUDES= -I$(top_srcdir)/src $(all_includes) ++ ++# The library containing the plugin base class ++lib_LTLIBRARIES = libkickoffsearch_interfaces.la ++libkickoffsearch_interfaces_la_SOURCES = kickoff-search-plugin.cpp kickoffsearchinterface.cpp ++libkickoffsearch_interfaces_la_LDFLAGS = $(all_libraries) -version-info 0:0:0 ++ ++kickoffsearchincludedir = $(includedir) ++kickoffsearchinclude_HEADERS = kickoff-search-plugin.h kickoffsearchinterface.h ++ ++kde_servicetypes_DATA = kickoffsearchplugin.desktop +--- kicker/interfaces/kickoffsearchinterface.h (Revision 0) ++++ kicker/interfaces/kickoffsearchinterface.h (Revision 849791) +@@ -0,0 +1,46 @@ ++/*************************************************************************** ++ * Copyright (C) 2006 by Stephan Binner <binner@kde.org> * ++ * * ++ * This program is free software; you can redistribute it and/or modify * ++ * it under the terms of the GNU General Public License as published by * ++ * the Free Software Foundation; either version 2 of the License, or * ++ * (at your option) any later version. * ++ * * ++ * This program is distributed in the hope that it will be useful, * ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of * ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * ++ * GNU General Public License for more details. * ++ * * ++ * You should have received a copy of the GNU General Public License * ++ * along with this program; if not, write to the * ++ * Free Software Foundation, Inc., * ++ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * ++ ***************************************************************************/ ++ ++#ifndef KICKOFFSEARCHINTERFACE_H ++#define KICKOFFSEARCHINTERFACE_H ++ ++#include <qobject.h> ++ ++class HitMenuItem; ++ ++namespace KickoffSearch ++{ ++ class KickoffSearchInterface :public QObject ++ { ++ Q_OBJECT ++ ++ public: ++ KickoffSearchInterface( QObject* parent, const char* name = 0); ++ ++ public: ++ virtual bool anotherHitMenuItemAllowed(int cat) = 0; ++ virtual void addHitMenuItem(HitMenuItem* item) = 0; ++ virtual void searchOver() = 0; ++ virtual void initCategoryTitlesUpdate() = 0; ++ virtual void updateCategoryTitles() = 0; ++ }; ++} ++ ++#endif /* SELECTIONINTERFACE_H */ ++ +--- kicker/interfaces/kickoffsearchplugin.desktop (Revision 0) ++++ kicker/interfaces/kickoffsearchplugin.desktop (Revision 849791) +@@ -0,0 +1,4 @@ ++[Desktop Entry] ++Type=ServiceType ++X-KDE-ServiceType=KickoffSearch/Plugin ++Comment=A search plugin for Kickoff +--- kicker/interfaces/kickoff-search-plugin.cpp (Revision 0) ++++ kicker/interfaces/kickoff-search-plugin.cpp (Revision 849791) +@@ -0,0 +1,37 @@ ++/*************************************************************************** ++ * Copyright (C) 2006 by Stephan Binner <binner@kde.org> * ++ * * ++ * This program is free software; you can redistribute it and/or modify * ++ * it under the terms of the GNU General Public License as published by * ++ * the Free Software Foundation; either version 2 of the License, or * ++ * (at your option) any later version. * ++ * * ++ * This program is distributed in the hope that it will be useful, * ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of * ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * ++ * GNU General Public License for more details. * ++ * * ++ * You should have received a copy of the GNU General Public License * ++ * along with this program; if not, write to the * ++ * Free Software Foundation, Inc., * ++ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * ++ ***************************************************************************/ ++ ++#include "kickoff-search-plugin.h" ++#include <qobjectlist.h> ++ ++KickoffSearch::Plugin::Plugin(QObject *parent, const char* name ) ++ :QObject( parent, name ) ++{ ++} ++ ++KickoffSearch::Plugin::~Plugin() ++{ ++} ++ ++KickoffSearch::KickoffSearchInterface* KickoffSearch::Plugin::kickoffSearchInterface() ++{ ++ return static_cast<KickoffSearchInterface*>( parent()->child( 0, "KickoffSearch::KickoffSearchInterface" ) ); ++} ++ ++#include "kickoff-search-plugin.moc" + +Eigenschaftsänderungen: kicker/interfaces +___________________________________________________________________ +Hinzugefügt: svn:ignore + + .deps +libkickoffsearch_interfaces.la +.libs +Makefile +Makefile.in +*.moc + + +--- kicker/core/menumanager.h (Revision 849788) ++++ kicker/core/menumanager.h (Revision 849791) +@@ -28,7 +28,9 @@ + #include <qvaluelist.h> + + class PanelKMenu; ++class KMenu; + class KickerClientMenu; ++class KMenuStub; + class PanelPopupButton; + + typedef QValueList<PanelPopupButton*> KButtonList; +@@ -50,13 +52,12 @@ + bool process(const QCString &fun, const QByteArray &data, QCString& replyType, QByteArray &reply); + + // KMenu controls +- PanelKMenu* kmenu() { return m_kmenu; } +- void showKMenu(); ++ KMenuStub* kmenu() { return m_kmenu; } + void popupKMenu(const QPoint &p); + + void registerKButton(PanelPopupButton *button); + void unregisterKButton(PanelPopupButton *button); +- PanelPopupButton* findKButtonFor(QPopupMenu* menu); ++ PanelPopupButton* findKButtonFor(QWidget* menu); + ~MenuManager(); + + public slots: +@@ -67,7 +68,7 @@ + void applicationRemoved(const QCString&); + + protected: +- PanelKMenu* m_kmenu; ++ KMenuStub* m_kmenu; + typedef QValueList<KickerClientMenu*> ClientMenuList; + ClientMenuList clientmenus; + +--- kicker/core/kicker.cpp (Revision 849788) ++++ kicker/core/kicker.cpp (Revision 849791) +@@ -48,6 +48,8 @@ + #include "extensionmanager.h" + #include "pluginmanager.h" + #include "menumanager.h" ++#include "k_new_mnu.h" ++#include "k_mnu_stub.h" + #include "k_mnu.h" + #include "showdesktop.h" + #include "panelbutton.h" +@@ -106,6 +108,7 @@ + + KGlobal::iconLoader()->addExtraDesktopThemes(); + ++ KGlobal::locale()->insertCatalogue("kdmgreet"); + KGlobal::locale()->insertCatalogue("libkonq"); + KGlobal::locale()->insertCatalogue("libdmctl"); + KGlobal::locale()->insertCatalogue("libtaskbar"); +@@ -212,7 +215,7 @@ + + void Kicker::showKMenu() + { +- MenuManager::the()->showKMenu(); ++ MenuManager::the()->kmenuAccelActivated(); + } + + void Kicker::popupKMenu(const QPoint &p) +--- kicker/core/container_button.cpp (Revision 849788) ++++ kicker/core/container_button.cpp (Revision 849791) +@@ -43,6 +43,7 @@ + #include "desktopbutton.h" + #include "extensionbutton.h" + #include "kbutton.h" ++#include "knewbutton.h" + #include "kicker.h" + #include "kickerSettings.h" + #include "kickertip.h" +@@ -326,14 +327,20 @@ + : ButtonContainer(opMenu, parent) + { + checkImmutability(config); +- embedButton( new KButton(this) ); ++ if(KickerSettings::legacyKMenu()) ++ embedButton( new KButton(this) ); ++ else ++ embedButton( new KNewButton(this) ); + _actions = PanelAppletOpMenu::KMenuEditor; + } + + KMenuButtonContainer::KMenuButtonContainer(QPopupMenu *opMenu, QWidget* parent) + : ButtonContainer(opMenu, parent) + { +- embedButton( new KButton(this) ); ++ if(KickerSettings::legacyKMenu()) ++ embedButton( new KButton(this) ); ++ else ++ embedButton( new KNewButton(this) ); + _actions = PanelAppletOpMenu::KMenuEditor; + } + +--- kicker/core/main.cpp (Revision 849788) ++++ kicker/core/main.cpp (Revision 849791) +@@ -108,7 +108,7 @@ + appname.sprintf("kicker-screen-%d", kicker_screen_number); + + KAboutData aboutData( appname.data(), I18N_NOOP("KDE Panel"), +- version, description, KAboutData::License_BSD, ++ version, description, KAboutData::License_GPL_V2, + I18N_NOOP("(c) 1999-2004, The KDE Team") ); + + aboutData.addAuthor("Aaron J. Seigo", I18N_NOOP("Current maintainer"), "aseigo@kde.org"); +--- kicker/core/menumanager.cpp (Revision 849788) ++++ kicker/core/menumanager.cpp (Revision 849791) +@@ -31,9 +31,12 @@ + #include "client_mnu.h" + #include "container_extension.h" + #include "global.h" ++#include "k_new_mnu.h" + #include "k_mnu.h" ++#include "k_mnu_stub.h" + #include "kicker.h" + #include "panelbutton.h" ++#include "kickerSettings.h" + + #include "menumanager.h" + #include "menumanager.moc" +@@ -62,7 +65,11 @@ + MenuManager::MenuManager(QObject *parent) + : QObject(parent, "MenuManager"), DCOPObject("MenuManager") + { +- m_kmenu = new PanelKMenu; ++ if (KickerSettings::legacyKMenu()) ++ m_kmenu = new KMenuStub(new PanelKMenu); ++ else ++ m_kmenu = new KMenuStub(new KMenu); ++ + kapp->dcopClient()->setNotifications(true); + connect(kapp->dcopClient(), SIGNAL(applicationRemoved(const QCString&)), + this, SLOT(applicationRemoved(const QCString&))); +@@ -83,14 +90,8 @@ + m_kmenu->selectFirstItem(); + } + +-void MenuManager::showKMenu() +-{ +- m_kmenu->showMenu(); +-} +- + void MenuManager::popupKMenu(const QPoint &p) + { +-// kdDebug(1210) << "popupKMenu()" << endl; + if (m_kmenu->isVisible()) + { + m_kmenu->hide(); +@@ -120,7 +121,7 @@ + m_kbuttons.remove(button); + } + +-PanelPopupButton* MenuManager::findKButtonFor(QPopupMenu* menu) ++PanelPopupButton* MenuManager::findKButtonFor(QWidget* menu) + { + KButtonList::const_iterator itEnd = m_kbuttons.constEnd(); + for (KButtonList::const_iterator it = m_kbuttons.constBegin(); it != itEnd; ++it) +@@ -169,7 +170,7 @@ + const QSize size = m_kmenu->sizeHint(); + m_kmenu->resize(size.width(),size.height()); + +- PanelPopupButton* button = findKButtonFor(m_kmenu); ++ PanelPopupButton* button = findKButtonFor(m_kmenu->widget()); + + // let's unhide the panel while we're at it. traverse the widget + // hierarchy until we find the panel, if any +@@ -189,7 +190,6 @@ + + menuParent = menuParent->parent(); + } +- + button->showMenu(); + } + } +@@ -213,7 +213,7 @@ + + void MenuManager::removeMenu(QCString menu) + { +- bool iterate = true; ++ bool iterate = true, need_adjustSize = false; + ClientMenuList::iterator it = clientmenus.begin(); + for (; it != clientmenus.end(); iterate ? ++it : it) + { +@@ -224,15 +224,17 @@ + m_kmenu->removeClientMenu(m->idInParentMenu); + it = clientmenus.erase(it); + iterate = false; ++ need_adjustSize = true; + } + } +- m_kmenu->adjustSize(); ++ if (need_adjustSize) ++ m_kmenu->adjustSize(); + } + + + void MenuManager::applicationRemoved(const QCString& appRemoved) + { +- bool iterate = true; ++ bool iterate = true, need_adjustSize = false; + ClientMenuList::iterator it = clientmenus.begin(); + for (; it != clientmenus.end(); iterate ? ++it : it) + { +@@ -243,9 +245,11 @@ + m_kmenu->removeClientMenu(m->idInParentMenu); + it = clientmenus.erase(it); + iterate = false; ++ need_adjustSize = true; + } + } +- m_kmenu->adjustSize(); ++ if (need_adjustSize) ++ m_kmenu->adjustSize(); + } + + bool MenuManager::process(const QCString &fun, const QByteArray &data, +--- kicker/core/unhidetrigger.cpp (Revision 849788) ++++ kicker/core/unhidetrigger.cpp (Revision 849791) +@@ -39,7 +39,7 @@ + , _lastXineramaScreen( -1 ) + , enabledCount( 0 ) + { +- _timer = new QTimer( this ); ++ _timer = new QTimer( this, "UnhideTrigger" ); + connect( _timer, SIGNAL(timeout()), SLOT(pollMouse()) ); + } + +--- kicker/core/applethandle.cpp (Revision 849788) ++++ kicker/core/applethandle.cpp (Revision 849791) +@@ -150,7 +150,7 @@ + { + if (!m_handleHoverTimer) + { +- m_handleHoverTimer = new QTimer(this); ++ m_handleHoverTimer = new QTimer(this, "m_handleHoverTimer"); + connect(m_handleHoverTimer, SIGNAL(timeout()), + this, SLOT(checkHandleHover())); + m_applet->installEventFilter(this); +@@ -177,11 +177,7 @@ + m_drawHandle = true; + resetLayout(); + +- if (m_handleHoverTimer) +- { +- m_handleHoverTimer->start(250); +- } +- break; ++ break; + } + + case QEvent::Leave: +@@ -191,6 +187,11 @@ + break; + } + ++ if (m_handleHoverTimer) ++ { ++ m_handleHoverTimer->start(250); ++ } ++ + QWidget* w = dynamic_cast<QWidget*>(o); + + bool nowDrawIt = false; +@@ -207,11 +208,6 @@ + + if (nowDrawIt != m_drawHandle) + { +- if (m_handleHoverTimer) +- { +- m_handleHoverTimer->stop(); +- } +- + m_drawHandle = nowDrawIt; + resetLayout(); + } +@@ -297,6 +293,11 @@ + } + + m_menuButton->setDown(false); ++ ++ if (m_handleHoverTimer) ++ { ++ m_handleHoverTimer->start(250); ++ } + } + + AppletHandleDrag::AppletHandleDrag(AppletHandle* parent) +--- kicker/core/containerarea.cpp 2009/11/20 21:00:18 1.1 ++++ kicker/core/containerarea.cpp 2009/11/20 21:00:38 +@@ -87,7 +87,8 @@ + m_immutable(_c->isImmutable()), + m_updateBackgroundsCalled(false), + m_layout(0), +- m_addAppletDialog(0) ++ m_addAppletDialog(0), ++ _autoScrollTimer(0, "ContainerArea::autoScrollTimer") + { + setBackgroundOrigin( WidgetOrigin ); + +--- kicker/core/Makefile.am (Revision 849788) ++++ kicker/core/Makefile.am (Revision 849791) +@@ -1,6 +1,6 @@ + INCLUDES = -I$(srcdir)/../../libkicker -I../../libkicker \ +- -I$(srcdir)/../ui -I$(srcdir)/../buttons -I$(top_srcdir)/libkonq \ +- $(all_includes) ++ -I../ui -I$(srcdir)/../ui -I$(srcdir)/../buttons -I$(top_srcdir)/libkonq \ ++ $(all_includes) + + noinst_LTLIBRARIES = libkicker_core.la + +--- kicker/Makefile.am (Revision 849788) ++++ kicker/Makefile.am (Revision 849791) +@@ -1,6 +1,6 @@ + INCLUDES = $(all_includes) + +-SUBDIRS = core ui buttons . ++SUBDIRS = core ui buttons interfaces . + + bin_PROGRAMS = + lib_LTLIBRARIES = +@@ -9,7 +9,7 @@ + CLEANFILES = dummy.cpp + + kicker_la_LIBADD = core/libkicker_core.la buttons/libkicker_buttons.la \ +- ui/libkicker_ui.la ../libkicker/libkickermain.la $(LIB_KIO) $(LIB_KUTILS) ++ ui/libkicker_ui.la ../libkicker/libkickermain.la $(LIB_KIO) $(LIB_KUTILS) $(LIB_KABC) + + kicker_la_SOURCES = dummy.cpp + kicker_la_LDFLAGS = -module $(KDE_PLUGIN) $(all_libraries) +--- kicker/ui/browser_mnu.cpp (Revision 849788) ++++ kicker/ui/browser_mnu.cpp (Revision 849791) +@@ -329,7 +329,7 @@ + if(_mimemap.count() > 0) { + + if(!_mimecheckTimer) +- _mimecheckTimer = new QTimer(this); ++ _mimecheckTimer = new QTimer(this, "_mimecheckTimer"); + + connect(_mimecheckTimer, SIGNAL(timeout()), SLOT(slotMimeCheck())); + _mimecheckTimer->start(0); +--- kicker/ui/flipscrollview.cpp (Revision 0) ++++ kicker/ui/flipscrollview.cpp (Revision 849791) +@@ -0,0 +1,324 @@ ++/***************************************************************** ++ ++Copyright (c) 2006 Will Stephenson <wstephenson@novell.com> ++ ++Permission is hereby granted, free of charge, to any person obtaining a copy ++of this software and associated documentation files (the "Software"), to deal ++in the Software without restriction, including without limitation the rights ++to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++copies of the Software, and to permit persons to whom the Software is ++furnished to do so, subject to the following conditions: ++ ++The above copyright notice and this permission notice shall be included in ++all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN ++AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ ++******************************************************************/ ++ ++#include <qapplication.h> ++#include <qhbox.h> ++#include <qheader.h> ++#include <assert.h> ++ ++#include "itemview.h" ++#include "flipscrollview.h" ++#include "kickerSettings.h" ++ ++/* Flip scroll steps, as percentage of itemview width to scroll per ++ * step. Assumes the itemview is scrolled in ten steps */ ++ ++/* slow start, then fast */ ++//static const double scrollSteps[] = { 0.05, 0.05, 0.1125, 0.1125, 0.1125, 0.1125, 0.1125, 0.1125, 0.1125, 0.1125 }; ++ ++/* slow fast slow */ ++//static const double scrollSteps[] = { 0.05, 0.05, 0.13, 0.13, 0.15, 0.13, 0.13, 0.13, 0.05, 0.05 }; ++ ++/* slow veryfast slow */ ++static const double scrollSteps[] = { 0.03, 0.03, 0.147, 0.147, 0.147, 0.147, 0.147, 0.147, 0.03, 0.028 }; ++; ++ ++BackFrame::BackFrame( QWidget *parent ) ++ : QFrame( parent ), mouse_inside( false ) ++{ ++ setFrameStyle( QFrame::NoFrame ); ++ if ( QApplication::reverseLayout() ) ++ left_triangle.load( locate( "data", "kicker/pics/right_triangle.png" ) ); ++ else ++ left_triangle.load( locate( "data", "kicker/pics/left_triangle.png" ) ); ++} ++ ++void BackFrame::drawContents( QPainter *p ) ++{ ++ QColor gray( 230, 230, 230 ); ++ if ( mouse_inside ) ++ p->fillRect( 3, 3, width() - 6, height() - 6, colorGroup().color( QColorGroup::Highlight ) ); ++ else ++ p->fillRect( 3, 3, width() - 6, height() - 6, gray ); ++ p->setPen( gray.dark(110) ); ++ p->drawRect( 3, 3, width() - 6, height() - 6 ); ++ ++ int pixsize = ( width() - 6 ) * 3 / 5; ++ QImage i = left_triangle.convertToImage().smoothScale( pixsize, pixsize ); ++ QPixmap tri; ++ tri.convertFromImage( i ); ++ ++ p->drawPixmap( ( width() - tri.width() ) / 2, ( height() - tri.height() ) / 2, tri ); ++} ++ ++void BackFrame::enterEvent( QEvent *e ) ++{ ++ mouse_inside = true; ++ update(); ++} ++ ++void BackFrame::leaveEvent( QEvent *e ) ++{ ++ mouse_inside = false; ++ update(); ++} ++ ++void BackFrame::mousePressEvent ( QMouseEvent * e ) ++{ ++ emit clicked(); ++} ++ ++FlipScrollView::FlipScrollView( QWidget * parent, const char * name ) ++ : QScrollView( parent, name ), mState( StoppedLeft ), mScrollDirection( 1 ), mShowBack( false ) ++{ ++ setVScrollBarMode( QScrollView::AlwaysOff ); ++ setHScrollBarMode( QScrollView::AlwaysOff ); ++ setFrameStyle( QFrame::NoFrame ); ++ mLeftView = new ItemView( this, "left_view" ); ++ addChild( mLeftView ); ++ ++ mRightView = new ItemView( this, "right_view" ); ++ addChild( mRightView ); ++ ++ mTimer = new QTimer( this, "mTimer" ); ++ connect( mTimer, SIGNAL( timeout() ), SLOT( slotScrollTimer() ) ); ++ ++ connect( mLeftView, SIGNAL( startService(KService::Ptr) ), ++ SIGNAL( startService(KService::Ptr) ) ); ++ connect( mLeftView, SIGNAL( startURL(const QString& ) ), ++ SIGNAL( startURL(const QString& ) ) ); ++ connect( mLeftView, SIGNAL( rightButtonPressed(QListViewItem*,const QPoint&,int) ), ++ SIGNAL( rightButtonPressed(QListViewItem*,const QPoint&,int) ) ); ++ connect( mRightView, SIGNAL( startService(KService::Ptr) ), ++ SIGNAL( startService(KService::Ptr) ) ); ++ connect( mRightView, SIGNAL( startURL(const QString& ) ), ++ SIGNAL( startURL(const QString& ) ) ); ++ connect( mRightView, SIGNAL( rightButtonPressed(QListViewItem*,const QPoint&,int) ), ++ SIGNAL( rightButtonPressed(QListViewItem*,const QPoint&,int) ) ); ++ ++ // wild hack to make sure it has correct width ++ mLeftView->setVScrollBarMode( QScrollView::AlwaysOn ); ++ mRightView->setVScrollBarMode( QScrollView::AlwaysOn ); ++ mLeftView->setVScrollBarMode( QScrollView::Auto ); ++ mRightView->setVScrollBarMode( QScrollView::Auto ); ++ ++ mBackrow = new BackFrame( this ); ++ mBackrow->resize( 24, 100 ); ++ connect( mBackrow, SIGNAL( clicked() ), SIGNAL( backButtonClicked() ) ); ++} ++ ++ItemView* FlipScrollView::prepareRightMove() ++{ ++ if ( mState != StoppedLeft ) ++ { ++ mTimer->stop(); ++ ItemView *swap = mLeftView; ++ mLeftView = mRightView; ++ mRightView = swap; ++ moveChild( mLeftView, 0, 0 ); ++ moveChild( mRightView, width(), 0 ); ++ mBackrow->hide(); ++ mRightView->resize( width(), height() ); ++ mLeftView->resize( width(), height() ); ++ setContentsPos( 0, 0 ); ++ } ++ ++ mState = StoppedLeft; ++ mRightView->clear(); ++ return mRightView; ++} ++ ++void FlipScrollView::showBackButton( bool enable ) ++{ ++ kdDebug() << "FlipScrollView::showBackButton " << enable << endl; ++ mShowBack = enable; ++} ++ ++ItemView* FlipScrollView::prepareLeftMove(bool clear) ++{ ++ if ( mState != StoppedRight ) ++ { ++ mTimer->stop(); ++ ItemView *swap = mLeftView; ++ mLeftView = mRightView; ++ mRightView = swap; ++ moveChild( mLeftView, 0, 0 ); ++ moveChild( mRightView, width(), 0 ); ++ mRightView->resize( width(), height() ); ++ mLeftView->resize( width(), height() ); ++ mBackrow->hide(); ++ setContentsPos( width(), 0 ); ++ } ++ ++ mState = StoppedRight; ++ if (clear) ++ mLeftView->clear(); ++ return mLeftView; ++} ++ ++void FlipScrollView::viewportResizeEvent ( QResizeEvent * ) ++{ ++ mLeftView->resize( size() ); ++ mRightView->resize( width() - mBackrow->width(), height() ); ++ mBackrow->resize( mBackrow->width(), height() ); ++ resizeContents( width() * 2, height() ); ++ moveChild( mBackrow, width(), 0 ); ++ moveChild( mRightView, width() + mBackrow->width(), 0 ); ++ setContentsPos( 0, 0 ); ++} ++ ++ItemView *FlipScrollView::currentView() const ++{ ++ if ( mState == StoppedRight ) ++ return mRightView; ++ else ++ return mLeftView; ++} ++ ++ItemView *FlipScrollView::leftView() const ++{ ++ return mLeftView; ++} ++ ++ItemView *FlipScrollView::rightView() const ++{ ++ return mRightView; ++} ++ ++FlipScrollView::~FlipScrollView() {} ++ ++static const int max_steps = 10; ++ ++void FlipScrollView::slotScrollTimer() ++{ ++ mStepsRemaining--; ++ assert( mStepsRemaining >= 0 && mStepsRemaining < int(sizeof( scrollSteps ) / sizeof( double )) ); ++ if (KickerSettings::scrollFlipView()) ++ scrollBy( ( int )( mScrollDirection * mLeftView->width() * scrollSteps[ mStepsRemaining ] ), 0 ); ++ else ++ scrollBy( ( int )( mScrollDirection * mLeftView->width()), 0 ); ++ ++ if ( mStepsRemaining == 0 ) ++ { ++ if ( mState == ScrollingRight ) ++ { ++ mState = StoppedRight; ++ setContentsPos( width(), 0 ); ++ } else { ++ mState = StoppedLeft; ++ setContentsPos( 0, 0 ); ++ } ++ ++ kdDebug() << "slotScrollTimer " << mShowBack << endl; ++ ++ if ( mShowBack ) ++ { ++ mBackrow->show(); ++ if ( mState == StoppedRight ) ++ { ++ ++ if ( QApplication::reverseLayout() ) ++ moveChild( mRightView, width(), 0 ); ++ else ++ moveChild( mRightView, width() + mBackrow->width(), 0 ); ++ mRightView->resize( width() - mBackrow->width(), height() ); ++ mLeftView->resize( width(), height() ); ++ if ( QApplication::reverseLayout() ) ++ moveChild( mBackrow, width() + mRightView->width(), 0 ); ++ else ++ moveChild( mBackrow, width(), 0 ); ++ moveChild( mLeftView, 0, 0 ); ++ } else ++ { ++ moveChild( mRightView, width(), 0 ); ++ mRightView->resize( width(), height() ); ++ mLeftView->resize( width() - mBackrow->width(), height() ); ++ if ( QApplication::reverseLayout() ) ++ { ++ moveChild( mBackrow, mLeftView->width(), 0 ); ++ moveChild( mLeftView, 0, 0 ); ++ } ++ else ++ { ++ moveChild( mBackrow, 0, 0 ); ++ moveChild( mLeftView, mBackrow->width(), 0 ); ++ } ++ } ++ } else ++ mBackrow->hide(); ++ ++ if (!mSelectMenuPath.isEmpty()) { ++ if (mSelectMenuPath=="kicker:/goup/") { ++ currentView()->setSelected(currentView()->firstChild(),true); ++ currentView()->firstChild()->repaint(); ++ } ++ else { ++ QListViewItem * child = currentView()->firstChild(); ++ while( child ) { ++ KMenuItem* kitem = dynamic_cast<KMenuItem*>(child); ++ if (kitem && kitem->menuPath()==mSelectMenuPath) { ++ currentView()->setSelected(child,true); ++ kdDebug() << "child repaint\n"; ++ child->repaint(); ++ break; ++ } ++ child = child->nextSibling(); ++ } ++ } ++ } ++ mLeftView->setVScrollBarMode( QScrollView::Auto ); ++ mRightView->setVScrollBarMode( QScrollView::Auto ); ++ mTimer->stop(); ++ mLeftView->setMouseMoveSelects( true ); ++ mRightView->setMouseMoveSelects( true ); ++ } ++} ++ ++void FlipScrollView::flipScroll(const QString& selectMenuPath) ++{ ++ if ( mState == StoppedLeft ) ++ { ++ mState = ScrollingRight; ++ mScrollDirection = 1; ++ } ++ else ++ { ++ mState = ScrollingLeft; ++ mScrollDirection = -1; ++ } ++ ++ mLeftView->setVScrollBarMode( QScrollView::AlwaysOff ); ++ mRightView->setVScrollBarMode( QScrollView::AlwaysOff ); ++ if (KickerSettings::scrollFlipView()) ++ mStepsRemaining = max_steps; ++ else ++ mStepsRemaining = 1; ++ mTimer->start( 30 ); ++ mSelectMenuPath = selectMenuPath; ++ if (!mSelectMenuPath.isEmpty()) { ++ mLeftView->setMouseMoveSelects( false ); ++ mRightView->setMouseMoveSelects( false ); ++ } ++} ++ ++#include "flipscrollview.moc" +--- kicker/ui/query.cpp (Revision 0) ++++ kicker/ui/query.cpp (Revision 849791) +@@ -0,0 +1,136 @@ ++/***************************************************************** ++ ++ Copyright (c) 2006 Stephan Binner <binner@kde.org> ++ ++ This program is free software; you can redistribute it and/or ++ modify it under the terms of the GNU General Public ++ License as published by the Free Software Foundation; either ++ version 2 of the License, or (at your option) any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; see the file COPYING. If not, write to ++ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ++ Boston, MA 02110-1301, USA. ++ ++******************************************************************/ ++ ++#include "query.h" ++#include <kdebug.h> ++ ++Query::Query() ++{ ++ alternatives.setAutoDelete(true); ++} ++ ++void Query::clear() ++{ ++ query_term = QString::null; ++ alternatives.clear(); ++} ++ ++void Query::set(const QString &term) ++{ ++ query_term = term; ++ alternatives.clear(); ++ ++ current_alternative = new Alternative; ++ current_part = QString::null; ++ within_quotes = false; ++ exclude_part = false; ++ ++ for (uint index=0;index<term.length();index++) { ++ if (current_part.isEmpty() && query_term[index]=='-') ++ exclude_part = true; ++ else if (term[index]=='\'' || term[index]=='"') { ++ if (within_quotes) ++ add_term(); ++ else ++ within_quotes = true; ++ } ++ else if (!within_quotes && query_term[index]==' ') ++ add_term(); ++ else if (!exclude_part && !within_quotes && query_term[index]=='O' && index+1<term.length() && query_term[index+1]=='R') { ++ index++; ++ alternatives.append(current_alternative); ++ current_alternative = new Alternative; ++ within_quotes = false; ++ exclude_part = false; ++ current_part = QString::null; ++ } ++ else ++ current_part+=term[index]; ++ } ++ add_term(); ++ alternatives.append(current_alternative); ++ ++#if 0 ++ for (Alternative* alt=alternatives.first(); alt; alt=alternatives.next()) { ++ kdDebug() << "---" << endl; ++ kdDebug() << "*** includes = " << alt->includes << endl; ++ kdDebug() << "*** excludes = " << alt->excludes << endl; ++ } ++#endif ++} ++ ++void Query::add_term() { ++ if (!current_part.isEmpty()) { ++ if (current_part.startsWith("*")) ++ current_part=current_part.mid(1); ++ ++ if (current_part.endsWith("*")) ++ current_part=current_part.mid(0,current_part.length()-1); ++ ++ if (exclude_part) ++ current_alternative->excludes+=current_part.lower(); ++ else ++ current_alternative->includes+=current_part.lower(); ++ } ++ within_quotes = false; ++ exclude_part = false; ++ current_part = QString::null; ++} ++ ++QString Query::get() const ++{ ++ return query_term; ++} ++ ++bool Query::matches(const QString &term) ++{ ++ QString lower_term = term.lower(); ++ ++ for (Alternative* alt=alternatives.first(); alt; alt=alternatives.next()) { ++ if (!alt->includes.count()) ++ continue; ++ ++ bool next_alternative = false; ++ ++ for ( QStringList::ConstIterator it = alt->excludes.begin(); it != alt->excludes.end(); ++it ) { ++ if ( lower_term.find(*it)!=-1 ) { ++ next_alternative = true; ++ continue; ++ } ++ } ++ if (next_alternative) ++ continue; ++ ++ for ( QStringList::ConstIterator it = alt->includes.begin(); it != alt->includes.end(); ++it ) { ++ if ( lower_term.find(*it)==-1 ) { ++ next_alternative = true; ++ continue; ++ } ++ } ++ if (next_alternative) ++ continue; ++ ++//kdDebug() << "Found hit in '" << term << "'" << endl; ++ return true; ++ } ++ ++ return false; ++} +--- kicker/ui/k_new_mnu.cpp (Revision 0) ++++ kicker/ui/k_new_mnu.cpp (Revision 849791) +@@ -0,0 +1,3779 @@ ++/***************************************************************** ++ ++ Copyright (c) 1996-2000 the kicker authors. See file AUTHORS. ++ Copyright (c) 2006 Debajyoti Bera <dbera.web@gmail.com> ++ Copyright (c) 2006 Dirk Mueller <mueller@kde.org> ++ ++ This program is free software; you can redistribute it and/or ++ modify it under the terms of the GNU General Public ++ License as published by the Free Software Foundation; either ++ version 2 of the License, or (at your option) any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; see the file COPYING. If not, write to ++ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ++ Boston, MA 02110-1301, USA. ++ ++******************************************************************/ ++ ++#include <stdlib.h> ++#include <sys/types.h> ++#include <unistd.h> ++#include <dmctl.h> ++#include <inttypes.h> ++ ++#include <qimage.h> ++#include <qpainter.h> ++#include <qstyle.h> ++#include <qwidgetstack.h> ++#include <qlayout.h> ++#include <qlabel.h> ++#include <qregexp.h> ++#include <qfile.h> ++#include <qstylesheet.h> ++#include <qaccel.h> ++#include <qcursor.h> ++#include <qdir.h> ++#include <qsimplerichtext.h> ++#include <qtooltip.h> ++#include <qtabbar.h> ++ ++#include <dcopclient.h> ++#include <kapplication.h> ++#include <kaboutkde.h> ++#include <kaction.h> ++#include <kbookmarkmenu.h> ++#include <kconfig.h> ++#include <kdebug.h> ++#include <kglobal.h> ++#include <kglobalsettings.h> ++#include <kiconloader.h> ++#include <klineedit.h> ++#include <klocale.h> ++#include <kmessagebox.h> ++#include <kstandarddirs.h> ++#include <kcombobox.h> ++#include <kwin.h> ++#include <kdebug.h> ++#include <kuser.h> ++#include <kurllabel.h> ++#include <krun.h> ++#include <kmimetype.h> ++#include <krecentdocument.h> ++#include <kcompletionbox.h> ++#include <kurifilter.h> ++#include <kbookmarkmanager.h> ++#include <kbookmark.h> ++#include <kprocess.h> ++#include <kio/jobclasses.h> ++#include <kio/job.h> ++#include <dcopref.h> ++#include <konq_popupmenu.h> ++#include <konqbookmarkmanager.h> ++#include <kparts/componentfactory.h> ++ ++#include "client_mnu.h" ++#include "container_base.h" ++#include "global.h" ++#include "knewbutton.h" ++#include "kicker.h" ++#include "kickerSettings.h" ++#include "konqbookmarkmanager.h" ++#include "menuinfo.h" ++#include "menumanager.h" ++#include "popupmenutitle.h" ++#include "quickbrowser_mnu.h" ++#include "recentapps.h" ++#include "flipscrollview.h" ++#include "itemview.h" ++#include <dmctl.h> ++#include <sys/vfs.h> ++#include <mykickoffsearchinterface.h> ++ ++#include "media_watcher.h" ++#include "k_mnu.h" ++#include "k_new_mnu.h" ++#include "k_new_mnu.moc" ++#include "kickoff_bar.h" ++ ++#define WAIT_BEFORE_QUERYING 700 ++ ++#define IDS_PER_CATEGORY 20 ++#define ACTIONS_ID_BASE 10 ++#define APP_ID_BASE 10 + IDS_PER_CATEGORY ++#define BOOKMARKS_ID_BASE 10 + (IDS_PER_CATEGORY * 2) ++#define NOTES_ID_BASE 10 + (IDS_PER_CATEGORY * 3) ++#define MAIL_ID_BASE 10 + (IDS_PER_CATEGORY * 4) ++#define FILE_ID_BASE 10 + (IDS_PER_CATEGORY * 5) ++#define MUSIC_ID_BASE 10 + (IDS_PER_CATEGORY * 6) ++#define WEBHIST_ID_BASE 10 + (IDS_PER_CATEGORY * 7) ++#define CHAT_ID_BASE 10 + (IDS_PER_CATEGORY * 8) ++#define FEED_ID_BASE 10 + (IDS_PER_CATEGORY * 9) ++#define PIC_ID_BASE 10 + (IDS_PER_CATEGORY * 10) ++#define VIDEO_ID_BASE 10 + (IDS_PER_CATEGORY * 11) ++#define DOC_ID_BASE 10 + (IDS_PER_CATEGORY * 12) ++#define OTHER_ID_BASE 10 + (IDS_PER_CATEGORY * 13) ++ ++static QString calculate(const QString &exp) ++{ ++ QString result, cmd; ++ const QString bc = KStandardDirs::findExe("bc"); ++ if ( !bc.isEmpty() ) ++ cmd = QString("echo %1 | %2").arg(KProcess::quote(exp), KProcess::quote(bc)); ++ else ++ cmd = QString("echo $((%1))").arg(exp); ++ FILE *fs = popen(QFile::encodeName(cmd).data(), "r"); ++ if (fs) ++ { ++ QTextStream ts(fs, IO_ReadOnly); ++ result = ts.read().stripWhiteSpace(); ++ pclose(fs); ++ } ++ return result; ++} ++ ++static QString workaroundStringFreeze(const QString& str) ++{ ++ QString s = str; ++ ++ s.replace("<u>","&"); ++ QRegExp re("<[^>]+>"); ++ re.setMinimal(true); ++ re.setCaseSensitive(false); ++ ++ s.replace(re, ""); ++ s = s.simplifyWhiteSpace(); ++ ++ return s; ++} ++ ++int base_category_id[] = {ACTIONS_ID_BASE, APP_ID_BASE, BOOKMARKS_ID_BASE, NOTES_ID_BASE, MAIL_ID_BASE, ++ FILE_ID_BASE, MUSIC_ID_BASE, WEBHIST_ID_BASE, CHAT_ID_BASE, FEED_ID_BASE, ++ PIC_ID_BASE, VIDEO_ID_BASE, DOC_ID_BASE, OTHER_ID_BASE}; ++ ++#include <assert.h> ++ ++static int used_size( QLabel *label, int oldsize ) ++{ ++ QSimpleRichText st( label->text(), KGlobalSettings::toolBarFont() ); ++ st.setWidth( oldsize ); ++ return QMAX( st.widthUsed(), oldsize ); ++} ++ ++KMenu::KMenu() ++ : KMenuBase(0, "SUSE::Kickoff::KMenu") ++ , m_sloppyTimer(0, "KNewMenu::sloppyTimer"), m_mediaFreeTimer(0, "KNewMenu::mediaFreeTimer"), ++ m_iconName(QString::null), m_orientation(UnDetermined), m_search_plugin( 0 ) ++{ ++ setMouseTracking(true); ++ connect(&m_sloppyTimer, SIGNAL(timeout()), SLOT(slotSloppyTimeout())); ++ ++ // set the first client id to some arbitrarily large value. ++ client_id = 10000; ++ // Don't automatically clear the main menu. ++ actionCollection = new KActionCollection(this); ++ ++ connect(Kicker::the(), SIGNAL(configurationChanged()), ++ this, SLOT(configChanged())); ++ ++ KUser * user = new KUser(); ++ ++ char hostname[256]; ++ hostname[0] = '\0'; ++ if (!gethostname( hostname, sizeof(hostname) )) ++ hostname[sizeof(hostname)-1] = '\0'; ++ ++ m_userInfo->setText( i18n( "User <b>%1</b> on <b>%2</b>" ) ++ .arg( user->loginName() ).arg( hostname ) ); ++ setupUi(); ++ ++ m_userInfo->setBackgroundMode( PaletteBase ); ++ QColor userInfoColor = QApplication::palette().color( QPalette::Normal, QColorGroup::Mid ); ++ if ( qGray( userInfoColor.rgb() ) > 120 ) ++ userInfoColor = userInfoColor.dark( 200 ); ++ else ++ userInfoColor = userInfoColor.light( 200 ); ++ m_userInfo->setPaletteForegroundColor( userInfoColor ); ++ ++ m_tabBar = new KickoffTabBar(this, "m_tabBar"); ++ connect(m_tabBar, SIGNAL(tabClicked(QTab*)), SLOT(tabClicked(QTab*))); ++ ++ const int tab_icon_size = 32; ++ ++ m_tabs[FavoriteTab] = new QTab; ++ m_tabBar->addTab(m_tabs[FavoriteTab]); ++ m_tabBar->setToolTip(FavoriteTab, "<qt>" + i18n( "Most commonly used applications and documents" ) + "</qt>" ); ++ m_tabs[ApplicationsTab] = new QTab; ++ m_tabBar->addTab(m_tabs[ApplicationsTab]); ++ m_tabBar->setToolTip(ApplicationsTab, "<qt>" + i18n( "List of installed applications" ) + ++ "</qt>" ); ++ ++ m_tabs[ComputerTab] = new QTab; ++ m_tabBar->addTab(m_tabs[ComputerTab]); ++ m_tabBar->setToolTip(ComputerTab, "<qt>" + i18n( "Information and configuration of your " ++ "system, access to personal files, network resources and connected disk drives") ++ + "</qt>"); ++#if 0 ++ m_tabs[SearchTab] = new QTab; ++ m_tabBar->addTab(m_tabs[SearchTab]); ++#endif ++ m_tabs[HistoryTab] = new QTab; ++ m_tabBar->addTab(m_tabs[HistoryTab]); ++ m_tabBar->setToolTip(HistoryTab, "<qt>" + i18n( "Recently used applications and documents" ) + ++ "</qt>" ); ++ m_tabs[LeaveTab] = new QTab; ++ m_tabBar->addTab(m_tabs[LeaveTab]); ++ m_tabBar->setToolTip(LeaveTab, i18n("<qt>Logout, switch user, switch off or reset," ++ " suspend of the system" ) + "</qt>" ); ++ ++ if (KickerSettings::kickoffTabBarFormat() != KickerSettings::IconOnly) { ++ m_tabs[FavoriteTab]->setText(workaroundStringFreeze(i18n("<p align=\"center\"> <u>F</u>avorites</p>"))); ++ m_tabs[HistoryTab]->setText(workaroundStringFreeze(i18n("<p align=\"center\"><u>H</u>istory</p>"))); ++ m_tabs[ComputerTab]->setText( ++ workaroundStringFreeze(i18n("<p align=\"center\"> <u>C</u>omputer</p>"))); ++ m_tabs[ApplicationsTab]->setText(workaroundStringFreeze(i18n("<p align=\"center\"><u>A</u>pplications</p>"))); ++ m_tabs[LeaveTab]->setText( ++ workaroundStringFreeze(i18n("<p align=\"center\"><u>L</u>eave</p>"))); ++ } ++ ++ if (KickerSettings::kickoffTabBarFormat() != KickerSettings::LabelOnly) { ++ m_tabs[FavoriteTab]->setIconSet(BarIcon("bookmark", tab_icon_size)); ++ m_tabs[HistoryTab]->setIconSet(BarIcon("recently_used", tab_icon_size)); ++ m_tabs[ComputerTab]->setIconSet(BarIcon("system", tab_icon_size)); ++ m_tabs[ApplicationsTab]->setIconSet(BarIcon("player_playlist", tab_icon_size)); ++ m_tabs[LeaveTab]->setIconSet(BarIcon("leave", tab_icon_size)); ++ } ++ ++ connect(m_tabBar, SIGNAL(selected(int)), m_stacker, SLOT(raiseWidget(int))); ++ connect(m_stacker, SIGNAL(aboutToShow(int)), m_tabBar, SLOT(setCurrentTab(int))); ++ ++ m_favoriteView = new FavoritesItemView (m_stacker, "m_favoriteView"); ++ m_favoriteView->setAcceptDrops(true); ++ m_favoriteView->setItemsMovable(true); ++ m_stacker->addWidget(m_favoriteView, FavoriteTab); ++ ++ m_recentlyView = new ItemView (m_stacker, "m_recentlyView"); ++ m_stacker->addWidget(m_recentlyView, HistoryTab); ++ ++ m_systemView = new ItemView(m_stacker, "m_systemView"); ++ m_stacker->addWidget(m_systemView, ComputerTab ); ++ ++ m_browserView = new FlipScrollView(m_stacker, "m_browserView"); ++ m_stacker->addWidget(m_browserView, ApplicationsTab); ++ connect( m_browserView, SIGNAL( backButtonClicked() ), SLOT( slotGoBack() ) ); ++ ++ m_exitView = new FlipScrollView(m_stacker, "m_exitView"); ++ m_stacker->addWidget(m_exitView, LeaveTab); ++ connect( m_exitView, SIGNAL( backButtonClicked() ), SLOT( slotGoExitMainMenu() ) ); ++ ++ m_searchWidget = new QVBox (m_stacker, "m_searchWidget"); ++ m_searchWidget->setSpacing(0); ++ m_stacker->addWidget(m_searchWidget, 5); ++ ++ // search provider icon ++ QPixmap icon; ++ KURIFilterData data; ++ QStringList list; ++ data.setData( QString("some keyword") ); ++ list << "kurisearchfilter" << "kuriikwsfilter"; ++ ++ if ( KURIFilter::self()->filterURI(data, list) ) { ++ QString iconPath = locate("cache", KMimeType::favIconForURL(data.uri()) + ".png"); ++ if ( iconPath.isEmpty() ) ++ icon = SmallIcon("enhanced_browsing"); ++ else ++ icon = QPixmap( iconPath ); ++ } ++ else ++ icon = SmallIcon("enhanced_browsing"); ++ ++ m_searchResultsWidget = new ItemView (m_searchWidget, "m_searchResultsWidget"); ++ m_searchResultsWidget->setItemMargin(4); ++ m_searchResultsWidget->setIconSize(16); ++ m_searchActions = new ItemView (m_searchWidget, "m_searchActions"); ++ m_searchActions->setFocusPolicy(QWidget::NoFocus); ++ m_searchActions->setItemMargin(4); ++ m_searchInternet = new QListViewItem(m_searchActions, i18n("Search Internet")); ++ m_searchInternet->setPixmap(0,icon); ++ setTabOrder(m_kcommand, m_searchResultsWidget); ++ ++ m_kerryInstalled = !KStandardDirs::findExe(QString::fromLatin1("kerry")).isEmpty(); ++ m_isShowing = false; ++ ++ if (!m_kerryInstalled) { ++ m_searchIndex = 0; ++ m_searchActions->setMaximumHeight(5+m_searchInternet->height()); ++ } ++ else { ++ m_searchIndex = new QListViewItem(m_searchActions, i18n("Search Index")); ++ m_searchIndex->setPixmap(0,SmallIcon("kerry")); ++ m_searchActions->setMaximumHeight(5+m_searchIndex->height()*2); ++ } ++ connect(m_searchActions, SIGNAL(clicked(QListViewItem*)), SLOT(searchActionClicked(QListViewItem*))); ++ connect(m_searchActions, SIGNAL(returnPressed(QListViewItem*)), SLOT(searchActionClicked(QListViewItem*))); ++ connect(m_searchActions, SIGNAL(spacePressed(QListViewItem*)), SLOT(searchActionClicked(QListViewItem*))); ++ ++ connect(m_searchResultsWidget, SIGNAL(startService(KService::Ptr)), SLOT(slotStartService(KService::Ptr))); ++ connect(m_searchResultsWidget, SIGNAL(startURL(const QString&)), SLOT(slotStartURL(const QString&))); ++ connect(m_searchResultsWidget, SIGNAL(rightButtonPressed( QListViewItem*, const QPoint &, int )), SLOT(slotContextMenuRequested( QListViewItem*, const QPoint &, int ))); ++ ++ connect(m_recentlyView, SIGNAL(startService(KService::Ptr)), SLOT(slotStartService(KService::Ptr))); ++ connect(m_recentlyView, SIGNAL(startURL(const QString&)), SLOT(slotStartURL(const QString&))); ++ connect(m_recentlyView, SIGNAL(rightButtonPressed( QListViewItem*, const QPoint &, int )), SLOT(slotContextMenuRequested( QListViewItem*, const QPoint &, int ))); ++ ++ connect(m_favoriteView, SIGNAL(startService(KService::Ptr)), SLOT(slotStartService(KService::Ptr))); ++ connect(m_favoriteView, SIGNAL(startURL(const QString&)), SLOT(slotStartURL(const QString&))); ++ connect(m_favoriteView, SIGNAL(rightButtonPressed( QListViewItem*, const QPoint &, int )), SLOT(slotContextMenuRequested( QListViewItem*, const QPoint &, int ))); ++ connect(m_favoriteView, SIGNAL(moved(QListViewItem*, QListViewItem*, QListViewItem*)), SLOT(slotFavoritesMoved( QListViewItem*, QListViewItem*, QListViewItem* ))); ++ ++ connect(m_systemView, SIGNAL(startURL(const QString&)), SLOT(slotStartURL(const QString&))); ++ connect(m_systemView, SIGNAL(startService(KService::Ptr)), SLOT(slotStartService(KService::Ptr))); ++ connect(m_systemView, SIGNAL(rightButtonPressed( QListViewItem*, const QPoint &, int )), SLOT(slotContextMenuRequested( QListViewItem*, const QPoint &, int ))); ++ ++ connect(m_browserView, SIGNAL(startURL(const QString&)), SLOT(slotGoSubMenu(const QString&))); ++ connect(m_browserView, SIGNAL(startService(KService::Ptr)), SLOT(slotStartService(KService::Ptr))); ++ connect(m_browserView, SIGNAL(rightButtonPressed( QListViewItem*, const QPoint &, int )), SLOT(slotContextMenuRequested( QListViewItem*, const QPoint &, int ))); ++ ++ connect(m_exitView, SIGNAL(startURL(const QString&)), SLOT(slotStartURL(const QString&))); ++ connect(m_exitView, SIGNAL(rightButtonPressed( QListViewItem*, const QPoint &, int )), SLOT(slotContextMenuRequested( QListViewItem*, const QPoint &, int ))); ++ ++ m_kcommand->setDuplicatesEnabled( false ); ++ m_kcommand->setLineEdit(new KLineEdit(m_kcommand, "m_kcommand-lineedit")); ++ m_kcommand->setCompletionMode( KGlobalSettings::CompletionAuto ); ++ connect(m_kcommand, SIGNAL(cleared()), SLOT(clearedHistory())); ++ connect(m_kcommand->lineEdit(), SIGNAL(returnPressed()), SLOT(searchAccept())); ++ connect(m_kcommand->lineEdit(), SIGNAL(textChanged(const QString &)), SLOT(searchChanged(const QString &))); ++ ++ // URI Filter meta object... ++ m_filterData = new KURIFilterData(); ++ ++ max_category_id = new int [num_categories]; ++ categorised_hit_total = new int [num_categories]; ++ ++ input_timer = new QTimer (this, "input_timer"); ++ connect( input_timer, SIGNAL(timeout()), this, SLOT(doQuery()) ); ++ ++ init_search_timer = new QTimer (this, "init_search_timer"); ++ connect( init_search_timer, SIGNAL(timeout()), this, SLOT(initSearch()) ); ++ init_search_timer->start(2000, true); ++ ++ connect( m_favoriteView, SIGNAL( dropped (QDropEvent *, QListViewItem * ) ), ++ SLOT( slotFavDropped( QDropEvent *, QListViewItem * ) ) ); ++ ++ this->installEventFilter(this); ++ m_tabBar->installEventFilter(this); ++ m_favoriteView->installEventFilter(this); ++ m_recentlyView->installEventFilter(this); ++ m_browserView->leftView()->installEventFilter(this); ++ m_browserView->rightView()->installEventFilter(this); ++ m_systemView->installEventFilter(this); ++ m_exitView->leftView()->installEventFilter(this); ++ m_exitView->rightView()->installEventFilter(this); ++ m_kcommand->lineEdit()->installEventFilter(this); ++ m_searchLabel->installEventFilter(this); ++ m_searchPixmap->installEventFilter(this); ++ m_stacker->installEventFilter(this); ++ ++ emailRegExp = QRegExp("^([\\w\\-]+\\.)*[\\w\\-]+@([\\w\\-]+\\.)*[\\w\\-]+$"); ++ authRegExp = QRegExp("^[a-zA-Z]+://\\w+(:\\w+)?@([\\w\\-]+\\.)*[\\w\\-]+(:\\d+)?(/.*)?$"); ++ uriRegExp = QRegExp("^[a-zA-Z]+://([\\w\\-]+\\.)*[\\w\\-]+(:\\d+)?(/.*)?$"); ++ uri2RegExp = QRegExp("^([\\w\\-]+\\.)+[\\w\\-]+(:\\d+)?(/.*)?$"); ++ ++ m_resizeHandle = new QLabel(this); ++ m_resizeHandle->setBackgroundOrigin( QLabel::ParentOrigin ); ++ m_resizeHandle->setScaledContents(true); ++ m_resizeHandle->setFixedSize( 16, 16 ); ++ m_searchFrame->stackUnder( m_resizeHandle ); ++ m_isresizing = false; ++ ++ m_searchPixmap->setPixmap( BarIcon( "find", 32 ) ); ++ ++ QFont f = font(); ++ f.setPointSize( kMax( 7, (f.pointSize() * 4 / 5 ) + KickerSettings::kickoffFontPointSizeOffset() ) ); ++ m_tabBar->setFont ( f ); ++ f.setPointSize( kMax( 7, (f.pointSize() * 3 / 2 ) + KickerSettings::kickoffFontPointSizeOffset() ) ); ++ m_searchLabel->setFont( f ); ++ ++ static_cast<KLineEdit*>(m_kcommand->lineEdit())->setClickMessage(i18n( "Applications, Contacts and Documents" ) ); ++ ++ bookmarkManager = 0; ++ m_addressBook = 0; ++ m_popupMenu = 0; ++ ++ main_border_tl.load( locate("data", "kicker/pics/main_corner_tl.png" ) ); ++ main_border_tr.load( locate("data", "kicker/pics/main_corner_tr.png" ) ); ++ ++ search_tab_left.load( locate("data", "kicker/pics/search-tab-left.png" ) ); ++ search_tab_right.load( locate("data", "kicker/pics/search-tab-right.png" ) ); ++ search_tab_center.load( locate("data", "kicker/pics/search-tab-center.png" ) ); ++ ++ search_tab_top_left.load( locate("data", "kicker/pics/search-tab-top-left.png" ) ); ++ search_tab_top_right.load( locate("data", "kicker/pics/search-tab-top-right.png" ) ); ++ search_tab_top_center.load( locate("data", "kicker/pics/search-tab-top-center.png" ) ); ++} ++ ++void KMenu::setupUi() ++{ ++ m_stacker = new QWidgetStack( this, "m_stacker" ); ++ m_stacker->setGeometry( QRect( 90, 260, 320, 220 ) ); ++ m_stacker->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)3, (QSizePolicy::SizeType)3, 1, 1, m_stacker->sizePolicy().hasHeightForWidth() ) ); ++ m_stacker->setPaletteBackgroundColor( QColor( 255, 255, 255 ) ); ++ // m_stacker->setFocusPolicy( QWidget::StrongFocus ); ++ m_stacker->setLineWidth( 0 ); ++ m_stacker->setFocusPolicy(QWidget::NoFocus); ++ connect(m_stacker, SIGNAL(aboutToShow(QWidget*)), SLOT(stackWidgetRaised(QWidget*))); ++ ++ m_kcommand->setName("m_kcommand"); ++} ++ ++KMenu::~KMenu() ++{ ++ saveConfig(); ++ ++ clearSubmenus(); ++ delete m_filterData; ++} ++ ++bool KMenu::eventFilter ( QObject * receiver, QEvent* e) ++{ ++//kdDebug() << "eventFilter receiver=" << receiver->name() << " type=" << e->type() << endl; ++ QWidget* raiseWidget = 0; ++ QRect raiseRect; ++ ++ if (e->type() == QEvent::KeyPress || ++ e->type() == QEvent::MouseButtonPress || ++ e->type() == QEvent::MouseMove ++ || e->type() == QEvent::FocusIn ++ || e->type() == QEvent::Wheel) { ++ QPoint p; ++ ++ if (e->type() == QEvent::MouseMove || e->type() == QEvent::MouseButtonPress) { ++ QMouseEvent* me = static_cast<QMouseEvent*>(e); ++ p = me->globalPos(); ++ } ++ else if (e->type() == QEvent::Wheel) { ++ QWheelEvent* we = static_cast<QWheelEvent*>(e); ++ p = we->globalPos(); ++ } ++ ++ while (receiver) { ++ if (receiver == m_tabBar && (e->type()!=QEvent::MouseMove || KickerSettings::kickoffSwitchTabsOnHover() ) ) { ++ QTab* s = m_tabBar->selectTab(m_tabBar->mapFromGlobal(p)); ++ if (s && s->identifier() == ApplicationsTab) ++ raiseWidget = m_browserView; ++ if (s && s->identifier() == FavoriteTab) ++ raiseWidget = m_favoriteView; ++ if (s && s->identifier() == HistoryTab) ++ raiseWidget = m_recentlyView; ++ if (s && s->identifier() == ComputerTab) ++ raiseWidget = m_systemView; ++ if (s && s->identifier() == LeaveTab) ++ raiseWidget = m_exitView; ++ ++ if (raiseWidget) ++ raiseRect = QRect( m_tabBar->mapToGlobal(s->rect().topLeft()), ++ s->rect().size()); ++ } ++ ++ /* we do not want hover activation for the search line edit as this can be ++ * pretty disturbing */ ++ if ( (receiver == m_searchPixmap || ++ ( ( receiver == m_searchLabel || receiver==m_kcommand->lineEdit() ) && ++ ( e->type() == QEvent::KeyPress || e->type() == QEvent::Wheel ++ || e->type() == QEvent::MouseButtonPress ) ) ) && ++ !m_isShowing) { ++ raiseWidget = m_searchWidget; ++ raiseRect = QRect( m_searchFrame->mapToGlobal(m_searchFrame->rect().topLeft()), ++ m_searchFrame->size()); ++ } ++ ++ if(raiseWidget) ++ break; ++ if(receiver->isWidgetType()) ++ receiver = static_cast<QWidget*>(receiver)->parentWidget(true); ++ else ++ break; ++ } ++ ++ if (e->type() == QEvent::FocusIn && receiver && raiseWidget) { ++ m_searchResultsWidget->setFocusPolicy(QWidget::StrongFocus); ++ m_searchActions->setFocusPolicy(raiseWidget == m_searchWidget ? ++ QWidget::StrongFocus : QWidget::NoFocus); ++ setTabOrder(raiseWidget, m_searchResultsWidget); ++ if (raiseWidget != m_stacker->visibleWidget() ++ && static_cast<QWidget*>(receiver)->focusPolicy() == QWidget::NoFocus ++ && m_stacker->id(raiseWidget) >= 0) { ++ ++ m_stacker->raiseWidget(raiseWidget); ++ return true; ++ } ++ ++ if (raiseWidget->focusPolicy() != QWidget::NoFocus) ++ return false; ++ } ++ ++ if (m_sloppyRegion.contains(p)) { ++ if (e->type() == QEvent::MouseButtonPress /*&& m_sloppyTimer.isActive()*/) ++ m_sloppySourceClicked = true; ++ ++ if (!m_sloppyTimer.isActive() || m_sloppySource != raiseRect) { ++ int timeout= style().styleHint(QStyle::SH_PopupMenu_SubMenuPopupDelay); ++ if (m_sloppySourceClicked) ++ timeout = 3000; ++ m_sloppyTimer.start(timeout); ++ } ++ ++ m_sloppyWidget = raiseWidget; ++ m_sloppySource = raiseRect; ++ return false; ++ } ++ } ++ ++ if(e->type() == QEvent::Enter && receiver->isWidgetType()) { ++ static_cast<QWidget*>(receiver)->setMouseTracking(true); ++ QToolTip::hide(); ++ } ++ ++ if ( ( e->type() == QEvent::DragEnter || e->type() == QEvent::DragMove ) && ++ raiseWidget == m_favoriteView ) ++ { ++ m_stacker->raiseWidget(m_favoriteView); ++ ++ return false; ++ } ++ ++ // This is a nightmare of a hack, look away. Logic needs ++ // to be moved to the stacker and all widgets in the stacker ++ // must have focusNextPrevChild() overwritten to do nothing ++ if (e->type() == QEvent::KeyPress && !raiseRect.isNull()) { ++ ItemView* view; ++ if (m_browserView==m_stacker->visibleWidget()) ++ view = m_browserView->currentView(); ++ else if (m_exitView==m_stacker->visibleWidget()) ++ view = m_exitView->currentView(); ++ else ++ view = dynamic_cast<ItemView*>(m_stacker->visibleWidget()); ++ ++ if (view) ++ { ++ bool handled = true; ++ switch (static_cast<QKeyEvent*>(e)->key()) { ++ case Key_Up: ++ if (view->selectedItem()) { ++ view->setSelected(view->selectedItem()->itemAbove(),true); ++ } ++ else { ++ view->setSelected(view->lastItem(),true); ++ } ++ break; ++ case Key_Down: ++ if (view->selectedItem()) { ++ view->setSelected(view->selectedItem()->itemBelow(),true); ++ } ++ else { ++ if (view->firstChild() && view->firstChild()->isSelectable()) ++ view->setSelected(view->firstChild(),true); ++ else if (view->childCount()>2) ++ view->setSelected(view->firstChild()->itemBelow(),true); ++ } ++ break; ++ case Key_Right: ++ if (view->selectedItem() && !static_cast<KMenuItem*>(view->selectedItem())->hasChildren()) ++ break; ++ // nobreak ++ case Key_Enter: ++ case Key_Return: ++ if (view->selectedItem()) ++ view->slotItemClicked(view->selectedItem()); ++ ++ break; ++ case Key_Left: ++ if (m_browserView == m_stacker->visibleWidget() || m_exitView == m_stacker->visibleWidget()) { ++ FlipScrollView* flip = dynamic_cast<FlipScrollView*>(m_stacker->visibleWidget()); ++ if (flip->showsBackButton()) { ++ if (m_browserView == m_stacker->visibleWidget()) ++ goSubMenu( m_browserView->currentView()->backPath(), true ); ++ else ++ view->slotItemClicked(view->firstChild()); ++ } ++ break; ++ } ++ // nobreak ++ case Key_Backspace: ++ if (m_browserView == m_stacker->visibleWidget() || m_exitView == m_stacker->visibleWidget()) { ++ FlipScrollView* flip = dynamic_cast<FlipScrollView*>(m_stacker->visibleWidget()); ++ if (flip->showsBackButton()) { ++ if (m_browserView == m_stacker->visibleWidget()) ++ goSubMenu( m_browserView->currentView()->backPath(), true ); ++ else ++ view->slotItemClicked(view->firstChild()); ++ } ++ } ++ ++ break; ++ default: ++ handled = false; ++ } ++ ++ if (handled) ++ view->ensureItemVisible(view->selectedItem()); ++ ++ return handled; ++ } ++ } ++ ++ bool r = KMenuBase::eventFilter(receiver, e); ++ ++ if (!r && raiseWidget) ++ m_stacker->raiseWidget(raiseWidget); ++ ++ if (e->type() == QEvent::Wheel && raiseWidget ) ++ { ++ // due to an ugly Qt bug we have to kill wheel events ++ // that cause focus switches ++ r = true; ++ } ++ ++ if (e->type() == QEvent::Enter && receiver == m_stacker) ++ { ++ QRect r(m_stacker->mapToGlobal(QPoint(-8,-32)), m_stacker->size()); ++ r.setSize(r.size()+QSize(16,128)); ++ ++ m_sloppyRegion = QRegion(r); ++ } ++ ++ // redo the sloppy region ++ if (e->type() == QEvent::MouseMove && !r && raiseWidget) ++ { ++ QPointArray points(4); ++ ++ // hmm, eventually this should be mouse position + 10px, not ++ // just worst case. but worst case seems to work fine enough. ++ QPoint edge(raiseRect.topLeft()); ++ edge.setX(edge.x()+raiseRect.center().x()); ++ ++ if (m_orientation == BottomUp) ++ { ++ points.setPoint(0, m_stacker->mapToGlobal(m_stacker->rect().bottomLeft())); ++ points.setPoint(1, m_stacker->mapToGlobal(m_stacker->rect().bottomRight())); ++ ++ edge.setY(edge.y()+raiseRect.height()); ++ points.setPoint(2, edge+QPoint(+raiseRect.width()/4,0)); ++ points.setPoint(3, edge+QPoint(-raiseRect.width()/4,0)); ++ } ++ else ++ { ++ points.setPoint(0, m_stacker->mapToGlobal(m_stacker->rect().topLeft())); ++ points.setPoint(1, m_stacker->mapToGlobal(m_stacker->rect().topRight())); ++ points.setPoint(2, edge+QPoint(-raiseRect.width()/4,0)); ++ points.setPoint(3, edge+QPoint(+raiseRect.width()/4,0)); ++ } ++ ++ m_sloppyRegion = QRegion(points); ++ } ++ ++ return r; ++} ++ ++void KMenu::slotSloppyTimeout() ++{ ++ if (m_sloppyRegion.contains(QCursor::pos()) && !m_sloppySource.isNull()) ++ { ++ if ( m_sloppySource.contains(QCursor::pos())) ++ { ++ m_stacker->raiseWidget(m_sloppyWidget); ++ ++ m_sloppyWidget = 0; ++ m_sloppySource = QRect(); ++ m_sloppyRegion = QRegion(); ++ m_sloppySourceClicked = false; ++ } ++ } ++ m_sloppyTimer.stop(); ++} ++ ++void KMenu::paintSearchTab( bool active ) ++{ ++ QPixmap canvas( m_searchFrame->size() ); ++ QPainter p( &canvas ); ++ ++ QPixmap pix; ++ ++ if ( m_orientation == BottomUp ) ++ pix.load( locate("data", "kicker/pics/search-gradient.png" ) ); ++ else ++ pix.load( locate("data", "kicker/pics/search-gradient-topdown.png" ) ); ++ ++ pix.convertFromImage( pix.convertToImage().scale(pix.width(), m_searchFrame->height())); ++ p.drawTiledPixmap( 0, 0, m_searchFrame->width(), m_searchFrame->height(), pix ); ++ ++ if ( active ) { ++ ++ m_tabBar->deactivateTabs(true); ++ ++ p.setBrush( Qt::white ); ++ p.setPen( Qt::NoPen ); ++ ++ if ( m_orientation == BottomUp ) { ++ search_tab_center.convertFromImage( search_tab_center.convertToImage().scale(search_tab_center.width(), m_searchFrame->height())); ++ p.drawTiledPixmap( search_tab_left.width(), 0, m_searchFrame->width()-search_tab_left.width()-search_tab_right.width(), m_searchFrame->height(), search_tab_center ); ++ ++ search_tab_left.convertFromImage( search_tab_left.convertToImage().scale(search_tab_left.width(), m_searchFrame->height())); ++ p.drawPixmap( 0, 0, search_tab_left ); ++ ++ search_tab_right.convertFromImage( search_tab_right.convertToImage().scale(search_tab_right.width(), m_searchFrame->height())); ++ p.drawPixmap( m_searchFrame->width()-search_tab_right.width(), 0, search_tab_right ); ++ } ++ else { ++ search_tab_top_center.convertFromImage( search_tab_top_center.convertToImage().scale(search_tab_top_center.width(), m_searchFrame->height())); ++ p.drawTiledPixmap( search_tab_top_left.width(), 0, m_searchFrame->width()-search_tab_top_left.width()-search_tab_top_right.width(), m_searchFrame->height(), search_tab_top_center ); ++ ++ search_tab_top_left.convertFromImage( search_tab_top_left.convertToImage().scale(search_tab_top_left.width(), m_searchFrame->height())); ++ p.drawPixmap( 0, 0, search_tab_top_left ); ++ ++ search_tab_top_right.convertFromImage( search_tab_top_right.convertToImage().scale(search_tab_top_right.width(), m_searchFrame->height())); ++ p.drawPixmap( m_searchFrame->width()-search_tab_top_right.width(), 0, search_tab_top_right ); ++ } ++ } ++ else ++ m_tabBar->deactivateTabs(false); ++ ++ p.end(); ++ m_searchFrame->setPaletteBackgroundPixmap( canvas ); ++} ++ ++void KMenu::stackWidgetRaised(QWidget* raiseWidget) ++{ ++ paintSearchTab(raiseWidget == m_searchWidget); ++ ++ if (raiseWidget == m_browserView) { ++ if ( m_tabBar->currentTab() == ApplicationsTab) ++ slotGoSubMenu(QString::null); ++ if (m_browserDirty ) { ++ createNewProgramList(); ++ m_browserView->prepareRightMove(); ++ m_browserView->currentView()->clear(); ++ fillSubMenu(QString::null, m_browserView->currentView()); ++ m_browserDirty = false; ++ } ++ } ++ else if (raiseWidget == m_recentlyView) { ++ if (m_recentDirty) ++ updateRecent(); ++ } ++ else if (raiseWidget == m_exitView) { ++ if (m_tabBar->currentTab() == LeaveTab) ++ slotGoExitMainMenu(); ++ } ++ ++ ++#warning Qtab fixme ++#if 0 ++ else if (raiseWidget == m_systemView) ++ frame = m_system; ++ else if (raiseWidget == m_favoriteView) ++ frame = m_btnFavorites; ++ if (!frame) ++ return; ++ ++ if ( m_activeTab == frame ) ++ return; ++ ++ paintTab( m_activeTab, false ); ++ paintTab( frame, true ); ++ ++ // if (dynamic_cast<QScrollView*>(raiseWidget)) ++ // m_activeTab->setFocusProxy(static_cast<QScrollView*>(raiseWidget)->viewport()); ++ ++ if (0 && /*raiseWidget == m_stacker->visibleWidget() &&*/ !raiseWidget->hasFocus()) { ++ ++ if (dynamic_cast<QScrollView*>(raiseWidget)) ++ static_cast<QScrollView*>(raiseWidget)->viewport()->setFocus(); ++ else ++ raiseWidget->setFocus(); ++ } ++ ++ m_activeTab = frame; ++ ++ m_sloppyRegion = QRegion(); ++ m_sloppyTimer.stop(); ++ ++ ItemView* view; ++ if (raiseWidget == m_browserView) ++ view = m_browserView->currentView(); ++ else if (raiseWidget == m_exitView) ++ view = m_exitView->currentView(); ++ else ++ view = dynamic_cast<ItemView*>(m_stacker->visibleWidget()); ++ if (view && !view->selectedItem()) { ++ if (view->firstChild() && view->firstChild()->isSelectable()) { ++ view->setSelected(view->firstChild(),true); ++ } ++ else if (view->childCount()>1) { ++ view->setSelected(view->firstChild()->itemBelow(),true); ++ } ++ } ++#endif ++} ++ ++void KMenu::paletteChanged() ++{ ++} ++ ++void KMenu::tabClicked(QTab* t) ++{ ++ if (t==m_tabs[ApplicationsTab]) ++ slotGoSubMenu(QString::null); ++ else if (t==m_tabs[LeaveTab]) ++ slotGoExitMainMenu(); ++} ++ ++void KMenu::slotGoBack() ++{ ++ goSubMenu( m_browserView->currentView()->backPath() ); ++} ++ ++void KMenu::slotGoExitMainMenu() ++{ ++ if (m_exitView->currentView()==m_exitView->rightView()) { ++ m_exitView->prepareLeftMove(false); ++ m_exitView->showBackButton(false); ++ m_exitView->flipScroll(QString::null); ++ } ++} ++ ++void KMenu::slotGoExitSubMenu(const QString& url) ++{ ++ m_exitView->prepareRightMove(); ++ m_exitView->showBackButton(true); ++ ++ int nId = serviceMenuEndId() + 1; ++ int index = 1; ++ ++ if (url=="kicker:/restart/") { ++ QStringList rebootOptions; ++ int def, cur; ++ if ( DM().bootOptions( rebootOptions, def, cur ) ) ++ { ++ if ( cur == -1 ) ++ cur = def; ++ ++ int boot_index = 0; ++ QStringList::ConstIterator it = rebootOptions.begin(); ++ for (; it != rebootOptions.end(); ++it, ++boot_index) ++ { ++ ++ QString option = i18n( "Start '%1'" ).arg( *it ); ++ if (boot_index == cur) ++ option = i18n("Start '%1' (current)").arg( *it ); ++ m_exitView->rightView()->insertItem( "reload", option, ++ i18n( "Restart and boot directly into '%1'").arg( *it ), ++ QString( "kicker:/restart_%1" ).arg( boot_index ), nId++, index++ ); ++ } ++ m_exitView->rightView()->insertHeader( nId++, "kicker:/restart/" ); ++ } ++ } ++ else /*if (url=="kicker:/switchuser/") */{ ++ m_exitView->rightView()->insertItem( "switchuser", i18n( "Start New Session" ), ++ i18n( "Start a parallel session" ), "kicker:/switchuser", nId++, index++ ); ++ ++ m_exitView->rightView()->insertItem( "lock", i18n( "Lock Current && Start New Session").replace("&&","&"), ++ i18n( "Lock screen and start a parallel session" ), "kicker:/switchuserafterlock", nId++, index++ ); ++ ++ SessList sess; ++ if (DM().localSessions( sess )) { ++ if (sess.count()>1) ++ m_exitView->rightView()->insertSeparator( nId++, QString::null, index++ ); ++ for (SessList::ConstIterator it = sess.begin(); it != sess.end(); ++it) { ++ if ((*it).vt && !(*it).self) { ++ QString user, loc; ++ DM().sess2Str2( *it, user, loc ); ++ QStringList list = QStringList::split(":", user); ++ m_exitView->rightView()->insertItem( "switchuser", i18n( "Switch to Session of User '%1'").arg(list[0]), ++ i18n("Session: %1").arg(list[1].mid(1)+", "+loc) , QString("kicker:/switchuser_%1").arg((*it).vt), nId++, index++ ); ++ } ++ } ++ } ++ ++ m_exitView->rightView()->insertHeader( nId++, "kicker:/switchuser/" ); ++ } ++ m_exitView->flipScroll(QString::null); ++} ++ ++void KMenu::slotGoSubMenu(const QString& relPath) ++{ ++ goSubMenu(relPath); ++} ++ ++void KMenu::goSubMenu(const QString& relPath, bool keyboard) ++{ ++ if ( relPath.startsWith( "kicker:/goup/" ) ) ++ { ++ QString rel = relPath.mid( strlen( "kicker:/goup/" ) ); ++ int index = rel.length() - 1; ++ if ( rel.endsWith( "/" ) ) ++ index--; ++ index = rel.findRev( '/', index ); ++ kdDebug() << "goup, rel '" << rel << "' " << index << endl; ++ QString currel = rel; ++ rel = rel.left( index + 1 ); ++ if ( rel == "/" ) ++ rel = QString::null; ++ ++ kdDebug() << "goup, rel '" << rel << "' " << rel.isEmpty() << endl; ++ fillSubMenu( rel, m_browserView->prepareLeftMove() ); ++ m_browserView->flipScroll(keyboard ? currel : QString::null); ++ return; ++ } else if (relPath.isEmpty()) ++ { ++ if (m_browserView->currentView()->path.isEmpty()) ++ return; ++ fillSubMenu( relPath, m_browserView->prepareLeftMove() ); ++ } else if ( relPath.startsWith( "kicker:/new/" ) ) ++ { ++ ItemView* view = m_browserView->prepareRightMove(); ++ m_browserView->showBackButton( true ); ++ ++ int nId = serviceMenuEndId() + 1; ++ view->insertHeader( nId++, "new/" ); ++ int index = 2; ++ for (QStringList::ConstIterator it = m_newInstalledPrograms.begin(); ++ it != m_newInstalledPrograms.end(); ++it) { ++ KService::Ptr p = KService::serviceByStorageId((*it)); ++ view->insertMenuItem(p, nId++, index++); ++ } ++ } else ++ { ++ //m_browserView->clear(); ++ fillSubMenu(relPath, m_browserView->prepareRightMove()); ++ } ++ m_browserView->flipScroll(keyboard ? "kicker:/goup/": QString::null); ++} ++ ++void KMenu::fillSubMenu(const QString& relPath, ItemView *view) ++{ ++ kdDebug() << "fillSubMenu() " << relPath << endl; ++ KServiceGroup::Ptr root = KServiceGroup::group(relPath); ++ Q_ASSERT( root ); ++ ++ KServiceGroup::List list = root->entries(true, true, true, KickerSettings:: ++ menuEntryFormat() == KickerSettings::DescriptionAndName || KickerSettings::menuEntryFormat() ++ == KickerSettings::DescriptionOnly); ++ ++ int nId = serviceMenuStartId(); ++ m_browserView->showBackButton( !relPath.isEmpty() ); ++ if ( !relPath.isEmpty() ) ++ { ++ view->insertHeader( nId++, relPath ); ++ } ++ else if ( m_newInstalledPrograms.count() ) { ++ KMenuItem *item = view->insertItem( "clock", i18n( "New Applications" ), ++ QString::null, "kicker:/new/", nId++, -1 ); ++ item->setHasChildren( true ); ++ view->insertSeparator( nId++, QString::null, -1 ); ++ } ++ ++ view->path = relPath; ++ ++ fillMenu (root, list, relPath, view, nId); ++} ++ ++void KMenu::fillMenu(KServiceGroup::Ptr& ++#ifdef KDELIBS_SUSE ++ _root ++#endif ++ , KServiceGroup::List& _list, ++ const QString& _relPath, ++ ItemView* view, ++ int& id) ++{ ++ bool separatorNeeded = false; ++ KServiceGroup::List::ConstIterator it = _list.begin(); ++#ifdef KDELIBS_SUSE ++ KSortableValueList<KSharedPtr<KSycocaEntry>,QCString> slist; ++ KSortableValueList<KSharedPtr<KSycocaEntry>,QCString> glist; ++ QMap<QString,QString> specialTitle; ++ QMap<QString,QString> categoryIcon; ++ QMap<QString,QString> shortenedMenuPath; ++#endif ++ ++ for (; it != _list.end(); ++it) ++ { ++ KSycocaEntry * e = *it; ++ ++ if (e->isType(KST_KServiceGroup)) ++ { ++ KServiceGroup::Ptr g(static_cast<KServiceGroup *>(e)); ++#ifdef KDELIBS_SUSE ++ if ( true /*KickerSettings::reduceMenuDepth()*/ && g->SuSEshortMenu() ){ ++ KServiceGroup::List l = g->entries(true, true /*excludeNoDisplay_*/ ); ++ if ( l.count() == 1 ) { ++ // the special case, we want to short the menu. ++ // TOFIX? : this works only for one level ++ KServiceGroup::List::ConstIterator _it=l.begin(); ++ KSycocaEntry *_e = *_it; ++ if (_e->isType(KST_KService)) { ++ KService::Ptr s(static_cast<KService *>(_e)); ++ QString key; ++ if ( g->SuSEgeneralDescription() ) { ++ // we use the application name ++ key = s->name(); ++ } ++ else { ++ // we use the normal menu description ++ key = s->name(); ++ if( !s->genericName().isEmpty() && g->caption()!=s->genericName()) { ++ if (KickerSettings::menuEntryFormat() == KickerSettings::NameAndDescription) ++ key = s->name() + " (" + g->caption() + ")"; ++ else if (KickerSettings::menuEntryFormat() == KickerSettings::DescriptionAndName) ++ key = g->caption() + " (" + s->name() + ")"; ++ else if (KickerSettings::menuEntryFormat() == KickerSettings::DescriptionOnly) ++ key = g->caption(); ++ } ++ } ++ specialTitle.insert( _e->name(), key ); ++ categoryIcon.insert( _e->name(), g->icon() ); ++ slist.insert( key.local8Bit(), _e ); ++ shortenedMenuPath.insert( _e->name(), g->relPath() ); ++ // and escape from here ++ continue; ++ } ++ } ++ } ++ glist.insert( g->caption().local8Bit(), e ); ++ }else if( e->isType(KST_KService)) { ++ KService::Ptr s(static_cast<KService *>(e)); ++ slist.insert( s->name().local8Bit(), e ); ++ } else ++ slist.insert( e->name().local8Bit(), e ); ++ } ++ ++ _list = _root->SuSEsortEntries( slist, glist, true /*excludeNoDisplay_*/, true ); ++ it = _list.begin(); ++ ++ for (; it != _list.end(); ++it) { ++ ++ KSycocaEntry * e = *it; ++ ++ if (e->isType(KST_KServiceGroup)) { ++ ++ KServiceGroup::Ptr g(static_cast<KServiceGroup *>(e)); ++ if ( true /*KickerSettings::reduceMenuDepth()*/ && g->SuSEshortMenu() ){ ++ KServiceGroup::List l = g->entries(true, true /*excludeNoDisplay_*/ ); ++ if ( l.count() == 1 ) { ++ continue; ++ } ++ } ++ // standard sub menu ++#endif ++ QString groupCaption = g->caption(); ++ ++ // Avoid adding empty groups. ++ KServiceGroup::Ptr subMenuRoot = KServiceGroup::group(g->relPath()); ++ ++ int nbChildCount = subMenuRoot->childCount(); ++ if (nbChildCount == 0 && !g->showEmptyMenu()) ++ { ++ continue; ++ } ++ ++ bool is_description = KickerSettings::menuEntryFormat() == KickerSettings::DescriptionAndName || ++ KickerSettings::menuEntryFormat() == KickerSettings::DescriptionOnly; ++ ++ QString inlineHeaderName = g->showInlineHeader() ? groupCaption : ""; ++ ++ if ( nbChildCount == 1 && g->allowInline() && g->inlineAlias()) ++ { ++ KServiceGroup::Ptr element = KServiceGroup::group(g->relPath()); ++ if ( element ) ++ { ++ //just one element ++ ++ KServiceGroup::List listElement = element->entries(true, true, true, is_description ); ++ KSycocaEntry * e1 = *( listElement.begin() ); ++ if ( e1->isType( KST_KService ) ) ++ { ++ KService::Ptr s(static_cast<KService *>(e1)); ++ view->insertMenuItem(s, id++, -1, 0); ++ continue; ++ } ++ } ++ } ++ ++ if (g->allowInline() && ((nbChildCount <= g->inlineValue() ) || (g->inlineValue() == 0))) ++ { ++ //inline all entries ++ KServiceGroup::Ptr rootElement = KServiceGroup::group(g->relPath()); ++ ++ if (!rootElement || !rootElement->isValid()) ++ { ++ break; ++ } ++ ++ ++ KServiceGroup::List listElement = rootElement->entries(true, true, true, is_description ); ++ ++#if 0 ++ if ( !g->inlineAlias() && !inlineHeaderName.isEmpty() ) ++ { ++ int mid = view->insertItem(new PopupMenuTitle(inlineHeaderName, font()), id++, id, 0); ++ m_browserView->setItemEnabled( mid, false ); ++ } ++#endif ++ ++ fillMenu( rootElement, listElement, g->relPath(), 0, id ); ++ continue; ++ } ++ ++ // Ignore dotfiles. ++ if ((g->name().at(0) == '.')) ++ { ++ continue; ++ } ++ ++ KMenuItem *item = view->insertItem(g->icon(), groupCaption, QString::null, g->relPath(), id++, -1); ++ item->setMenuPath(g->relPath()); ++ item->setHasChildren( true ); ++ ++#warning FIXME ++#if 0 ++ PanelServiceMenu * m = ++ newSubMenu(g->name(), g->relPath(), this, g->name().utf8(), inlineHeaderName); ++ m->setCaption(groupCaption); ++ ++ QIconSet iconset = KickerLib::menuIconSet(g->icon()); ++ ++ if (separatorNeeded) ++ { ++ insertSeparator(); ++ separatorNeeded = false; ++ } ++ ++ int newId = insertItem(iconset, groupCaption, m, id++); ++ entryMap_.insert(newId, static_cast<KSycocaEntry*>(g)); ++ // We have to delete the sub menu our selves! (See Qt docs.) ++ subMenus.append(m); ++#endif ++ } ++ if (e->isType(KST_KService)) ++ { ++ KService::Ptr s(static_cast<KService *>(e)); ++ if (_relPath.isEmpty()) { ++ QStringList favs = KickerSettings::favorites(); ++ if (favs.find(s->storageId())!=favs.end()) ++ continue; ++ } ++#ifdef KDELIBS_SUSE ++ KMenuItem *item = view->insertMenuItem(s, id++, -1, 0, QString::null, specialTitle[s->name()], categoryIcon[s->name()] ); ++ if (shortenedMenuPath[s->name()].isEmpty()) ++ item->setMenuPath(_relPath+s->menuId()); ++ else ++ item->setMenuPath(shortenedMenuPath[s->name()]+s->menuId()); ++#else ++ KMenuItem *item = view->insertMenuItem(s, id++, -1); ++ item->setMenuPath(_relPath+s->menuId()); ++#endif ++ } ++ else if (e->isType(KST_KServiceSeparator)) ++ { ++ separatorNeeded = true; ++ } ++ } ++ ++ view->slotMoveContent(); ++} ++ ++void KMenu::initialize() ++{ ++ static bool m_initialized=false; ++ if (m_initialized) ++ return; ++ m_initialized = true; ++ ++ kdDebug(1210) << "KMenu::initialize()" << endl; ++ ++ // in case we've been through here before, let's disconnect ++ disconnect(kapp, SIGNAL(kdisplayPaletteChanged()), ++ this, SLOT(paletteChanged())); ++ connect(kapp, SIGNAL(kdisplayPaletteChanged()), ++ this, SLOT(paletteChanged())); ++ ++ /* ++ If the user configured ksmserver to ++ */ ++ KConfig ksmserver("ksmserverrc", false, false); ++ ksmserver.setGroup("General"); ++ connect( m_branding, SIGNAL(clicked()), SLOT(slotOpenHomepage())); ++ m_tabBar->setTabEnabled(LeaveTab, kapp->authorize("logout")); ++ ++ // load search field history ++ QStringList histList = KickerSettings::history(); ++ int maxHistory = KickerSettings::historyLength(); ++ ++ bool block = m_kcommand->signalsBlocked(); ++ m_kcommand->blockSignals( true ); ++ m_kcommand->setMaxCount( maxHistory ); ++ m_kcommand->setHistoryItems( histList ); ++ m_kcommand->blockSignals( block ); ++ ++ QStringList compList = KickerSettings::completionItems(); ++ if( compList.isEmpty() ) ++ m_kcommand->completionObject()->setItems( histList ); ++ else ++ m_kcommand->completionObject()->setItems( compList ); ++ ++ KCompletionBox* box = m_kcommand->completionBox(); ++ if (box) ++ box->setActivateOnSelect( false ); ++ ++ m_finalFilters = KURIFilter::self()->pluginNames(); ++ m_finalFilters.remove("kuriikwsfilter"); ++ ++ m_middleFilters = m_finalFilters; ++ m_middleFilters.remove("localdomainurifilter"); ++ ++ QStringList favs = KickerSettings::favorites(); ++ if (favs.isEmpty()) { ++ QFile f(locate("data", "kicker/default-favs")); ++ if (f.open(IO_ReadOnly)) { ++ QTextStream is(&f); ++ ++ while (!is.eof()) ++ favs << is.readLine(); ++ ++ f.close(); ++ } ++ KickerSettings::setFavorites(favs); ++ KickerSettings::writeConfig(); ++ } ++ ++ int nId = serviceMenuEndId() + 1; ++ int index = 1; ++ for (QStringList::ConstIterator it = favs.begin(); it != favs.end(); ++it) ++ { ++ if ((*it)[0]=='/') { ++ KDesktopFile df((*it),true); ++ QString url = df.readURL(); ++ if (!KURL(url).isLocalFile() || QFile::exists(url.replace("file://",QString::null))) ++ m_favoriteView->insertItem(df.readIcon(),df.readName(),df.readGenericName(), url, nId++, index++); ++ } ++ else { ++ KService::Ptr p = KService::serviceByStorageId((*it)); ++ m_favoriteView->insertMenuItem(p, nId++, index++); ++ } ++ } ++ ++ //nId = m_favoriteView->insertSeparator( nId, QString::null, index++ ); ++// m_favoriteView->insertDocument(KURL("help:/khelpcenter/userguide/index.html"), nId++); ++ ++ insertStaticItems(); ++ ++ m_stacker->raiseWidget (m_favoriteView); ++} ++ ++void KMenu::insertStaticExitItems() ++{ ++ int nId = serviceMenuEndId() + 1; ++ int index = 1; ++ ++ m_exitView->leftView()->insertSeparator( nId++, i18n("Session"), index++ ); ++ if (kapp->authorize("logout")) ++ m_exitView->leftView()->insertItem( "undo", i18n( "Logout" ), ++ i18n( "End session" ), "kicker:/logout", nId++, index++ ); ++ if (kapp->authorize("lock_screen")) ++ m_exitView->leftView()->insertItem( "lock", i18n( "Lock" ), ++ i18n( "Lock screen" ), "kicker:/lock", nId++, index++ ); ++ ++ KConfig ksmserver("ksmserverrc", false, false); ++ ksmserver.setGroup("General"); ++ if (ksmserver.readEntry( "loginMode" ) == "restoreSavedSession") ++ { ++ m_exitView->leftView()->insertItem("filesave", i18n("Save Session"), ++ i18n("Save current Session for next login"), ++ "kicker:/savesession", nId++, index++ ); ++ } ++ if (DM().isSwitchable() && kapp->authorize("switch_user")) ++ { ++ KMenuItem *switchuser = m_exitView->leftView()->insertItem( "switchuser", i18n( "Switch User" ), ++ i18n( "Manage parallel sessions" ), "kicker:/switchuser/", nId++, index++ ); ++ switchuser->setHasChildren(true); ++ } ++ ++ bool maysd = false; ++ if (ksmserver.readBoolEntry( "offerShutdown", true ) && DM().canShutdown()) ++ maysd = true; ++ ++ if ( maysd ) ++ { ++ m_exitView->leftView()->insertSeparator( nId++, i18n("System"), index++ ); ++ m_exitView->leftView()->insertItem( "exit", i18n( "Shutdown Computer" ), ++ i18n( "Turn off computer" ), "kicker:/shutdown", nId++, index++ ); ++ ++ m_exitView->leftView()->insertItem( "reload", i18n( "&Restart Computer" ).replace("&",""), ++ i18n( "Restart and boot the default system" ), ++ "kicker:/restart", nId++, index++ ); ++ ++ insertSuspendOption(nId, index); ++ ++ int def, cur; ++ QStringList dummy_opts; ++ if ( DM().bootOptions( dummy_opts, def, cur ) ) ++ { ++ ++ KMenuItem *restart = m_exitView->leftView()->insertItem( "reload", i18n( "Start Operating System" ), ++ i18n( "Restart and boot another operating system" ), ++ "kicker:/restart/", nId++, index++ ); ++ restart->setHasChildren(true); ++ } ++ } ++} ++ ++void KMenu::insertStaticItems() ++{ ++ insertStaticExitItems(); ++ ++ int nId = serviceMenuEndId() + 10; ++ int index = 1; ++ ++ m_systemView->insertSeparator( nId++, i18n("Applications"), index++); ++ ++ KService::Ptr p = KService::serviceByStorageId("/usr/share/applications/YaST.desktop"); ++ m_systemView->insertMenuItem(p, nId++, index++); ++ ++ m_systemView->insertItem( "info", i18n( "System Information" ), ++ "sysinfo:/", "sysinfo:/", nId++, index++ ); ++ ++ m_systemView->insertSeparator( nId++, i18n("System Folders"), index++ ); ++ ++ m_systemView->insertItem( "folder_home", i18n( "Home Folder" ), ++ QDir::homeDirPath(), "file://"+QDir::homeDirPath(), nId++, index++ ); ++ ++ if ( KStandardDirs::exists( KGlobalSettings::documentPath() + "/" ) ) ++ { ++ QString documentPath = KGlobalSettings::documentPath(); ++ if ( documentPath.endsWith( "/" ) ) ++ documentPath = documentPath.left( documentPath.length() - 1 ); ++ if (documentPath!=QDir::homeDirPath()) ++ m_systemView->insertItem( "folder_man", i18n( "My Documents" ), documentPath, documentPath, nId++, index++ ); ++ } ++ ++ m_systemView->insertItem( "network", i18n( "Network Folders" ), ++ "remote:/", "remote:/", nId++, index++ ); ++ ++ m_mediaWatcher = new MediaWatcher( this ); ++ connect( m_mediaWatcher, SIGNAL( mediumChanged() ), SLOT( updateMedia() ) ); ++ m_media_id = 0; ++ ++ connect(&m_mediaFreeTimer, SIGNAL(timeout()), SLOT( updateMedia())); ++} ++ ++int KMenu::insertClientMenu(KickerClientMenu *) ++{ ++#if 0 ++ int id = client_id; ++ clients.insert(id, p); ++ return id; ++#endif ++ return 0; ++} ++ ++void KMenu::removeClientMenu(int) ++{ ++#if 0 ++ clients.remove(id); ++ slotClear(); ++#endif ++} ++ ++extern int kicker_screen_number; ++ ++void KMenu::slotLock() ++{ ++ kdDebug() << "slotLock " << endl; ++ accept(); ++ QCString appname( "kdesktop" ); ++ if ( kicker_screen_number ) ++ appname.sprintf("kdesktop-screen-%d", kicker_screen_number); ++ kapp->dcopClient()->send(appname, "KScreensaverIface", "lock()", ""); ++} ++ ++void KMenu::slotOpenHomepage() ++{ ++ accept(); ++ kapp->invokeBrowser("http://opensuse.org"); ++} ++ ++void KMenu::slotLogout() ++{ ++ kapp->requestShutDown(); ++} ++ ++void KMenu::slotPopulateSessions() ++{ ++ int p = 0; ++ DM dm; ++ ++ sessionsMenu->clear(); ++ if (kapp->authorize("start_new_session") && (p = dm.numReserve()) >= 0) ++ { ++ if (kapp->authorize("lock_screen")) ++ sessionsMenu->insertItem(/*SmallIconSet("lockfork"),*/ i18n("Lock Current && Start New Session"), 100 ); ++ sessionsMenu->insertItem(SmallIconSet("fork"), i18n("Start New Session"), 101 ); ++ if (!p) { ++ sessionsMenu->setItemEnabled( 100, false ); ++ sessionsMenu->setItemEnabled( 101, false ); ++ } ++ sessionsMenu->insertSeparator(); ++ } ++ SessList sess; ++ if (dm.localSessions( sess )) ++ for (SessList::ConstIterator it = sess.begin(); it != sess.end(); ++it) { ++ int id = sessionsMenu->insertItem( DM::sess2Str( *it ), (*it).vt ); ++ if (!(*it).vt) ++ sessionsMenu->setItemEnabled( id, false ); ++ if ((*it).self) ++ sessionsMenu->setItemChecked( id, true ); ++ } ++} ++ ++void KMenu::slotSessionActivated( int ent ) ++{ ++ if (ent == 100) ++ doNewSession( true ); ++ else if (ent == 101) ++ doNewSession( false ); ++ else if (!sessionsMenu->isItemChecked( ent )) ++ DM().lockSwitchVT( ent ); ++} ++ ++void KMenu::doNewSession( bool lock ) ++{ ++ int result = KMessageBox::warningContinueCancel( ++ kapp->desktop()->screen(kapp->desktop()->screenNumber(this)), ++ i18n("<p>You have chosen to open another desktop session.<br>" ++ "The current session will be hidden " ++ "and a new login screen will be displayed.<br>" ++ "An F-key is assigned to each session; " ++ "F%1 is usually assigned to the first session, " ++ "F%2 to the second session and so on. " ++ "You can switch between sessions by pressing " ++ "Ctrl, Alt and the appropriate F-key at the same time. " ++ "Additionally, the KDE Panel and Desktop menus have " ++ "actions for switching between sessions.</p>") ++ .arg(7).arg(8), ++ i18n("Warning - New Session"), ++ KGuiItem(i18n("&Start New Session"), "fork"), ++ ":confirmNewSession", ++ KMessageBox::PlainCaption | KMessageBox::Notify); ++ ++ if (result==KMessageBox::Cancel) ++ return; ++ ++ if (lock) ++ slotLock(); ++ ++ DM().startReserve(); ++} ++ ++void KMenu::searchAccept() ++{ ++ QString cmd = m_kcommand->currentText().stripWhiteSpace(); ++ ++ bool logout = (cmd == "logout"); ++ bool lock = (cmd == "lock"); ++ ++ addToHistory(); ++ ++ if ( !logout && !lock ) ++ { ++ // first try if we have any search action ++ if (m_searchResultsWidget->currentItem()) { ++ m_searchResultsWidget->slotItemClicked(m_searchResultsWidget->currentItem()); ++ return; ++ } ++ } ++ ++ accept(); ++ saveConfig(); ++ ++ if ( logout ) ++ { ++ kapp->propagateSessionManager(); ++ kapp->requestShutDown(); ++ } ++ if ( lock ) ++ { ++ QCString appname( "kdesktop" ); ++ int kicker_screen_number = qt_xscreen(); ++ if ( kicker_screen_number ) ++ appname.sprintf("kdesktop-screen-%d", kicker_screen_number); ++ kapp->dcopClient()->send(appname, "KScreensaverIface", "lock()", ""); ++ } ++} ++ ++bool KMenu::runCommand() ++{ ++ kdDebug() << "runCommand() " << m_kcommand->lineEdit()->text() << endl; ++ // Ignore empty commands... ++ if ( m_kcommand->lineEdit()->text().isEmpty() ) ++ return true; ++ ++ accept(); ++ ++ if (input_timer->isActive ()) ++ input_timer->stop (); ++ ++ // Make sure we have an updated data ++ parseLine( true ); ++ ++ bool block = m_kcommand->signalsBlocked(); ++ m_kcommand->blockSignals( true ); ++ m_kcommand->clearEdit(); ++ m_kcommand->setFocus(); ++ m_kcommand->reset(); ++ m_kcommand->blockSignals( block ); ++ ++ ++ QString cmd; ++ KURL uri = m_filterData->uri(); ++ if ( uri.isLocalFile() && !uri.hasRef() && uri.query().isEmpty() ) ++ cmd = uri.path(); ++ else ++ cmd = uri.url(); ++ ++ QString exec; ++ ++ switch( m_filterData->uriType() ) ++ { ++ case KURIFilterData::LOCAL_FILE: ++ case KURIFilterData::LOCAL_DIR: ++ case KURIFilterData::NET_PROTOCOL: ++ case KURIFilterData::HELP: ++ { ++ // No need for kfmclient, KRun does it all (David) ++ (void) new KRun( m_filterData->uri(), parentWidget()); ++ return false; ++ } ++ case KURIFilterData::EXECUTABLE: ++ { ++ if( !m_filterData->hasArgsAndOptions() ) ++ { ++ // Look for desktop file ++ KService::Ptr service = KService::serviceByDesktopName(cmd); ++ if (service && service->isValid() && service->type() == "Application") ++ { ++ notifyServiceStarted(service); ++ KRun::run(*service, KURL::List()); ++ return false; ++ } ++ } ++ } ++ // fall-through to shell case ++ case KURIFilterData::SHELL: ++ { ++ if (kapp->authorize("shell_access")) ++ { ++ exec = cmd; ++ ++ if( m_filterData->hasArgsAndOptions() ) ++ cmd += m_filterData->argsAndOptions(); ++ ++ break; ++ } ++ else ++ { ++ KMessageBox::sorry( this, i18n("<center><b>%1</b></center>\n" ++ "You do not have permission to execute " ++ "this command.") ++ .arg( QStyleSheet::convertFromPlainText(cmd) )); ++ return true; ++ } ++ } ++ case KURIFilterData::UNKNOWN: ++ case KURIFilterData::ERROR: ++ default: ++ { ++ // Look for desktop file ++ KService::Ptr service = KService::serviceByDesktopName(cmd); ++ if (service && service->isValid() && service->type() == "Application") ++ { ++ notifyServiceStarted(service); ++ KRun::run(*service, KURL::List(), this); ++ return false; ++ } ++ ++ service = KService::serviceByName(cmd); ++ if (service && service->isValid() && service->type() == "Application") ++ { ++ notifyServiceStarted(service); ++ KRun::run(*service, KURL::List(), this); ++ return false; ++ } ++ ++ KMessageBox::sorry( this, i18n("<center><b>%1</b></center>\n" ++ "Could not run the specified command.") ++ .arg( QStyleSheet::convertFromPlainText(cmd) )); ++ return true; ++ } ++ } ++ ++ if ( KRun::runCommand( cmd, exec, m_iconName ) ) ++ return false; ++ ++ KMessageBox::sorry( this, i18n("<center><b>%1</b></center>\n" ++ "The specified command does not exist.").arg(cmd) ); ++ return true; // Let the user try again... ++} ++ ++void KMenu::show() ++{ ++ m_isShowing = true; ++ emit aboutToShow(); ++ ++ initialize(); ++ ++ PanelPopupButton *kButton = MenuManager::the()->findKButtonFor( this ); ++ if (kButton) ++ { ++ QPoint center = kButton->center(); ++ QRect screen = QApplication::desktop()->screenGeometry( center ); ++ setOrientation((center.y()-screen.y()<screen.height()/2) ++ ? TopDown : BottomUp); ++ } ++ ++ m_browserDirty=true; ++ m_recentDirty=true; ++ ++ updateMedia(); ++ m_mediaFreeTimer.start(10 * 1000); // refresh all 10s ++ ++ m_stacker->raiseWidget(FavoriteTab); ++ m_kcommand->clear(); ++ current_query.clear(); ++ m_kcommand->setFocus(); ++ ++ // we need to reenable it ++ m_toolTipsEnabled = QToolTip::isGloballyEnabled(); ++ QToolTip::setGloballyEnabled(KickerSettings::showToolTips()); ++ ++ KMenuBase::show(); ++ m_isShowing = false; ++} ++ ++void KMenu::setOrientation(MenuOrientation orientation) ++{ ++ if (m_orientation == orientation) ++ return; ++ ++ m_orientation=orientation; ++ ++ m_resizeHandle->setCursor(m_orientation == BottomUp ? Qt::sizeBDiagCursor : Qt::sizeFDiagCursor); ++ ++ QPixmap pix; ++ if ( m_orientation == BottomUp ) ++ pix.load( locate("data", "kicker/pics/search-gradient.png" ) ); ++ else ++ pix.load( locate("data", "kicker/pics/search-gradient-topdown.png" ) ); ++ ++ pix.convertFromImage( pix.convertToImage().scale(pix.width(), m_searchFrame->height())); ++ m_search->mainWidget()->setPaletteBackgroundPixmap( pix ); ++ m_resizeHandle->setPaletteBackgroundPixmap( pix ); ++ ++ m_tabBar->setShape( m_orientation == BottomUp ++ ? QTabBar::RoundedBelow : QTabBar::RoundedAbove); ++ ++ QPixmap respix = QPixmap( locate("data", "kicker/pics/resize_handle.png" ) ); ++ if ( m_orientation == TopDown ) { ++ QWMatrix m; ++ m.rotate( 90.0 ); ++ respix=respix.xForm(m); ++ } ++ m_resizeHandle->setPixmap(respix); ++ ++ { ++ QWidget *footer = m_footer->mainWidget(); ++ QPixmap pix( 64, footer->height() ); ++ QPainter p( &pix ); ++ p.fillRect( 0, 0, 64, footer->height(), m_branding->colorGroup().brush( QColorGroup::Base ) ); ++ p.fillRect( 0, m_orientation == BottomUp ? footer->height() - 2 : 0, ++ 64, 3, KNewButton::self()->borderColor() ); ++ p.end(); ++ footer->setPaletteBackgroundPixmap( pix ); ++ } ++ ++ resizeEvent(new QResizeEvent(sizeHint(), sizeHint())); ++} ++ ++void KMenu::showMenu() ++{ ++ kdDebug() << "KMenu::showMenu()" << endl; ++ PanelPopupButton *kButton = MenuManager::the()->findKButtonFor(this); ++ if (kButton) ++ { ++ adjustSize(); ++ kButton->showMenu(); ++ } ++ else ++ { ++ show(); ++ } ++ kdDebug() << "end KMenu::showMenu()" << endl; ++} ++ ++void KMenu::hide() ++{ ++ //kdDebug() << "KMenu::hide() from " << kdBacktrace() << endl; ++ ++ // TODO: hide popups ++ ++ emit aboutToHide(); ++ ++ if (m_popupMenu) { ++ m_popupMenu->deleteLater(); ++ m_popupMenu=0; ++ } ++ m_mediaFreeTimer.stop(); ++ ++ m_isresizing = false; ++ ++ KickerSettings::setKMenuWidth(width()); ++ KickerSettings::setKMenuHeight(height()); ++ KickerSettings::writeConfig(); ++ ++ QToolTip::setGloballyEnabled(m_toolTipsEnabled); ++ ++ // remove focus from lineedit again, otherwise it doesn't kill its timers ++ m_stacker->raiseWidget(FavoriteTab); ++ ++ QWidget::hide(); ++} ++ ++void KMenu::paintEvent(QPaintEvent * e) ++{ ++ KMenuBase::paintEvent(e); ++ ++ QPainter p(this); ++ p.setClipRegion(e->region()); ++ ++ const BackgroundMode bgmode = backgroundMode(); ++ const QColorGroup::ColorRole crole = QPalette::backgroundRoleFromMode( bgmode ); ++ p.setBrush( colorGroup().brush( crole ) ); ++ ++ p.drawRect( 0, 0, width(), height() ); ++ int ypos = m_search->mainWidget()->geometry().bottom(); ++ ++ p.drawPixmap( 0, ypos, main_border_tl ); ++ p.drawPixmap( width() - main_border_tr.width(), ypos, main_border_tr ); ++ // p.drawPixmap( 0, ->y(), button_box_left ); ++} ++ ++ ++void KMenu::configChanged() ++{ ++ RecentlyLaunchedApps::the().m_bNeedToUpdate = false; ++ RecentlyLaunchedApps::the().configChanged(); ++ ++ m_exitView->leftView()->clear(); ++ insertStaticExitItems(); ++} ++ ++// create and fill "recent" section at first ++void KMenu::createRecentMenuItems() ++{ ++ RecentlyLaunchedApps::the().init(); ++ ++ if (!KickerSettings::numVisibleEntries()) ++ KickerSettings::setNumVisibleEntries(5); ++ ++ int nId = serviceMenuEndId() + 1; ++ m_recentlyView->insertSeparator( nId++, i18n( "Applications" ), -1 ); ++ ++ QStringList RecentApps; ++ ++ if (!KickerSettings::recentVsOften()) { ++ KickerSettings::setRecentVsOften(true); ++ RecentlyLaunchedApps::the().configChanged(); ++ RecentlyLaunchedApps::the().getRecentApps(RecentApps); ++ KickerSettings::setRecentVsOften(false); ++ RecentlyLaunchedApps::the().configChanged(); ++ } ++ else ++ RecentlyLaunchedApps::the().getRecentApps(RecentApps); ++ ++ ++ if (RecentApps.count() > 0) ++ { ++// bool bSeparator = KickerSettings::showMenuTitles(); ++ int nIndex = 0; ++ ++ for (QValueList<QString>::ConstIterator it = ++ RecentApps.begin(); it!=RecentApps.end(); ++it) ++ { ++ KService::Ptr s = KService::serviceByStorageId(*it); ++ if (!s) ++ { ++ RecentlyLaunchedApps::the().removeItem(*it); ++ } ++ else ++ m_recentlyView->insertMenuItem(s, nIndex++); ++ } ++ ++ } ++ ++ m_recentlyView->insertSeparator( nId++, i18n( "Documents" ), -1 ); ++ ++ QStringList fileList = KRecentDocument::recentDocuments(); ++ kdDebug() << "createRecentMenuItems=" << fileList << endl; ++ for (QStringList::ConstIterator it = fileList.begin(); ++ it != fileList.end(); ++ ++it) ++ m_recentlyView->insertRecentlyItem(*it, nId++); ++ ++} ++ ++void KMenu::clearSubmenus() ++{ ++ // we don't need to delete these on the way out since the libloader ++ // handles them for us ++ if (QApplication::closingDown()) ++ { ++ return; ++ } ++ ++ for (PopupMenuList::const_iterator it = dynamicSubMenus.constBegin(); ++ it != dynamicSubMenus.constEnd(); ++ ++it) ++ { ++ delete *it; ++ } ++ dynamicSubMenus.clear(); ++} ++ ++void KMenu::updateRecent() ++{ ++ m_recentlyView->clear(); ++ ++ createRecentMenuItems(); ++ ++ m_recentDirty = false; ++} ++ ++void KMenu::popup(const QPoint&, int) ++{ ++ showMenu(); ++} ++ ++void KMenu::clearRecentAppsItems() ++{ ++ RecentlyLaunchedApps::the().clearRecentApps(); ++ RecentlyLaunchedApps::the().save(); ++ RecentlyLaunchedApps::the().m_bNeedToUpdate = true; ++ updateRecent(); ++} ++ ++void KMenu::clearRecentDocsItems() ++{ ++ KRecentDocument::clear(); ++ updateRecent(); ++} ++ ++void KMenu::searchChanged(const QString & text) ++{ ++ if (!text.isEmpty()) { ++ const QColor on = QColor( 244, 244, 244 ); ++ const QColor off = QColor( 181, 181, 181 ); ++ m_stacker->raiseWidget(m_searchWidget); ++ paintSearchTab(true); ++ } ++ ++ m_searchActions->clearSelection(); ++ m_searchResultsWidget->clearSelection(); ++ ++ if (input_timer->isActive ()) ++ input_timer->stop (); ++ input_timer->start (WAIT_BEFORE_QUERYING, TRUE); ++} ++ ++bool KMenu::dontQueryNow (const QString& str) ++{ ++ if (str.isEmpty ()) ++ return true; ++ if (str == current_query.get()) ++ return true; ++ int length = str.length (); ++ int last_whitespace = str.findRev (' ', -1); ++ if (last_whitespace == length-1) ++ return false; // if the user typed a space, search ++ if (last_whitespace >= length-2) ++ return true; // dont search if the user only typed one character ++ QChar lastchar = str[length-1]; ++ if (lastchar == ":" || lastchar == "=") ++ return true; ++ return false; ++} ++ ++void KMenu::createNewProgramList() ++{ ++ m_seenProgramsChanged = false; ++ m_seenPrograms = KickerSettings::firstSeenApps(); ++ m_newInstalledPrograms.clear(); ++ ++ m_currentDate = QDate::currentDate().toString(Qt::ISODate); ++ ++ bool initialize = (m_seenPrograms.count() == 0); ++ ++ createNewProgramList(QString::null); ++ ++ if (initialize) { ++ for (QStringList::Iterator it = m_seenPrograms.begin(); it != m_seenPrograms.end(); ++it) ++ *(++it)="-"; ++ ++ m_newInstalledPrograms.clear(); ++ } ++ ++ if (m_seenProgramsChanged) { ++ KickerSettings::setFirstSeenApps(m_seenPrograms); ++ KickerSettings::writeConfig(); ++ } ++} ++ ++void KMenu::createNewProgramList(QString relPath) ++{ ++ KServiceGroup::Ptr group = KServiceGroup::group(relPath); ++ if (!group || !group->isValid()) ++ return; ++ ++ KServiceGroup::List list = group->entries(); ++ if (list.isEmpty()) ++ return; ++ ++ KServiceGroup::List::ConstIterator it = list.begin(); ++ for(; it != list.end(); ++it) { ++ KSycocaEntry *e = *it; ++ ++ if(e != 0) { ++ if(e->isType(KST_KServiceGroup)) { ++ KServiceGroup::Ptr g(static_cast<KServiceGroup *>(e)); ++ if(!g->noDisplay()) ++ createNewProgramList(g->relPath()); ++ } else if(e->isType(KST_KService)) { ++ KService::Ptr s(static_cast<KService *>(e)); ++ if(s->type() == "Application" && !s->noDisplay() ) { ++ QString shortStorageId = s->storageId().replace(".desktop",QString::null); ++ QStringList::Iterator it_find = m_seenPrograms.begin(); ++ QStringList::Iterator it_end = m_seenPrograms.end(); ++ bool found = false; ++ for (; it_find != it_end; ++it_find) { ++ if (*(it_find)==shortStorageId) { ++ found = true; ++ break; ++ } ++ ++it_find; ++ } ++ if (!found) { ++ m_seenProgramsChanged=true; ++ m_seenPrograms+=shortStorageId; ++ m_seenPrograms+=m_currentDate; ++ if (m_newInstalledPrograms.find(s->storageId())==m_newInstalledPrograms.end()) ++ m_newInstalledPrograms+=s->storageId(); ++ } ++ else { ++ ++it_find; ++ if (*(it_find)!="-") { ++ QDate date = QDate::fromString(*(it_find),Qt::ISODate); ++ if (date.daysTo(QDate::currentDate())<3) { ++ if (m_newInstalledPrograms.find(s->storageId())==m_newInstalledPrograms.end()) ++ m_newInstalledPrograms+=s->storageId(); ++ } ++ else { ++ m_seenProgramsChanged=true; ++ (*it_find)="-"; ++ } ++ } ++ } ++ } ++ } ++ } ++ } ++} ++ ++void KMenu::searchProgramList(QString relPath) ++{ ++ KServiceGroup::Ptr group = KServiceGroup::group(relPath); ++ if (!group || !group->isValid()) ++ return; ++ ++ KServiceGroup::List list = group->entries(); ++ if (list.isEmpty()) ++ return; ++ ++ KServiceGroup::List::ConstIterator it = list.begin(); ++ for(; it != list.end(); ++it) { ++ KSycocaEntry *e = *it; ++ ++ if(e != 0) { ++ if(e->isType(KST_KServiceGroup)) { ++ KServiceGroup::Ptr g(static_cast<KServiceGroup *>(e)); ++ if(!g->noDisplay()) ++ searchProgramList(g->relPath()); ++ } else if(e->isType(KST_KService)) { ++ KService::Ptr s(static_cast<KService *>(e)); ++ if(s->type() == "Application" && !s->noDisplay() && !checkUriInMenu(s->desktopEntryPath())) { ++ if (!current_query.matches(s->name()+' '+s->genericName()+' '+s->exec()+' '+ ++ s->keywords().join(",")+' '+s->comment()+' '+group->caption()+' '+ ++ s->categories().join(",")) || !anotherHitMenuItemAllowed(APPS)) ++ continue; ++ ++ QString input = current_query.get(); ++ int score = 0; ++ if (s->exec()==input) ++ score = 100; ++ else if (s->exec().find(input)==0) ++ score = 50; ++ else if (s->exec().find(input)!=-1) ++ score = 10; ++ else if (s->name().lower()==input) ++ score = 100; ++ else if (s->genericName().lower()==input) ++ score = 100; ++ else if (s->name().lower().find(input)==0) ++ score = 50; ++ else if (s->genericName().lower().find(input)==0) ++ score = 50; ++ else if (s->name().lower().find(input)!=-1) ++ score = 10; ++ else if (s->genericName().lower().find(input)!=-1) ++ score = 10; ++ ++ if (s->exec().find(' ')==-1) ++ score+=1; ++ ++ if (s->substituteUid()) ++ score-=1; ++ ++ if (s->noDisplay()) ++ score -= 100; ++ else if (s->terminal()) ++ score -= 50; ++ else ++ score += kMin(10, s->initialPreference()); ++ ++ QString firstLine, secondLine; ++ if ((KickerSettings::DescriptionAndName || KickerSettings::menuEntryFormat() == KickerSettings::DescriptionOnly) && !s->genericName().isEmpty()) { ++ firstLine = s->genericName(); ++ secondLine = s->name(); ++ } ++ else { ++ firstLine = s->name(); ++ secondLine = s->genericName(); ++ } ++ ++ HitMenuItem *hit_item = new HitMenuItem (firstLine, secondLine, ++ s->desktopEntryPath(), QString::null, 0, APPS, s->icon(), score); ++ if (hit_item == NULL) ++ continue; ++ ++ hit_item->service = s; ++ insertSearchResult(hit_item); ++ ++ QString exe = s->exec(); ++ int pos = exe.find(' '); ++ if (pos>0) ++ exe=exe.left(pos); ++ m_programsInMenu+=KGlobal::dirs()->findExe(exe); ++ } ++ } ++ } ++ } ++} ++ ++void KMenu::searchBookmarks(KBookmarkGroup group) ++{ ++ KBookmark bookmark = group.first(); ++ while(!bookmark.isNull()) { ++ if (bookmark.isGroup()) { ++ searchBookmarks(bookmark.toGroup()); ++ } else if (!bookmark.isSeparator() && !bookmark.isNull()) { ++ if (!current_query.matches(bookmark.fullText()+' '+bookmark.url().url()) || !anotherHitMenuItemAllowed(BOOKMARKS)) { ++ bookmark = group.next(bookmark); ++ continue; ++ } ++ ++ HitMenuItem *hit_item = new HitMenuItem (bookmark.fullText(), bookmark.fullText(), ++ bookmark.url(), QString::null, 0, BOOKMARKS, bookmark.icon()); ++ ++ insertSearchResult(hit_item); ++ } ++ bookmark = group.next(bookmark); ++ } ++} ++ ++void KMenu::initSearch() ++{ ++ if (!m_addressBook && KickerSettings::kickoffSearchAddressBook()) ++ m_addressBook = KABC::StdAddressBook::self( false ); ++ ++ if (!bookmarkManager) ++ bookmarkManager = KBookmarkManager::userBookmarksManager(); ++ ++ if (!m_search_plugin) { ++ m_search_plugin_interface = new QObject( this, "m_search_plugin_interface" ); ++ new MyKickoffSearchInterface( this, m_search_plugin_interface, "kickoffsearch interface" ); ++ KTrader::OfferList offers = KTrader::self()->query("KickoffSearch/Plugin"); ++ ++ KService::Ptr service = *offers.begin(); ++ if (service) { ++ int errCode = 0; ++ m_search_plugin = KParts::ComponentFactory::createInstanceFromService<KickoffSearch::Plugin> ++ ( service, m_search_plugin_interface, 0, QStringList(), &errCode); ++ } ++ } ++} ++ ++void KMenu::searchAddressbook() ++{ ++ if (!KickerSettings::kickoffSearchAddressBook()) ++ return; ++ ++ if (!m_addressBook) ++ m_addressBook = KABC::StdAddressBook::self( false ); ++ ++ KABC::AddressBook::ConstIterator it = m_addressBook->begin(); ++ while (it!=m_addressBook->end()) { ++ if (!current_query.matches((*it).assembledName()+' '+(*it).fullEmail())) { ++ it++; ++ continue; ++ } ++ ++ HitMenuItem *hit_item; ++ QString realName = (*it).realName(); ++ if (realName.isEmpty()) ++ realName=(*it).preferredEmail(); ++ ++ if (!(*it).preferredEmail().isEmpty()) { ++ if (!anotherHitMenuItemAllowed(ACTIONS)) { ++ it++; ++ continue; ++ } ++ ++ hit_item = new HitMenuItem (i18n("Send Email to %1").arg(realName), (*it).preferredEmail(), ++ "mailto:"+(*it).preferredEmail(), QString::null, 0, ACTIONS, "mail_new"); ++ ++ insertSearchResult(hit_item); ++ } ++ ++ if (!anotherHitMenuItemAllowed(ACTIONS)) { ++ it++; ++ continue; ++ } ++ ++ hit_item = new HitMenuItem (i18n("Open Addressbook at %1").arg(realName), (*it).preferredEmail(), ++ "kaddressbook:/"+(*it).uid(), QString::null, 0, ACTIONS, "kaddressbook"); ++ ++ insertSearchResult(hit_item); ++ ++ it++; ++ } ++} ++ ++QString KMenu::insertBreaks(const QString& text, QFontMetrics fm, int width, QString leadInsert) ++{ ++ QString result, line; ++ QStringList words = QStringList::split(' ', text); ++ ++ for(QStringList::Iterator it = words.begin(); it != words.end(); ++it) { ++ if (fm.width(line+' '+*it) >= width) { ++ if (!result.isEmpty()) ++ result = result + '\n'; ++ result = result + line; ++ line = leadInsert + *it; ++ } ++ else ++ line = line + ' ' + *it; ++ } ++ if (!result.isEmpty()) ++ result = result + '\n'; ++ ++ return result + line; ++} ++ ++void KMenu::clearSearchResults(bool showHelp) ++{ ++ m_searchResultsWidget->clear(); ++ m_searchResultsWidget->setFocusPolicy(showHelp ? QWidget::NoFocus : QWidget::StrongFocus); ++ setTabOrder(m_kcommand, m_searchResultsWidget); ++ ++ if (showHelp) { ++ const int width = m_searchResultsWidget->width()-10; ++ QFontMetrics fm = m_searchResultsWidget->fontMetrics(); ++ ++ QListViewItem* item; ++ item = new QListViewItem( m_searchResultsWidget, insertBreaks(i18n("- Add ext:type to specify a file extension."), fm, width, " ") ); ++ item->setSelectable(false); ++ item->setMultiLinesEnabled(true); ++ item = new QListViewItem( m_searchResultsWidget, insertBreaks(i18n("- When searching for a phrase, add quotes."), fm, width, " " ) ); ++ item->setSelectable(false); ++ item->setMultiLinesEnabled(true); ++ item = new QListViewItem( m_searchResultsWidget, insertBreaks(i18n("- To exclude search terms, use the minus symbol in front."), fm, width, " " ) ); ++ item->setSelectable(false); ++ item->setMultiLinesEnabled(true); ++ item = new QListViewItem( m_searchResultsWidget, insertBreaks(i18n("- To search for optional terms, use OR."), fm, width, " ") ); ++ item->setSelectable(false); ++ item->setMultiLinesEnabled(true); ++ item = new QListViewItem( m_searchResultsWidget, insertBreaks(i18n("- You can use upper and lower case."), fm, width, " ") ); ++ item->setSelectable(false); ++ item->setMultiLinesEnabled(true); ++ item = new QListViewItem( m_searchResultsWidget, i18n("Search Quick Tips")); ++ item->setSelectable(false); ++ } ++ ++ for (int i=0; i<num_categories; ++i) { ++ categorised_hit_total [i] = 0; ++ max_category_id [i] = base_category_id [i]; ++ } ++} ++ ++void KMenu::doQuery (bool return_pressed) ++{ ++ QString query_str = m_kcommand->lineEdit()->text ().simplifyWhiteSpace (); ++ if (! return_pressed && dontQueryNow (query_str)) { ++ if (query_str.length()<3) ++ clearSearchResults(); ++ else { ++ if (m_searchResultsWidget->firstChild() && m_searchResultsWidget->firstChild()->isSelectable()) { ++ m_searchResultsWidget->setSelected(m_searchResultsWidget->firstChild(),true); ++ } ++ else if (m_searchResultsWidget->childCount()>1) { ++ m_searchResultsWidget->setSelected(m_searchResultsWidget->firstChild()->itemBelow(),true); ++ } ++ } ++ return; ++ } ++ kdDebug() << "Querying for [" << query_str << "]" << endl; ++ current_query.set(query_str); ++ ++ // reset search results ++ HitMenuItem *hit_item; ++ while ((hit_item = m_current_menu_items.take ()) != NULL) { ++ //kndDebug () << " (" << hit_item->id << "," << hit_item->category << ")" << endl; ++ delete hit_item; ++ } ++ ++ clearSearchResults(false); ++ m_searchPixmap->setMovie(QMovie(locate( "data", "kicker/pics/search-running.mng" ))); ++ ++ resetOverflowCategory(); ++ ++ initCategoryTitlesUpdate(); ++ ++ // calculate ? ++ QString cmd = query_str.stripWhiteSpace(); ++ if (!cmd.isEmpty() && (cmd[0].isNumber() || (cmd[0] == '(')) && ++ (QRegExp("[a-zA-Z\\]\\[]").search(cmd) == -1)) ++ { ++ QString result = calculate(cmd); ++ if (!result.isEmpty()) ++ { ++ categorised_hit_total[ACTIONS] ++; ++ HitMenuItem *hit_item = new HitMenuItem (i18n("%1 = %2").arg(query_str, result), QString::null, ++ "kcalc", QString::null, (++max_category_id [ACTIONS]), ACTIONS, "kcalc"); ++ int index = getHitMenuItemPosition (hit_item); ++ m_searchResultsWidget->insertItem(iconForHitMenuItem(hit_item), hit_item->display_name, ++ hit_item->display_info, KGlobal::dirs()->findExe("kcalc"), max_category_id [ACTIONS], index); ++ } ++ } ++ ++ // detect email address ++ if (emailRegExp.exactMatch(query_str)) { ++ categorised_hit_total[ACTIONS] ++; ++ HitMenuItem *hit_item = new HitMenuItem (i18n("Send Email to %1").arg(query_str), QString::null, ++ "mailto:"+query_str, QString::null, (++max_category_id [ACTIONS]), ACTIONS, "mail_new"); ++ int index = getHitMenuItemPosition (hit_item); ++ m_searchResultsWidget->insertItem(iconForHitMenuItem(hit_item), hit_item->display_name, hit_item->display_info, "mailto:"+query_str, max_category_id [ACTIONS], index); ++ } ++ ++ // quick own application search ++ m_programsInMenu.clear(); ++ searchProgramList(QString::null); ++ ++ KURIFilterData filterData; ++ filterData.setData(query_str); ++ filterData.setCheckForExecutables(true); ++ ++ if (KURIFilter::self()->filterURI(filterData)) { ++ ++ QString description; ++ QString exe; ++ ++ switch (filterData.uriType()) { ++ case KURIFilterData::LOCAL_FILE: ++ description = i18n("Open Local File: %1").arg(filterData.uri().url()); ++ break; ++ case KURIFilterData::LOCAL_DIR: ++ description = i18n("Open Local Dir: %1").arg(filterData.uri().url()); ++ break; ++ case KURIFilterData::NET_PROTOCOL: ++ description = i18n("Open Remote Location: %1").arg(filterData.uri().url()); ++ break; ++ case KURIFilterData::SHELL: ++ case KURIFilterData::EXECUTABLE: ++ { ++ exe = KGlobal::dirs()->findExe(filterData.uri().url()); ++#ifdef KDELIBS_SUSE ++ bool gimp_hack = false; ++ if (exe.endsWith("/bin/gimp")) { ++ QStringList::ConstIterator it = m_programsInMenu.begin(); ++ for (; it != m_programsInMenu.end(); ++it) ++ if ((*it).find("bin/gimp-remote-")!=-1) { ++ gimp_hack = true; ++ break; ++ } ++ } ++#endif ++ if (m_programsInMenu.find(exe)!=m_programsInMenu.end() ++#ifdef KDELIBS_SUSE ++ || gimp_hack ++#endif ++ ) ++ exe = QString::null; ++ else if (kapp->authorize("shell_access")) ++ { ++ if( filterData.hasArgsAndOptions() ) ++ exe += filterData.argsAndOptions(); ++ ++ description = i18n("Run '%1'").arg(exe); ++ exe = "kicker:/runcommand"; ++ } ++ } ++ default: ++ break; ++ } ++ ++ if (!description.isEmpty()) { ++ categorised_hit_total[ACTIONS] ++; ++ HitMenuItem *hit_item = new HitMenuItem (description, QString::null, ++ exe.isEmpty() ? filterData.uri() : exe, QString::null, ++ (++max_category_id [ACTIONS]), ACTIONS, exe.isEmpty() ? "fileopen": "run"); ++ int index = getHitMenuItemPosition (hit_item); ++ m_searchResultsWidget->insertItem(iconForHitMenuItem(hit_item), hit_item->display_name, ++ hit_item->display_info, ++ exe.isEmpty() ? filterData.uri().url() : exe, max_category_id [ACTIONS], index); ++ } ++ } ++ ++ // search Konqueror bookmarks; ++ if (!bookmarkManager) ++ bookmarkManager = KBookmarkManager::userBookmarksManager(); ++ ++ if (query_str.length()>=3) ++ searchBookmarks(bookmarkManager->root()); ++ ++ // search KDE addressbook ++ if (query_str.length()>=3) ++ searchAddressbook(); ++ ++ updateCategoryTitles(); ++ ++ if (m_searchResultsWidget->childCount()>1) ++ m_searchResultsWidget->setSelected(m_searchResultsWidget->firstChild()->itemBelow(),true); ++ m_searchActions->clearSelection(); ++ ++ if (!m_search_plugin) ++ initSearch(); ++ ++ // start search plugin only with at least 3 characters ++ if (query_str.length()<3 || !m_search_plugin || (m_search_plugin && !m_search_plugin->daemonRunning()) ) { ++ m_searchPixmap->setPixmap( BarIcon( "find", 32 ) ); ++ fillOverflowCategory(); ++ if (query_str.length()>2 && m_current_menu_items.isEmpty()) ++ reportError (i18n("No matches found")); ++ return; ++ } ++ ++ if (m_search_plugin) { ++ m_search_plugin->query(current_query.get(), KickerSettings::DescriptionAndName || KickerSettings::menuEntryFormat() == KickerSettings::DescriptionOnly); ++ } ++} ++ ++bool KMenu::anotherHitMenuItemAllowed(int cat, bool count) ++{ ++ // update number of hits in this category ++ if (count) ++ categorised_hit_total [cat] ++; ++ ++ // if number of hits in this category is more than allowed, dont process this ++ if (max_category_id [cat] - base_category_id [cat] < max_items(cat)) ++ return true; ++ ++ if (m_overflowCategoryState==None || (m_overflowCategoryState==Filling && m_overflowCategory==cat && ++ max_category_id [cat] + m_overflowList.count() - base_category_id [cat] < max_items(cat) * 2.0)) ++ return true; ++ ++ return false; ++} ++ ++void KMenu::addHitMenuItem(HitMenuItem* item) ++{ ++ if (checkUriInMenu(item->uri)) ++ return; ++ ++ // if number of hits in this category is more than allowed, dont process this ++ if (!anotherHitMenuItemAllowed(item->category, false)) ++ return; ++ ++ insertSearchResult(item); ++} ++ ++void KMenu::insertSearchResult(HitMenuItem* item) ++{ ++ if (m_overflowCategoryState==None) { ++ m_overflowCategoryState = Filling; ++ m_overflowCategory = item->category; ++ } ++ else if (m_overflowCategoryState==Filling && m_overflowCategory!=item->category) ++ m_overflowCategoryState = NotNeeded; ++ ++ if (max_category_id [item->category] - base_category_id [item->category] < max_items(item->category)) { ++ max_category_id [item->category]++; ++ item->id=max_category_id [item->category]; ++ ++ int index = getHitMenuItemPosition (item); ++ ++ kdDebug () << "Adding " << item->uri ++ << "(" << item->mimetype << ") with id=" ++ << max_category_id [item->category] << " at " << index << endl; ++ ++ KMenuItem *hit_item = m_searchResultsWidget->insertItem(iconForHitMenuItem(item), item->display_name, item->display_info, item->uri.url(), max_category_id [item->category], index); ++ hit_item->setService(item->service); ++ ++ kdDebug () << "Done inserting ... " << endl; ++ } ++ else if (m_overflowCategoryState==Filling && m_overflowCategory==item->category && ++ max_category_id [item->category] - base_category_id [item->category] < max_items(item->category) * 2) ++ m_overflowList.append(item); ++} ++ ++void KMenu::searchOver() ++{ ++ m_searchPixmap->setPixmap( BarIcon( "find", 32 ) ); ++ fillOverflowCategory(); ++ if (m_current_menu_items.isEmpty()) { ++ kdDebug() << "No matches found" << endl; ++ reportError (i18n("No matches found")); ++ } ++ if (!m_searchResultsWidget->selectedItem() && !m_searchActions->selectedItem() && m_searchResultsWidget->childCount()>1) { ++ m_searchResultsWidget->setSelected(m_searchResultsWidget->firstChild()->itemBelow(),true); ++ } ++} ++ ++void KMenu::initCategoryTitlesUpdate() ++{ ++ // Need to know if each category was updated with hits or had the first hit ++ // That way we know if we need to changetitle or inserttitle ++ already_added = new bool [num_categories]; ++ for (int i=0; i<num_categories; ++i) ++ already_added [i] = (max_category_id [i] != base_category_id [i]); ++} ++ ++void KMenu::updateCategoryTitles() ++{ ++ // update category title ++ for (int i=0; i<num_categories; ++i) { ++ if (i == OTHER) ++ continue; ++ // nothing is in this category ++ if (max_category_id [i] == base_category_id [i]) ++ continue; ++ ++ KMenuItemSeparator *sep = 0; ++ ++ // if nothing was in this category before but now there is ++ if (! already_added [i]) { ++ // insert a new title for this category ++ int index = getHitMenuItemPosition (new HitMenuItem ( ++ base_category_id[i], ++ i)); ++ QString title = QString ("%1").arg (i18n(categories [i].utf8())); ++ sep = m_searchResultsWidget->insertSeparator(base_category_id [i], title, index); ++ kdDebug () << "Inserting heading with id=" << base_category_id[i] << " for " << categories[i] << " at " << index << endl; ++ } else { ++ // something was already displayed in this category ++ // update the title to reflect the total ++ sep = dynamic_cast<KMenuItemSeparator*>( m_searchResultsWidget->findItem(base_category_id [i]) ); ++ if ( !sep ) ++ continue; ++ kdDebug () << "Changing heading of id=" << base_category_id[i] << " for " << categories[i] << endl; ++ } ++ ++ int max = max_items(i); ++ if (m_overflowCategoryState == Filling && m_overflowCategory == i) ++ max *= 2; ++ ++ if ( categorised_hit_total [i] > max ) { ++ if (m_kerryInstalled) ++ sep->setLink( i18n( "top %1 of %2" ).arg( max ).arg( categorised_hit_total [i] ), QString( "kerry:/%1" ).arg( i ) ); ++ else ++ sep->setText( 0, i18n( "%1 (top %2 of %3)" ).arg( i18n(categories [i].utf8()) ).arg( max ).arg( categorised_hit_total [i] ) ); ++ } ++ else { ++ sep->setLink( QString::null ); ++ } ++ } ++ delete[] already_added; ++ already_added = 0; ++} ++ ++QString KMenu::iconForHitMenuItem(HitMenuItem *hit_item) ++{ ++ // get the icon ++ if (!hit_item->icon.isEmpty()) ++ return hit_item->icon; ++ ++ if (hit_item->category == WEBHIST) { ++ QString favicon = KMimeType::favIconForURL (hit_item->uri); ++ if (! favicon.isEmpty ()) ++ return favicon; ++ } ++ ++ if (mimetype_iconstore.contains (hit_item->mimetype)) ++ return (mimetype_iconstore [hit_item->mimetype]); ++ else { ++ KMimeType::Ptr mimetype_ptr = KMimeType::mimeType (hit_item->mimetype); ++ QString mimetype_icon = mimetype_ptr->icon(QString::null, FALSE); ++ mimetype_iconstore [hit_item->mimetype] = mimetype_icon; ++ return mimetype_icon; ++ } ++ return QString::null; ++} ++ ++void KMenu::slotStartService(KService::Ptr ptr) ++{ ++ accept(); ++ ++ addToHistory(); ++ KApplication::startServiceByDesktopPath(ptr->desktopEntryPath(), ++ QStringList(), 0, 0, 0, "", true); ++ updateRecentlyUsedApps(ptr); ++} ++ ++ ++void KMenu::slotStartURL(const QString& u) ++{ ++ if ( u == "kicker:/goup/" ) { ++ // only m_exitView is connected to this slot, not m_browserView ++ slotGoExitMainMenu(); ++ return; ++ } ++ ++ if ( u == "kicker:/restart/" || u=="kicker:/switchuser/") { ++ slotGoExitSubMenu(u); ++ return; ++ } ++ ++ accept(); ++ ++ if ( u == "kicker:/lock" ) { ++ slotLock(); ++ } ++ else if ( u == "kicker:/logout" ) { ++#ifdef KDELIBS_SUSE ++ QByteArray params; ++ QDataStream stream(params, IO_WriteOnly); ++ stream << 0 << -1 << ""; ++ ++ kapp->dcopClient()->send("ksmserver", "default", "logoutTimed(int,int,QString)", params); ++#else ++ DCOPRef mediamanager("ksmserver", "ksmserver"); ++ DCOPReply reply = mediamanager.call( "logoutTimed", (int)KApplication::ShutdownTypeNone, (int)KApplication::ShutdownModeDefault ); ++ if (!reply.isValid() && KMessageBox::Continue==KMessageBox::warningContinueCancel(this, i18n("Do you really want to end the session?"), ++ i18n("Logout Confirmation"), KGuiItem(i18n("Logout"),"undo"))) ++ kapp->requestShutDown( KApplication::ShutdownConfirmNo, ++ KApplication::ShutdownTypeNone, ++ KApplication::ShutdownModeDefault ); ++ ++#endif ++ } ++ else if ( u == "kicker:/runcommand" ) ++ { ++ runCommand(); ++ } ++ else if ( u == "kicker:/shutdown" ) { ++#ifdef KDELIBS_SUSE ++ QByteArray params; ++ QDataStream stream(params, IO_WriteOnly); ++ stream << 2 << -1 << ""; ++ ++ kapp->dcopClient()->send("ksmserver", "default", "logoutTimed(int,int,QString)", params); ++#else ++ if (KMessageBox::Continue==KMessageBox::warningContinueCancel(this, i18n("Do you really want to turn off the computer?"), ++ i18n("Shutdown Confirmation"), KGuiItem(i18n("Shutdown"),"exit"))) ++ kapp->requestShutDown( KApplication::ShutdownConfirmNo, ++ KApplication::ShutdownTypeHalt, ++ KApplication::ShutdownModeDefault ); ++#endif ++ } ++ else if ( u == "kicker:/restart" ) { ++#ifdef KDELIBS_SUSE ++ QByteArray params; ++ QDataStream stream(params, IO_WriteOnly); ++ stream << 1 << -1 << QString::null; ++ ++ kapp->dcopClient()->send("ksmserver", "default", "logoutTimed(int,int,QString)", params); ++#else ++ if (KMessageBox::Continue==KMessageBox::warningContinueCancel(this, i18n("Do you really want to reset the computer and boot (another operating system)?"), ++ i18n("Restart Confirmation"), KGuiItem(i18n("Restart"),"reload"))) ++ kapp->requestShutDown( KApplication::ShutdownConfirmNo, ++ KApplication::ShutdownTypeReboot, ++ KApplication::ShutdownModeDefault ); ++#endif ++ } ++#ifdef KDELIBS_SUSE ++ else if ( u == "kicker:/suspend_disk" ) { ++ slotSuspend( 1 ); ++ } ++ else if ( u == "kicker:/suspend_ram" ) { ++ slotSuspend( 2 ); ++ } ++ else if ( u == "kicker:/standby" ) { ++ slotSuspend( 3 ); ++ } ++#endif ++ else if ( u == "kicker:/savesession" ) { ++ QByteArray data; ++ kapp->dcopClient()->send( "ksmserver", "default", ++ "saveCurrentSession()", data ); ++ } ++ else if ( u == "kicker:/switchuser" ) { ++ DM().startReserve(); ++ } ++ else if ( u == "kicker:/switchuserafterlock" ) { ++ slotLock(); ++ DM().startReserve(); ++ } ++ else if ( u.startsWith("kicker:/switchuser_") ) ++ DM().lockSwitchVT( u.mid(19).toInt() ); ++ else if ( u.startsWith("kicker:/restart_") ) { ++#ifdef KDELIBS_SUSE ++ QStringList rebootOptions; ++ int def, cur; ++ DM().bootOptions( rebootOptions, def, cur ); ++ ++ QByteArray params; ++ QDataStream stream(params, IO_WriteOnly); ++ stream << 1 << -1 << rebootOptions[u.mid(16).toInt()]; ++ ++ kapp->dcopClient()->send("ksmserver", "default", "logoutTimed(int,int,QString)", params); ++#else ++ KMessageBox::error( this, QString( "Sorry, not implemented." )); ++#endif ++ } ++#warning restart entry not supported ++#if 0 ++ else if ( u == "kicker:/restart_windows" ) { ++ if (KMessageBox::Continue==KMessageBox::warningContinueCancel(this, i18n("Do you really want to reset the computer and boot Microsoft Windows"), i18n("Start Windows Confirmation"), KGuiItem(i18n("Start Windows"),"reload"))) ++ KMessageBox::error( this, QString( "kicker:/restart_windows is not yet implemented " ) ); ++ } ++#endif ++ else if ( u.startsWith("kerry:/")) ++ { ++ QByteArray data; ++ QDataStream arg(data, IO_WriteOnly); ++ arg << m_kcommand->currentText() << kerry_categories[u.mid(7).toInt()]; ++ if (ensureServiceRunning("kerry")) ++ kapp->dcopClient()->send("kerry","search","search(QString,QString)", data); ++ } ++ else { ++ addToHistory(); ++ if (u.startsWith("kaddressbook:/")) { ++ KProcess *proc = new KProcess; ++ *proc << "kaddressbook" << "--uid" << u.mid(14); ++ proc->start(); ++ accept(); ++ return; ++ } else if (u.startsWith("note:/")) { ++ KProcess *proc = new KProcess; ++ *proc << "tomboy"; ++ *proc << "--open-note" << u; ++ if (!proc->start()) ++ KMessageBox::error(0,i18n("Could not start Tomboy.")); ++ return; ++ } ++ else if (u.startsWith("knotes:/") ) { ++ if (ensureServiceRunning("knotes")) { ++ QByteArray data; ++ QDataStream arg(data, IO_WriteOnly); ++ arg << u.mid(9,22); ++ ++ kapp->dcopClient()->send("knotes","KNotesIface","showNote(QString)", data); ++ } ++ return; ++ } ++ ++ kapp->propagateSessionManager(); ++ (void) new KRun( u, parentWidget()); ++ } ++} ++ ++void KMenu::slotContextMenuRequested( QListViewItem * item, const QPoint & pos, int /*col*/ ) ++{ ++ const QObject* source = sender(); ++ ++ if (!item) ++ return; ++ ++ KMenuItem* kitem = dynamic_cast<KMenuItem*>(item); ++ if (!kitem) ++ return; ++ ++ KFileItemList _items; ++ _items.setAutoDelete(true); ++ ++ if (dynamic_cast<KMenuItemSeparator*>(item)) ++ return; ++ ++ m_popupService = kitem->service(); ++ m_popupPath.menuPath = kitem->menuPath(); ++ if (!m_popupService) { ++ m_popupPath.title = kitem->title(); ++ m_popupPath.description = kitem->description(); ++ m_popupPath.path = kitem->path(); ++ m_popupPath.icon = kitem->icon(); ++ ++ if (m_popupPath.path.startsWith(locateLocal("data", QString::fromLatin1("RecentDocuments/")))) { ++ KDesktopFile df(m_popupPath.path,true); ++ m_popupPath.path=df.readURL(); ++ } ++ } ++ ++ m_popupMenu = new KPopupMenu(this); ++ connect(m_popupMenu, SIGNAL(activated(int)), SLOT(slotContextMenu(int))); ++ bool hasEntries = false; ++ ++ m_popupMenu->insertTitle(SmallIcon(kitem->icon()),kitem->title()); ++ ++ if (source==m_favoriteView) ++ { ++ hasEntries = true; ++ m_popupMenu->insertItem(SmallIconSet("remove"), ++ i18n("Remove From Favorites"), RemoveFromFavorites); ++ } ++ else if (!kitem->hasChildren() && !m_popupPath.path.startsWith("system:/") && ++ !m_popupPath.path.startsWith("kicker:/switchuser_") && !m_popupPath.path.startsWith("kicker:/restart_")) ++ { ++ hasEntries = true; ++ int num = m_popupMenu->insertItem(SmallIconSet("bookmark_add"), ++ i18n("Add to Favorites"), AddToFavorites); ++ ++ QStringList favs = KickerSettings::favorites(); ++ if (m_popupService && favs.find(m_popupService->storageId())!=favs.end()) ++ m_popupMenu->setItemEnabled(num, false); ++ else { ++ QStringList::Iterator it; ++ for (it = favs.begin(); it != favs.end(); ++it) ++ { ++ if ((*it)[0]=='/') ++ { ++ KDesktopFile df((*it),true); ++ if (df.readURL().replace("file://",QString::null)==m_popupPath.path) ++ break; ++ } ++ } ++ if (it!=favs.end()) ++ m_popupMenu->setItemEnabled(num, false); ++ } ++ } ++ ++ if (source!=m_exitView) { ++ if (m_popupService || (!m_popupPath.path.startsWith("kicker:/") && !m_popupPath.path.startsWith("system:/") && !m_popupPath.path.startsWith("kaddressbook:/"))) { ++ if (hasEntries) ++ m_popupMenu->insertSeparator(); ++ ++ if (kapp->authorize("editable_desktop_icons") ) ++ { ++ hasEntries = true; ++ if (m_popupPath.menuPath.endsWith("/")) ++ m_popupMenu->insertItem(SmallIconSet("desktop"), ++ i18n("Add Menu to Desktop"), AddMenuToDesktop); ++ else ++ m_popupMenu->insertItem(SmallIconSet("desktop"), ++ i18n("Add Item to Desktop"), AddItemToDesktop); ++ } ++ if (kapp->authorizeKAction("kicker_rmb") && !Kicker::the()->isImmutable()) ++ { ++ hasEntries = true; ++ if (m_popupPath.menuPath.endsWith("/")) ++ m_popupMenu->insertItem(SmallIconSet("kicker"), ++ i18n("Add Menu to Main Panel"), AddMenuToPanel); ++ else ++ m_popupMenu->insertItem(SmallIconSet("kicker"), ++ i18n("Add Item to Main Panel"), AddItemToPanel); ++ } ++ if (kapp->authorizeKAction("menuedit") && !kitem->menuPath().isEmpty()) ++ { ++ hasEntries = true; ++ if (kitem->menuPath().endsWith("/")) ++ m_popupMenu->insertItem(SmallIconSet("kmenuedit"), i18n("Edit Menu"), EditMenu); ++ else ++ m_popupMenu->insertItem(SmallIconSet("kmenuedit"), i18n("Edit Item"), EditItem); ++ } ++ if (kapp->authorize("run_command") && (m_popupService || (!m_popupPath.menuPath.isEmpty() && !m_popupPath.menuPath.endsWith("/")))) ++ { ++ hasEntries = true; ++ m_popupMenu->insertItem(SmallIconSet("run"), ++ i18n("Put Into Run Dialog"), PutIntoRunDialog); ++ } ++ } ++ if (source==m_searchResultsWidget || ((source==m_favoriteView || source==m_recentlyView || source == m_systemView) && !m_popupService && !m_popupPath.path.startsWith("kicker:/")) ) { ++ QString uri; ++ if (m_popupService) ++ uri = locate("apps", m_popupService->desktopEntryPath()); ++ else ++ uri = m_popupPath.path; ++ ++ QString mimetype = QString::null; ++ if ( m_popupPath.path.startsWith( "system:/media/" ) ) ++ mimetype = media_mimetypes[m_popupPath.path]; ++ ++ KFileItem* item = new KFileItem(uri, mimetype, KFileItem::Unknown); ++ _items.append( item ); ++ ++ const KURL kurl(uri); ++ KActionCollection act(this); ++ ++ KonqPopupMenu * konqPopupMenu = new KonqPopupMenu( KonqBookmarkManager::self(), _items, ++ kurl, act, (KNewMenu*)NULL, this, ++ item->isLocalFile() ? KonqPopupMenu::ShowProperties : KonqPopupMenu::NoFlags, ++ KParts::BrowserExtension::DefaultPopupItems ); ++ ++ if (konqPopupMenu->count()) { ++ if (hasEntries) { ++ m_popupMenu->insertSeparator(); ++ m_popupMenu->insertItem(SmallIconSet("add"),i18n("Advanced"), konqPopupMenu); ++ } ++ else { ++ delete m_popupMenu; ++ m_popupMenu = (KPopupMenu*)konqPopupMenu; ++ m_popupMenu->insertTitle(SmallIcon(kitem->icon()),kitem->title(),-1,0); ++ } ++ hasEntries = true; ++ } ++ } ++ } ++ ++ if (source==m_recentlyView) { ++ m_popupMenu->insertSeparator(); ++ if (m_popupService) ++ m_popupMenu->insertItem(SmallIconSet("history_clear"), ++ i18n("Clear Recently Used Applications"), ClearRecentlyUsedApps); ++ else ++ m_popupMenu->insertItem(SmallIconSet("history_clear"), ++ i18n("Clear Recently Used Documents"), ClearRecentlyUsedDocs); ++ } ++ ++ if (hasEntries) { ++ m_isShowing = true; ++ m_popupMenu->exec(pos); ++ m_isShowing = false; ++ } ++ ++ delete m_popupMenu; ++ m_popupMenu = 0; ++} ++ ++void KMenu::slotContextMenu(int selected) ++{ ++ KServiceGroup::Ptr g; ++ QByteArray ba; ++ QDataStream ds(ba, IO_WriteOnly); ++ ++ KURL src,dest; ++ KIO::CopyJob *job; ++ ++ KProcess *proc; ++ ++ QStringList favs = KickerSettings::favorites(); ++ ++ switch (selected) { ++ case AddItemToDesktop: ++ accept(); ++ if (m_popupService) { ++ src.setPath( KGlobal::dirs()->findResource( "apps", m_popupService->desktopEntryPath() ) ); ++ dest.setPath( KGlobalSettings::desktopPath() ); ++ dest.setFileName( src.fileName() ); ++ ++ job = KIO::copyAs( src, dest ); ++ job->setDefaultPermissions( true ); ++ } ++ else { ++ KDesktopFile* df = new KDesktopFile( newDesktopFile(KURL(m_popupPath.path), KGlobalSettings::desktopPath() ) ); ++ df->writeEntry("GenericName", m_popupPath.description); ++ df->writeEntry( "Icon", m_popupPath.icon ); ++ df->writePathEntry( "URL", m_popupPath.path ); ++ df->writeEntry( "Name", m_popupPath.title ); ++ df->writeEntry( "Type", "Link" ); ++ df->sync(); ++ delete df; ++ } ++ accept(); ++ break; ++ ++ case AddItemToPanel: ++ accept(); ++ if (m_popupService) ++ kapp->dcopClient()->send("kicker", "Panel", "addServiceButton(QString)", m_popupService->desktopEntryPath()); ++ else ++#warning FIXME special RecentDocuments/foo.desktop handling ++ kapp->dcopClient()->send("kicker", "Panel", "addURLButton(QString)", m_popupPath.path); ++ accept(); ++ break; ++ ++ case EditItem: ++ case EditMenu: ++ accept(); ++ proc = new KProcess(this); ++ *proc << KStandardDirs::findExe(QString::fromLatin1("kmenuedit")); ++ *proc << "/"+m_popupPath.menuPath.section('/',-200,-2) << m_popupPath.menuPath.section('/', -1); ++ proc->start(); ++ break; ++ ++ case PutIntoRunDialog: ++ accept(); ++ if (m_popupService) ++ kapp->dcopClient()->send("kdesktop", "default", "popupExecuteCommand(QString)", m_popupService->exec()); ++ else ++#warning FIXME special RecentDocuments/foo.desktop handling ++ kapp->dcopClient()->send("kdesktop", "default", "popupExecuteCommand(QString)", m_popupPath.path); ++ accept(); ++ break; ++ ++ case AddMenuToDesktop: { ++ accept(); ++ KDesktopFile *df = new KDesktopFile( newDesktopFile(KURL("programs:/"+m_popupPath.menuPath),KGlobalSettings::desktopPath())); ++ df->writeEntry( "Icon", m_popupPath.icon ); ++ df->writePathEntry( "URL", "programs:/"+m_popupPath.menuPath ); ++ df->writeEntry( "Name", m_popupPath.title ); ++ df->writeEntry( "Type", "Link" ); ++ df->sync(); ++ delete df; ++ ++ break; ++ } ++ case AddMenuToPanel: ++ accept(); ++ ds << "foo" << m_popupPath.menuPath; ++ kapp->dcopClient()->send("kicker", "Panel", "addServiceMenuButton(QString,QString)", ba); ++ break; ++ ++ case AddToFavorites: ++ if (m_popupService) { ++ if (favs.find(m_popupService->storageId())==favs.end()) { ++ KService::Ptr p = KService::serviceByStorageId(m_popupService->storageId()); ++ m_favoriteView->insertMenuItem(p, serviceMenuEndId()+favs.count()+1); ++ favs+=m_popupService->storageId(); ++ } ++ } ++ else { ++ QStringList::Iterator it; ++ for (it = favs.begin(); it != favs.end(); ++it) { ++ if ((*it)[0]=='/') { ++ KDesktopFile df((*it),true); ++ if (df.readURL().replace("file://",QString::null)==m_popupPath.path) ++ break; ++ } ++ } ++ if (it==favs.end()) { ++ QString file = KickerLib::newDesktopFile(m_popupPath.path); ++ KDesktopFile df(file); ++ df.writeEntry("Encoding", "UTF-8"); ++ df.writeEntry("Type","Link"); ++ df.writeEntry("Name", m_popupPath.title); ++ df.writeEntry("GenericName", m_popupPath.description); ++ df.writeEntry("Icon", m_popupPath.icon); ++ df.writeEntry("URL", m_popupPath.path); ++ ++ m_favoriteView->insertItem(m_popupPath.icon, m_popupPath.title, m_popupPath.description, ++ m_popupPath.path, serviceMenuEndId()+favs.count()+1, -1); ++ ++ favs+=file; ++ } ++ } ++ KickerSettings::setFavorites(favs); ++ KickerSettings::writeConfig(); ++ m_browserDirty=true; ++ m_stacker->raiseWidget(FavoriteTab); ++ break; ++ ++ case RemoveFromFavorites: ++ if (m_popupService) { ++ favs.erase(favs.find(m_popupService->storageId())); ++ ++ for (QListViewItemIterator it(m_favoriteView); it.current(); ++it) { ++ KMenuItem* kitem = static_cast<KMenuItem*>(it.current()); ++ if (kitem->service() && kitem->service()->storageId() == m_popupService->storageId()) { ++ delete it.current(); ++ break; ++ } ++ } ++ } ++ else { ++ for (QStringList::Iterator it = favs.begin(); it != favs.end(); ++it) { ++ if ((*it)[0]=='/') { ++ KDesktopFile df((*it),true); ++ if (df.readURL().replace("file://",QString::null)==m_popupPath.path) { ++ QFile::remove((*it)); ++ favs.erase(it); ++ break; ++ } ++ } ++ } ++ for (QListViewItemIterator it(m_favoriteView); it.current(); ++it) { ++ KMenuItem* kitem = static_cast<KMenuItem*>(it.current()); ++ if (!kitem->service() && kitem->path() == m_popupPath.path) { ++ delete it.current(); ++ break; ++ } ++ } ++ } ++ m_favoriteView->slotMoveContent(); ++ KickerSettings::setFavorites(favs); ++ KickerSettings::writeConfig(); ++ m_browserDirty=true; ++ m_stacker->raiseWidget(FavoriteTab); ++ break; ++ ++ case ClearRecentlyUsedApps: ++ clearRecentAppsItems(); ++ break; ++ ++ case ClearRecentlyUsedDocs: ++ clearRecentDocsItems(); ++ break; ++ ++ default: ++ break; ++ } ++} ++ ++void KMenu::resizeEvent ( QResizeEvent * e ) ++{ ++ //kdDebug() << "resizeEvent " << size() << endl; ++ KMenuBase::resizeEvent(e); ++ int ypos = 0; ++ // this is the height remaining to fill ++ int left_height = height(); ++ ++ if ( m_orientation == BottomUp ) ++ { ++ m_resizeHandle->move( e->size().width() - 19, 3); ++ ++ // put the search widget at the top of the menu and give it its desired ++ // height ++ m_search->mainWidget()->setGeometry( 0, ypos, width(), ++ m_search->minimumSize().height() ); ++ left_height -= m_search->minimumSize().height(); ++ ypos += m_search->minimumSize().height(); ++ ++ // place the footer widget at the bottom of the menu and give it its desired ++ // height ++ m_footer->mainWidget()->setGeometry( 0, height() - m_footer->minimumSize().height(), ++ width(), m_footer->minimumSize().height() ); ++ left_height -= m_footer->minimumSize().height(); ++ ++ // place the button box above the footer widget, horizontal placement ++ // has the width of the edge graphics subtracted ++ m_tabBar->setGeometry(button_box_left.width(), ++ height() - m_footer->minimumSize().height() - ++ m_tabBar->sizeHint().height(), ++ width() - button_box_left.width(), ++ m_tabBar->sizeHint().height() ); ++ left_height -= m_tabBar->sizeHint().height(); ++ ++ // place the main (stacker) widget below the search widget, ++ // in the remaining vertical space ++ m_stacker->setGeometry(0, ypos, ++ width(), ++ left_height ); ++ ++ } ++ else // TopDown orientation ++ { ++ // place the 'footer' widget at the top of the menu and give it ++ // its desired height ++ m_footer->mainWidget()->setGeometry( 0, ++ ypos /*height() - m_footer->minimumSize().height()*/, ++ width(), ++ m_footer->minimumSize().height() ); ++ ypos += m_footer->minimumSize().height(); ++ left_height -= m_footer->minimumSize().height(); ++ ++ // place the button box next at the top of the menu. ++ // has the width of the edge graphics subtracted ++ m_tabBar->setGeometry(button_box_left.width(), ypos, width() - button_box_left.width(), ++ m_tabBar->sizeHint().height()); ++ ++ ypos += m_tabBar->sizeHint().height(); ++ left_height -= m_tabBar->sizeHint().height(); ++ ++ // put the search widget above the footer widget ++ // height ++ m_search->mainWidget()->setGeometry( 0, ++ height() - m_search->minimumSize().height(), ++ width(), ++ m_search->minimumSize().height() ++ ); ++ left_height -= m_search->minimumSize().height(); ++ ++ // place the main (stacker) widget below the button box, ++ // in the remaining vertical space ++ m_stacker->setGeometry(0, ypos, ++ width(), ++ left_height ); ++ m_resizeHandle->move( e->size().width() - 19, e->size().height() - 19); ++ } ++ paintSearchTab( false ); ++} ++ ++void KMenu::mousePressEvent ( QMouseEvent * e ) ++{ ++ if ( m_orientation == BottomUp ) { ++ if (e->x() > width() - m_resizeHandle->width() && ++ e->y() < m_resizeHandle->height() ) ++ { ++ m_isresizing = true; ++ } ++ } ++ else { ++ if (e->x() > width() - m_resizeHandle->width() && ++ e->y() > height() - m_resizeHandle->height() ) ++ { ++ m_isresizing = true; ++ } ++ } ++ KMenuBase::mousePressEvent(e); ++} ++ ++void KMenu::mouseReleaseEvent ( QMouseEvent * /*e*/ ) ++{ ++ m_isresizing = false; ++} ++ ++void KMenu::mouseMoveEvent ( QMouseEvent * e ) ++{ ++ if ( hasMouseTracking() && m_isresizing ) { ++ m_stacker->setMinimumSize( QSize(0, 0) ); ++ m_stacker->setMaximumSize( QSize(32000, 32000) ); ++ int newWidth = QMAX( e->x() - x(), minimumSizeHint().width() ); ++ if ( m_orientation == BottomUp ) { ++ int newHeight = QMAX( height() - e->y(), minimumSizeHint().height() + 10 ); ++ int newY = y() + height() - newHeight; ++ setGeometry( x(), newY, newWidth, newHeight); ++ } ++ else { ++ setGeometry( x(), y(), newWidth, QMAX( e->y(), minimumSizeHint().height() + 10 )); ++ } ++ } ++} ++ ++void KMenu::clearedHistory() ++{ ++ saveConfig(); ++} ++ ++void KMenu::saveConfig() ++{ ++ KickerSettings::setHistory( m_kcommand->historyItems() ); ++ KickerSettings::setCompletionItems( m_kcommand->completionObject()->items() ); ++ KickerSettings::writeConfig(); ++} ++ ++void KMenu::notifyServiceStarted(KService::Ptr service) ++{ ++ // Inform other applications (like the quickstarter applet) ++ // that an application was started ++ QByteArray params; ++ QDataStream stream(params, IO_WriteOnly); ++ stream << "minicli" << service->storageId(); ++ kdDebug() << "minicli appLauncher dcop signal: " << service->storageId() << endl; ++ KApplication::kApplication()->dcopClient()->emitDCOPSignal("appLauncher", ++ "serviceStartedByStorageId(QString,QString)", params); ++} ++ ++void KMenu::parseLine( bool final ) ++{ ++ QString cmd = m_kcommand->currentText().stripWhiteSpace(); ++ m_filterData->setData( cmd ); ++ ++ if( final ) ++ KURIFilter::self()->filterURI( *(m_filterData), m_finalFilters ); ++ else ++ KURIFilter::self()->filterURI( *(m_filterData), m_middleFilters ); ++ ++ m_iconName = m_filterData->iconName(); ++ ++ kdDebug (1207) << "Command: " << m_filterData->uri().url() << endl; ++ kdDebug (1207) << "Arguments: " << m_filterData->argsAndOptions() << endl; ++} ++ ++// report error as a title in the menu ++void KMenu::reportError (QString error) ++{ ++ int index = 1000; //getHitMenuItemPosition (new HitMenuItem (base_category_id[0], 0)); ++ kndDebug () << "Inserting error:" << error << " at position " << index << endl; ++ m_searchResultsWidget->insertSeparator(OTHER_ID_BASE + 120, error, index); ++} ++ ++int KMenu::getHitMenuItemPosition ( HitMenuItem *hit_item) ++{ ++ QPtrListIterator<HitMenuItem> it (m_current_menu_items); ++ const HitMenuItem *cur_item; ++ int pos = 0; ++ while ((cur_item = it.current ()) != NULL) { ++ ++it; ++ if ((cur_item->category!=hit_item->category || !cur_item->display_name.isEmpty()) && (*hit_item) < (*cur_item)) ++ break; ++ pos++; ++ } ++ m_current_menu_items.insert (pos, hit_item); ++ ++ return pos + 1; ++} ++ ++bool KMenu::checkUriInMenu( const KURL &uri) ++{ ++ QPtrListIterator<HitMenuItem> it (m_current_menu_items); ++ const HitMenuItem *cur_item; ++ while ((cur_item = it.current ()) != NULL) { ++ ++it; ++ if (cur_item->uri == uri ) ++ return true; ++ } ++ ++ return false; ++} ++ ++void KMenu::searchActionClicked(QListViewItem* item) ++{ ++ accept(); ++ ++ addToHistory(); ++ if (item==m_searchIndex) { ++ QByteArray data; ++ QDataStream arg(data, IO_WriteOnly); ++ arg << m_kcommand->currentText(); ++ ++ if (ensureServiceRunning("kerry")) ++ kapp->dcopClient()->send("kerry","search","search(QString)", data); ++ } ++ else { ++ KURIFilterData data; ++ QStringList list; ++ data.setData( m_kcommand->currentText() ); ++ list << "kurisearchfilter" << "kuriikwsfilter"; ++ ++ if( !KURIFilter::self()->filterURI(data, list) ) { ++ KDesktopFile file("searchproviders/google.desktop", true, "services"); ++ data.setData(file.readEntry("Query").replace("\\{@}", m_kcommand->currentText())); ++ } ++ ++ (void) new KRun( data.uri(), parentWidget()); ++ } ++} ++ ++void KMenu::addToHistory() ++{ ++ QString search = m_kcommand->currentText().stripWhiteSpace(); ++ ++ if (search.length()<4) ++ return; ++ ++ m_kcommand->addToHistory( search ); ++} ++ ++QString KMenu::newDesktopFile(const KURL& url, const QString &directory) ++{ ++ QString base = url.fileName(); ++ if (base.endsWith(".desktop")) ++ base.truncate(base.length()-8); ++ QRegExp r("(.*)(?=-\\d+)"); ++ if (r.search(base) > -1) ++ base = r.cap(1); ++ ++ QString file = base + ".desktop"; ++ ++ for(int n = 1; ++n; ) ++ { ++ if (!QFile::exists(directory+file)) ++ break; ++ ++ file = QString("%2-%1.desktop").arg(n).arg(base); ++ } ++ return directory+file; ++} ++ ++void KMenu::updateRecentlyUsedApps(KService::Ptr &service) ++{ ++ QString strItem(service->desktopEntryPath()); ++ ++ // don't add an item from root kmenu level ++ if (!strItem.contains('/')) ++ { ++ return; ++ } ++ ++ // add it into recent apps list ++ RecentlyLaunchedApps::the().appLaunched(strItem); ++ RecentlyLaunchedApps::the().save(); ++ RecentlyLaunchedApps::the().m_bNeedToUpdate = true; ++} ++ ++QSize KMenu::sizeHint() const ++{ ++#warning FIXME ++ // this should be only for the inner area so layout changes do not break it ++ const int width = kMin(KickerSettings::kMenuWidth(), QApplication::desktop()->screen()->width()-50); ++ ++ const int height = kMin(KickerSettings::kMenuHeight(), QApplication::desktop()->screen()->height()-50); ++ QSize wanted(width, height); ++ kdDebug() << "show " << minimumSizeHint() << " " << m_stacker->minimumSizeHint() << " " ++ << m_searchFrame->minimumSizeHint() << " " << wanted << endl; ++ bool isDefault = wanted.isNull(); ++ wanted = wanted.expandedTo(minimumSizeHint()); ++ if ( isDefault ) ++ wanted.setHeight( wanted.height() + ( m_favoriteView->goodHeight() - m_stacker->minimumSizeHint().height() ) ); ++ ++ return wanted; ++} ++ ++QSize KMenu::minimumSizeHint() const ++{ ++ QSize minsize; ++ minsize.setWidth( minsize.width() + m_tabBar->sizeHint().width() ); ++ minsize.setWidth( QMAX( minsize.width(), ++ m_search->minimumSize().width() ) ); ++ minsize.setWidth( QMAX( minsize.width(), ++ m_search->minimumSize().width() ) ); ++ ++ minsize.setHeight( minsize.height() + ++ m_search->minimumSize().height() + ++ m_footer->minimumSize().height() + ++ 180 ); // 180 is a very rough guess for 32 icon size ++ return minsize; ++} ++ ++void KMenu::slotFavoritesMoved( QListViewItem* item, QListViewItem* /*afterFirst*/, QListViewItem* afterNow) ++{ ++ KMenuItem* kitem = dynamic_cast<KMenuItem*>(item); ++ KMenuItem* kafterNow = dynamic_cast<KMenuItem*>(afterNow); ++ ++ QStringList favs = KickerSettings::favorites(); ++ QStringList::Iterator it; ++ QString addFav = QString::null; ++ ++ // remove at old position ++ if (kitem->service()) ++ { ++ favs.erase(favs.find(kitem->service()->storageId())); ++ addFav = kitem->service()->storageId(); ++ } ++ else ++ { ++ for (it = favs.begin(); it != favs.end(); ++it) ++ { ++ if ((*it)[0]=='/') ++ { ++ KDesktopFile df((*it),true); ++ if (df.readURL().replace("file://",QString::null)==kitem->path()) ++ { ++ addFav = *it; ++ favs.erase(it); ++ break; ++ } ++ } ++ } ++ } ++ ++ if (addFav.isEmpty()) ++ return; ++ ++ if (!kafterNow || dynamic_cast<KMenuSpacer*>(afterNow)) ++ { ++ favs.prepend(addFav); ++ } ++ else ++ { ++ // add at new position ++ for (it = favs.begin(); it != favs.end(); ++it) ++ { ++ if ((*it)[0]=='/' && !kafterNow->service()) ++ { ++ KDesktopFile df((*it),true); ++ if (df.readURL().replace("file://",QString::null)==kafterNow->path()) ++ { ++ kdDebug() << "insert after " << kafterNow->path() << endl; ++ favs.insert(++it,addFav); ++ break; ++ } ++ } ++ else if (kafterNow->service() && *it==kafterNow->service()->storageId()) ++ { ++ kdDebug() << "insert after service " << kafterNow->service() << endl; ++ favs.insert(++it,addFav); ++ break; ++ } ++ } ++ } ++ kdDebug() << "favs " << favs << endl; ++ ++ KickerSettings::setFavorites(favs); ++ KickerSettings::writeConfig(); ++ ++ m_favoriteView->slotMoveContent(); ++} ++ ++void KMenu::updateMedia() ++{ ++ QStringList devices = m_mediaWatcher->devices(); ++ if ( devices.isEmpty() ) ++ return; ++ ++ int nId = serviceMenuStartId(); ++ if ( m_media_id ) { ++ for ( int i = m_media_id + 1 ;; ++i ) ++ { ++ KMenuItem *item = m_systemView->findItem( i ); ++ if ( !item ) ++ break; ++ if ( !item->path().startsWith( "system:/" ) ) ++ break; ++ media_mimetypes.remove(item->path()); ++ delete item; ++ } ++ nId = m_media_id + 1; ++ } else { ++ m_media_id = nId; ++ m_systemView->insertSeparator( nId++, i18n("Media"), -1); ++ } ++ ++ for ( QStringList::ConstIterator it = devices.constBegin(); it != devices.constEnd(); ++it ) ++ { ++ QString id = ( *it ); ++ QString name = *++it; ++ QString label = *++it; ++ QString userLabel = ( *++it ); ++ bool mountable = ( *++it == "true" ); // bool ++ ( void )mountable; ++ QString deviceNode = ( *++it ); ++ QString mountPoint = ( *++it ); ++ QString fsType = ( *++it ); ++ bool mounted = ( *++it == "true" ); // bool ++ QString baseURL = ( *++it ); ++ QString mimeType = ( *++it ); ++ QString iconName = ( *++it ); ++ ++ media_mimetypes["system:/media/"+name] = mimeType; ++ ++ if ( iconName.isEmpty() ) // no user icon, query the MIME type ++ { ++ KMimeType::Ptr mime = KMimeType::mimeType( mimeType ); ++ iconName = mime->icon( QString::null, false ); ++ } ++ ++ QString descr = deviceNode; ++ if ( mounted ) ++ { ++ descr = mountPoint; ++ // calc the free/total space ++ struct statfs sfs; ++ if ( statfs( QFile::encodeName( mountPoint ), &sfs ) == 0 ) ++ { ++ uint64_t total = ( uint64_t )sfs.f_blocks * sfs.f_bsize; ++ uint64_t avail = ( uint64_t )( getuid() ? sfs.f_bavail : sfs.f_bfree ) * sfs.f_bsize; ++ if ( avail < total && avail > 1024 ) { ++ label += " " + i18n( "(%1 available)" ).arg( KIO::convertSize(avail) ); ++ } ++ } ++ } ++ m_systemView->insertItem( iconName, userLabel.isEmpty() ? label : userLabel, ++ descr, "system:/media/" + name, nId++, -1 ); ++ ++ ++it; // skip separator ++ } ++} ++ ++bool KMenu::ensureServiceRunning(const QString & service) ++{ ++ QStringList URLs; ++ QByteArray data, replyData; ++ QCString replyType; ++ QDataStream arg(data, IO_WriteOnly); ++ arg << service << URLs; ++ ++ if ( !kapp->dcopClient()->call( "klauncher", "klauncher", "start_service_by_desktop_name(QString,QStringList)", ++ data, replyType, replyData) ) { ++ qWarning( "call to klauncher failed."); ++ return false; ++ } ++ QDataStream reply(replyData, IO_ReadOnly); ++ ++ if ( replyType != "serviceResult" ) ++ { ++ qWarning( "unexpected result '%s' from klauncher.", replyType.data()); ++ return false; ++ } ++ int result; ++ QCString dcopName; ++ QString error; ++ reply >> result >> dcopName >> error; ++ if (result != 0) ++ { ++ qWarning("Error starting: %s", error.local8Bit().data()); ++ return false; ++ } ++ return true; ++} ++ ++void KMenu::slotFavDropped(QDropEvent * ev, QListViewItem *after ) ++{ ++ QStringList favs = KickerSettings::favorites(); ++ KMenuItem *newItem = 0; ++ ++ if (KMenuItemDrag::canDecode(ev)) ++ { ++ KMenuItemInfo item; ++ KMenuItemDrag::decode(ev,item); ++ ++ if (item.m_s) ++ { ++ if (favs.find(item.m_s->storageId())==favs.end()) ++ { ++ newItem = m_favoriteView->insertMenuItem(item.m_s, serviceMenuEndId()+favs.count()+1); ++ favs += item.m_s->storageId(); ++ } ++ } ++ else ++ { ++ QString uri = item.m_path; ++ if (uri.startsWith(locateLocal("data", QString::fromLatin1("RecentDocuments/")))) { ++ KDesktopFile df(uri,true); ++ uri=df.readURL(); ++ } ++ ++ QStringList::Iterator it; ++ for (it = favs.begin(); it != favs.end(); ++it) ++ { ++ if ((*it)[0]=='/') ++ { ++ KDesktopFile df((*it),true); ++ if (df.readURL().replace("file://",QString::null)==uri) ++ break; ++ } ++ } ++ if (it==favs.end()) ++ { ++ QString file = KickerLib::newDesktopFile(uri); ++ KDesktopFile df(file); ++ df.writeEntry("Encoding", "UTF-8"); ++ df.writeEntry("Type","Link"); ++ df.writeEntry("Name", item.m_title); ++ df.writeEntry("GenericName", item.m_description); ++ df.writeEntry("Icon", item.m_icon); ++ df.writeEntry("URL", uri); ++ ++ newItem = m_favoriteView->insertItem(item.m_icon, item.m_title, item.m_description, ++ uri, serviceMenuEndId()+favs.count()+1, -1); ++ favs += file; ++ } ++ } ++ } ++ else if (QTextDrag::canDecode(ev)) ++ { ++ QString text; ++ QTextDrag::decode(ev,text); ++ ++ if (text.endsWith(".desktop")) ++ { ++ KService::Ptr p = KService::serviceByDesktopPath(text.replace("file://",QString::null)); ++ if (p && favs.find(p->storageId())==favs.end()) { ++ newItem = m_favoriteView->insertMenuItem(p, serviceMenuEndId()+favs.count()+1); ++ favs+=p->storageId(); ++ } ++ } ++ else ++ { ++ QStringList::Iterator it; ++ for (it = favs.begin(); it != favs.end(); ++it) ++ { ++ if ((*it)[0]=='/') ++ { ++ KDesktopFile df((*it),true); ++ if (df.readURL().replace("file://",QString::null)==text) ++ break; ++ } ++ } ++ if (it==favs.end()) ++ { ++ KFileItem* item = new KFileItem(text, QString::null, KFileItem::Unknown); ++ KURL kurl(text); ++ ++ QString file = KickerLib::newDesktopFile(text); ++ KDesktopFile df(file); ++ df.writeEntry("Encoding", "UTF-8"); ++ df.writeEntry("Type","Link"); ++ df.writeEntry("Name", item->name()); ++ df.writeEntry("GenericName", i18n("Directory: %1").arg(kurl.upURL().path())); ++ df.writeEntry("Icon", item->iconName()); ++ df.writeEntry("URL", text); ++ ++ newItem = m_favoriteView->insertItem(item->iconName(), item->name(), i18n("Directory: %1").arg(kurl.upURL().path()), text, serviceMenuEndId()+favs.count()+1, -1); ++ favs += file; ++ } ++ } ++ } ++ ++ if ( newItem ) { ++ if (!after && m_favoriteView->childCount()>0) { ++ newItem->moveItem( m_favoriteView->firstChild() ); ++ m_favoriteView->firstChild()->moveItem( newItem ); ++ } ++ else ++ newItem->moveItem( after ); ++ KickerSettings::setFavorites(favs); ++ slotFavoritesMoved( newItem, 0, after ); ++ } ++ m_stacker->raiseWidget(m_favoriteView); ++} ++ ++void KMenu::resetOverflowCategory() ++{ ++ if (m_overflowCategoryState==NotNeeded) ++ m_overflowList.setAutoDelete( true ); ++ ++ m_overflowList.clear(); ++ m_overflowList.setAutoDelete( false ); ++ m_overflowCategoryState = None; ++ m_overflowCategory = num_categories; ++} ++ ++void KMenu::fillOverflowCategory() ++{ ++ if (m_overflowCategoryState==Filling) { ++ initCategoryTitlesUpdate(); ++ for (HitMenuItem * item = m_overflowList.first(); item; item = m_overflowList.next() ) { ++ max_category_id [item->category]++; ++ item->id=max_category_id [item->category]; ++ ++ KMenuItem *hit_item = m_searchResultsWidget->insertItem(iconForHitMenuItem(item), item->display_name, item->display_info, item->uri.url(), max_category_id [item->category], getHitMenuItemPosition (item)); ++ hit_item->setService(item->service); ++ } ++ updateCategoryTitles(); ++ } ++} ++ ++int KMenu::max_items(int category) const ++{ ++ if (category==ACTIONS) ++ return 10; ++ ++ return 5; ++} ++ ++#define DBUS_HAL_INTERFACE "org.freedesktop.Hal" ++#define DBUS_HAL_SYSTEM_POWER_INTERFACE "org.freedesktop.Hal.Device.SystemPowerManagement" ++#define HAL_UDI_COMPUTER "/org/freedesktop/Hal/devices/computer" ++ ++#ifdef KDELIBS_SUSE ++#include <liblazy.h> ++#endif ++ ++void KMenu::insertSuspendOption( int &nId, int &index ) ++{ ++#ifdef KDELIBS_SUSE ++ int supported = -1; ++ bool suspend_ram, suspend_disk, standby; ++ ++ liblazy_hal_get_property_bool(HAL_UDI_COMPUTER, "power_management.can_suspend", &supported); ++ if (supported == 1) ++ suspend_ram = true; ++ else ++ suspend_ram = false; ++ liblazy_hal_get_property_bool(HAL_UDI_COMPUTER, "power_management.can_standby", &supported); ++ if (supported == 1) ++ standby = true; ++ else ++ standby = false; ++ liblazy_hal_get_property_bool(HAL_UDI_COMPUTER, "power_management.can_hibernate", &supported); ++ if (supported == 1) ++ suspend_disk = true; ++ else ++ suspend_disk = false; ++ ++ if (liblazy_hal_is_caller_privileged("org.freedesktop.hal.power-management.hibernate") != 1) ++ suspend_disk = false; ++ if (liblazy_hal_is_caller_privileged("org.freedesktop.hal.power-management.suspend") != 1) ++ suspend_ram = false; ++ if (liblazy_hal_is_caller_privileged("org.freedesktop.hal.power-management.standby") != 1) ++ standby = false; ++ ++ if ( ! ( standby + suspend_ram + suspend_disk ) ) ++ return; ++ ++ i18n("Suspend Computer"); ++ ++ if ( suspend_disk ) ++ m_exitView->leftView()->insertItem( "suspend2disk", i18n( "Suspend to Disk" ), ++ i18n( "Pause without logging out" ), "kicker:/suspend_disk", nId++, index++ ); ++ ++ if ( suspend_ram ) ++ m_exitView->leftView()->insertItem( "suspend2ram", i18n( "Suspend to RAM" ), ++ i18n( "Pause without logging out" ), "kicker:/suspend_ram", nId++, index++ ); ++ ++ if ( standby ) ++ m_exitView->leftView()->insertItem( "player_pause", i18n( "Standby" ), ++ i18n( "Pause without logging out" ), "kicker:/standby", nId++, index++ ); ++#endif ++} ++ ++void KMenu::slotSuspend(int id) ++{ ++#ifdef KDELIBS_SUSE ++ int error = 0; ++ int wake = 0; ++ DBusMessage *reply = 0; ++ ++ if (id == 1) { ++ error = liblazy_dbus_system_send_method_call(DBUS_HAL_INTERFACE, ++ HAL_UDI_COMPUTER, ++ DBUS_HAL_SYSTEM_POWER_INTERFACE, ++ "Hibernate", ++ &reply, ++ DBUS_TYPE_INVALID); ++ } else if (id == 2) ++ error = liblazy_dbus_system_send_method_call(DBUS_HAL_INTERFACE, ++ HAL_UDI_COMPUTER, ++ DBUS_HAL_SYSTEM_POWER_INTERFACE, ++ "Suspend", ++ &reply, ++ DBUS_TYPE_INT32, ++ &wake, ++ DBUS_TYPE_INVALID); ++ else if (id == 3) ++ error = liblazy_dbus_system_send_method_call(DBUS_HAL_INTERFACE, ++ HAL_UDI_COMPUTER, ++ DBUS_HAL_SYSTEM_POWER_INTERFACE, ++ "Standby", ++ &reply, ++ DBUS_TYPE_INVALID); ++ else ++ return; ++ if (error) ++#endif ++ KMessageBox::error(this, i18n("Suspend failed")); ++ ++} ++ ++// vim:cindent:sw=4: +--- kicker/ui/kmenuitembase.ui (Revision 0) ++++ kicker/ui/kmenuitembase.ui (Revision 849791) +@@ -0,0 +1,141 @@ ++<!DOCTYPE UI><UI version="3.3" stdsetdef="1"> ++<class>KMenuItemBase</class> ++<widget class="QWidget"> ++ <property name="name"> ++ <cstring>KMenuItemBase</cstring> ++ </property> ++ <property name="geometry"> ++ <rect> ++ <x>0</x> ++ <y>0</y> ++ <width>514</width> ++ <height>80</height> ++ </rect> ++ </property> ++ <property name="sizePolicy"> ++ <sizepolicy> ++ <hsizetype>7</hsizetype> ++ <vsizetype>5</vsizetype> ++ <horstretch>0</horstretch> ++ <verstretch>0</verstretch> ++ </sizepolicy> ++ </property> ++ <property name="minimumSize"> ++ <size> ++ <width>0</width> ++ <height>0</height> ++ </size> ++ </property> ++ <property name="maximumSize"> ++ <size> ++ <width>32767</width> ++ <height>80</height> ++ </size> ++ </property> ++ <property name="caption"> ++ <string>KMenuItemBase</string> ++ </property> ++ <grid> ++ <property name="name"> ++ <cstring>unnamed</cstring> ++ </property> ++ <property name="margin"> ++ <number>2</number> ++ </property> ++ <widget class="QLayoutWidget" row="0" column="1"> ++ <property name="name"> ++ <cstring>layout11</cstring> ++ </property> ++ <vbox> ++ <property name="name"> ++ <cstring>unnamed</cstring> ++ </property> ++ <widget class="QLabel"> ++ <property name="name"> ++ <cstring>itemTitle</cstring> ++ </property> ++ <property name="sizePolicy"> ++ <sizepolicy> ++ <hsizetype>7</hsizetype> ++ <vsizetype>1</vsizetype> ++ <horstretch>1</horstretch> ++ <verstretch>0</verstretch> ++ </sizepolicy> ++ </property> ++ <property name="font"> ++ <font> ++ <pointsize>14</pointsize> ++ </font> ++ </property> ++ <property name="text"> ++ <string></string> ++ </property> ++ <property name="textFormat"> ++ <enum>RichText</enum> ++ </property> ++ <property name="alignment"> ++ <set>WordBreak|AlignTop</set> ++ </property> ++ </widget> ++ <widget class="QLabel"> ++ <property name="name"> ++ <cstring>itemDescription</cstring> ++ </property> ++ <property name="sizePolicy"> ++ <sizepolicy> ++ <hsizetype>7</hsizetype> ++ <vsizetype>7</vsizetype> ++ <horstretch>0</horstretch> ++ <verstretch>1</verstretch> ++ </sizepolicy> ++ </property> ++ <property name="paletteForegroundColor"> ++ <color> ++ <red>188</red> ++ <green>188</green> ++ <blue>188</blue> ++ </color> ++ </property> ++ <property name="text"> ++ <string></string> ++ </property> ++ <property name="textFormat"> ++ <enum>RichText</enum> ++ </property> ++ <property name="alignment"> ++ <set>WordBreak|AlignTop</set> ++ </property> ++ </widget> ++ </vbox> ++ </widget> ++ <widget class="QLayoutWidget" row="0" column="0"> ++ <property name="name"> ++ <cstring>layout4</cstring> ++ </property> ++ <vbox> ++ <property name="name"> ++ <cstring>unnamed</cstring> ++ </property> ++ <widget class="QLabel"> ++ <property name="name"> ++ <cstring>itemPixmap</cstring> ++ </property> ++ <property name="minimumSize"> ++ <size> ++ <width>64</width> ++ <height>64</height> ++ </size> ++ </property> ++ <property name="text"> ++ <string></string> ++ </property> ++ <property name="alignment"> ++ <set>AlignTop|AlignHCenter</set> ++ </property> ++ </widget> ++ </vbox> ++ </widget> ++ </grid> ++</widget> ++<layoutdefaults spacing="6" margin="11"/> ++</UI> +--- kicker/ui/addappletvisualfeedback.cpp (Revision 849788) ++++ kicker/ui/addappletvisualfeedback.cpp (Revision 849791) +@@ -51,6 +51,7 @@ + m_richText(0), + m_dissolveDelta(-1), + m_frames(1), ++ m_moveTimer(0, "m_moveTimer"), + m_dirty(false) + { + setFocusPolicy(NoFocus); +--- kicker/ui/kickoff_bar.cpp (Revision 0) ++++ kicker/ui/kickoff_bar.cpp (Revision 849791) +@@ -0,0 +1,200 @@ ++/***************************************************************** ++ ++ Copyright (c) 1996-2000 the kicker authors. See file AUTHORS. ++ Copyright (c) 2006 Dirk Mueller <mueller@kde.org> ++ ++ This program is free software; you can redistribute it and/or ++ modify it under the terms of the GNU General Public ++ License as published by the Free Software Foundation; either ++ version 2 of the License, or (at your option) any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; see the file COPYING. If not, write to ++ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ++ Boston, MA 02110-1301, USA. ++ ++******************************************************************/ ++ ++#include "kickoff_bar.h" ++#include "itemview.h" ++ ++#include <qiconset.h> ++#include <qpainter.h> ++#include <qcursor.h> ++#include <qstyle.h> ++#include <qapplication.h> ++ ++#include <kdebug.h> ++#include "kickerSettings.h" ++ ++KickoffTabBar::KickoffTabBar(QWidget* parent, const char* name) ++ : QTabBar(parent, name), m_tabsActivated(true) ++{ ++ setAcceptDrops(true); ++} ++ ++void KickoffTabBar::deactivateTabs(bool b) ++{ ++ m_tabsActivated = !b; ++ ++ update(); ++} ++ ++void KickoffTabBar::paint(QPainter* p, QTab* t, bool selected) const ++{ ++ QStyle::SFlags flags = QStyle::Style_Default; ++ ++ if (isEnabled() && t->isEnabled()) ++ flags |= QStyle::Style_Enabled; ++ if ( m_tabsActivated && selected ) ++ flags |= QStyle::Style_Selected; ++// else if(t == d->pressed) ++// flags |= QStyle::Style_Sunken; ++ //selection flags ++ if(t->rect().contains(mapFromGlobal(QCursor::pos()))) ++ flags |= QStyle::Style_MouseOver; ++ style().drawControl( QStyle::CE_TabBarTab, p, this, t->rect(), ++ colorGroup(), flags, QStyleOption(t) ); ++ ++ paintLabel( p, t->rect(), t, t->identifier() == keyboardFocusTab() ); ++} ++ ++ ++void KickoffTabBar::paintLabel(QPainter* p, const QRect& br, QTab* t, bool has_focus) const ++{ ++ QRect r = br; ++ ++ bool selected = m_tabsActivated && (currentTab() == t->identifier()); ++ int vframe = style().pixelMetric( QStyle::PM_TabBarTabVSpace, this ); ++ ++ p->setFont( font() ); ++ QFontMetrics fm = p->fontMetrics(); ++ int fw = fm.size( Qt::SingleLine|Qt::ShowPrefix, t->text() ).width(); ++ ++ QRect rt(r); ++ rt.setWidth(fw); ++ ++ if ( t->iconSet()) ++ { ++ // the tab has an iconset, draw it in the right mode ++ QIconSet::Mode mode = (t->isEnabled() && isEnabled()) ++ ? QIconSet::Normal : QIconSet::Disabled; ++ if ( mode == QIconSet::Normal && has_focus ) ++ mode = QIconSet::Active; ++ QPixmap pixmap = t->iconSet()->pixmap( QIconSet::Large, mode ); ++ int pixw = pixmap.width(); ++ int pixh = pixmap.height(); ++ int xoff = br.x() + (br.width() - pixw)/2; ++ int yoff = br.y() + (br.height() - 4 - pixh - ((KickerSettings::kickoffTabBarFormat() != KickerSettings::IconOnly) ? fm.height() : 0) - vframe)/2; ++ ++ p->drawPixmap( xoff, 4 + yoff, pixmap ); ++ ++ r.setTop(vframe/2 + yoff + pixh - 8); ++ rt.setTop(vframe/2 + yoff + pixh - 8); ++ rt.setHeight(((KickerSettings::kickoffTabBarFormat() != KickerSettings::IconOnly) ? fm.height() : 0) + vframe/2); ++ } ++ else ++ rt.setHeight(vframe/2 + fm.height()); ++ ++ rt.setWidth(fw+8); ++ rt.moveCenter(r.center()); ++ ++ QStyle::SFlags flags = QStyle::Style_Default; ++ ++ if (isEnabled() && t->isEnabled()) ++ flags |= QStyle::Style_Enabled; ++ if (has_focus) ++ flags |= QStyle::Style_HasFocus; ++ if ( selected ) ++ flags |= QStyle::Style_Selected; ++ // else if(t == d->pressed) ++ // flags |= QStyle::Style_Sunken; ++ if(t->rect().contains(mapFromGlobal(QCursor::pos()))) ++ flags |= QStyle::Style_MouseOver; ++ style().drawControl( QStyle::CE_TabBarLabel, p, this, rt, ++ t->isEnabled() ? colorGroup(): palette().disabled(), ++ flags, QStyleOption(t) ); ++} ++ ++QSize KickoffTabBar::sizeHint() const ++{ ++ QSize s = QTabBar::sizeHint(); ++ ++ return s; ++} ++ ++void KickoffTabBar::layoutTabs() ++{ ++ QTabBar::layoutTabs(); ++ ++ QFontMetrics fm = fontMetrics(); ++ int fh = ((KickerSettings::kickoffTabBarFormat() != KickerSettings::IconOnly) ? fm.height() : 0) + 4; ++ ++ int hframe = style().pixelMetric( QStyle::PM_TabBarTabHSpace, this ); ++ int vframe = style().pixelMetric( QStyle::PM_TabBarTabVSpace, this ); ++ int overlap = style().pixelMetric( QStyle::PM_TabBarTabOverlap, this ); ++ ++ QSize s; ++ for (int t = 0; t < count(); ++t) ++ { ++ QTab* tab = tabAt(t); ++ if (tab->iconSet()) ++ s = s.expandedTo(tab->iconSet()->pixmap(QIconSet::Large, QIconSet::Normal).size()); ++ } ++ ++ int x = 0; ++ for (int t = 0; t < count(); ++t) { ++ QTab* tab = tabAt(QApplication::reverseLayout() ? count() - t - 1 : t); ++ int h = fh; ++ if (tab->iconSet()) ++ h += 4 + s.height() + 4; ++ QRect r = tab->rect(); ++ ++ int fw = fm.size( Qt::SingleLine|Qt::ShowPrefix, tab->text() ).width(); ++ int iw = 0; ++ if ( tab->iconSet() != 0 ) ++ iw = tab->iconSet()->pixmap( QIconSet::Large, QIconSet::Normal ).width(); ++ int w = QMAX(iw, fw + 6 + 6 ) + hframe; ++ h += ((KickerSettings::kickoffTabBarFormat() != KickerSettings::IconOnly) ? fm.height() : 0) + vframe; ++ tab->setRect(QRect(QPoint(x, 0), style().sizeFromContents(QStyle::CT_TabBarTab, this, ++ QSize(w, h), QStyleOption(tab)))); ++ x += tab->rect().width() - overlap; ++ } ++} ++ ++void KickoffTabBar::dragEnterEvent(QDragEnterEvent* event) ++{ ++ event->accept(KMenuItemDrag::canDecode(event)); ++} ++ ++void KickoffTabBar::dragMoveEvent(QDragMoveEvent* event) ++{ ++ QTab* t = selectTab(event->pos()); ++ ++ // ### uhhh, look away ++ if (t && t->identifier() == 0) ++ { ++ setCurrentTab(t); ++ } ++} ++ ++void KickoffTabBar::mousePressEvent( QMouseEvent * e ) ++{ ++ if ( e->button() != LeftButton ) { ++ e->ignore(); ++ return; ++ } ++ QTab *t = selectTab( e->pos() ); ++ if ( t && t->isEnabled() ) { ++ emit tabClicked(t); ++ } ++ QTabBar::mousePressEvent(e); ++} ++ ++#include "kickoff_bar.moc" ++// vim:cindent:sw=4: +--- kicker/ui/media_watcher.h (Revision 0) ++++ kicker/ui/media_watcher.h (Revision 849791) +@@ -0,0 +1,51 @@ ++/***************************************************************** ++ ++Copyright (c) 2006 Stephan Kulow <coolo@novell.com> ++ ++Permission is hereby granted, free of charge, to any person obtaining a copy ++of this software and associated documentation files (the "Software"), to deal ++in the Software without restriction, including without limitation the rights ++to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++copies of the Software, and to permit persons to whom the Software is ++furnished to do so, subject to the following conditions: ++ ++The above copyright notice and this permission notice shall be included in ++all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN ++AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ ++******************************************************************/ ++ ++#ifndef _media_watcher_ ++#define _media_watcher_ ++ ++#include <dcopobject.h> ++#include <qobject.h> ++#include <qstringlist.h> ++ ++class MediaWatcher : public QObject, public DCOPObject ++{ ++ Q_OBJECT ++ K_DCOP ++ ++ QStringList m_devices; ++ void updateDevices(); ++ ++k_dcop: ++ void slotMediumAdded(QString medium, bool a); ++ ++signals: ++ void mediumChanged(); ++ ++public: ++ MediaWatcher(QObject *parent); ++ ++ QStringList devices() const { return m_devices; } ++}; ++ ++#endif +--- kicker/ui/appletop_mnu.h (Revision 849788) ++++ kicker/ui/appletop_mnu.h (Revision 849791) +@@ -47,6 +47,9 @@ + signals: + void escapePressed(); + ++protected slots: ++ void toggleLegacy(); ++ + protected: + void keyPressEvent(QKeyEvent* e); + }; +--- kicker/ui/flipscrollview.h (Revision 0) ++++ kicker/ui/flipscrollview.h (Revision 849791) +@@ -0,0 +1,118 @@ ++/***************************************************************** ++ ++Copyright (c) 2006 Will Stephenson <wstephenson@novell.com> ++ ++Permission is hereby granted, free of charge, to any person obtaining a copy ++of this software and associated documentation files (the "Software"), to deal ++in the Software without restriction, including without limitation the rights ++to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++copies of the Software, and to permit persons to whom the Software is ++furnished to do so, subject to the following conditions: ++ ++The above copyright notice and this permission notice shall be included in ++all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN ++AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ ++******************************************************************/ ++ ++/* ++ * Flip scroll menu ++ * Each level of the menu is a separate QListView ++ * Child items are added to their own QListView. ++ * When a parent is clicked, we look up its child menu and insert ++ * that in a QScrollView, then scroll to it. ++ * ++ * Need to intercept QListViewItems' parent param and instead of ++ * inserting directly into parent, insert into parent item's listview ++ * ++ * So need ++ * - adapted QLVI ++ * - wrap QLV and offer same interface ++ */ ++ ++#ifndef FLIPSCROLLVIEW_H ++#define FLIPSCROLLVIEW_H ++ ++#include <qscrollview.h> ++#include <qlistview.h> ++#include <qframe.h> ++#include <qtimer.h> ++#include <qpainter.h> ++#include <kstandarddirs.h> ++#include "service_mnu.h" ++ ++class ItemView; ++ ++class BackFrame : public QFrame ++{ ++ Q_OBJECT ++ ++public: ++ BackFrame( QWidget *parent ); ++ virtual void drawContents( QPainter *p ); ++ ++ void enterEvent ( QEvent * ); ++ void leaveEvent( QEvent * ); ++ void mousePressEvent ( QMouseEvent * e ); ++ ++signals: ++ void clicked(); ++ ++private: ++ QPixmap left_triangle; ++ bool mouse_inside; ++}; ++ ++class FlipScrollView : public QScrollView ++{ ++ Q_OBJECT ++public: ++ enum State{ StoppedLeft, StoppedRight, ScrollingLeft, ScrollingRight }; ++ FlipScrollView( QWidget * parent = 0, const char * name = 0 ); ++ ~FlipScrollView(); ++ ++ ItemView *currentView() const; ++ ItemView *leftView() const; ++ ItemView *rightView() const; ++ ItemView *prepareLeftMove(bool clear=true); ++ ItemView *prepareRightMove(); ++ ++ void flipScroll(const QString& selectMenuPath = QString::null); ++ void showBackButton(bool enable); ++ bool showsBackButton() const {return mShowBack;} ++ ++protected slots: ++ void slotScrollTimer(); ++ ++signals: ++ void startService(KService::Ptr kservice); ++ void startURL(const QString& u); ++ void rightButtonPressed(QListViewItem*,const QPoint&,int); ++ void backButtonClicked(); ++ ++protected: ++ void viewportResizeEvent ( QResizeEvent * ); ++ ++private: ++ ItemView * mLeftView; ++ ItemView * mRightView; ++// ItemView * mCurrentView; ++ int mStepsRemaining; ++ State mState; ++ QTimer * mTimer; ++ BackFrame *mBackrow; ++ QString mSelectMenuPath; ++ int mScrollDirection; ++ bool mShowBack; ++}; ++ ++ ++ ++ ++#endif +--- kicker/ui/k_new_mnu.h (Revision 0) ++++ kicker/ui/k_new_mnu.h (Revision 849791) +@@ -0,0 +1,342 @@ ++/***************************************************************** ++ ++ Copyright (c) 1996-2000 the kicker authors. See file AUTHORS. ++ Copyright (c) 2006 Debajyoti Bera <dbera.web@gmail.com> ++ ++ This program is free software; you can redistribute it and/or ++ modify it under the terms of the GNU General Public ++ License as published by the Free Software Foundation; either ++ version 2 of the License, or (at your option) any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; see the file COPYING. If not, write to ++ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ++ Boston, MA 02110-1301, USA. ++ ++******************************************************************/ ++ ++#ifndef __k_new_mnu_h__ ++#define __k_new_mnu_h__ ++ ++#include <dcopobject.h> ++#include <qintdict.h> ++#include <qpixmap.h> ++#include <qframe.h> ++#include <qtoolbutton.h> ++#include <qscrollview.h> ++#include <qtimer.h> ++#include <qbitmap.h> ++#include <qvbox.h> ++#include <qregexp.h> ++ ++#include <kabc/addressbook.h> ++#include <kabc/stdaddressbook.h> ++#include "../interfaces/kickoff-search-plugin.h" ++ ++#include "kmenubase.h" ++#include "service_mnu.h" ++#include "query.h" ++ ++class KickerClientMenu; ++class KickoffTabBar; ++class KBookmarkMenu; ++class KActionCollection; ++class KBookmarkOwner; ++class Panel; ++class QWidgetStack; ++class KHistoryCombo; ++class QScrollView; ++class PopupMenuTitle; ++class MediaWatcher; ++class KURIFilterData; ++class KBookmarkGroup; ++class KBookmarkManager; ++class ItemView; ++class FlipScrollView; ++class QListViewItem; ++class KMenuItem; ++class QListView; ++class QTabBar; ++class QTab; ++ ++static QString categories[14] = {I18N_NOOP("Actions"), I18N_NOOP("Applications"), I18N_NOOP("Bookmarks"), ++ I18N_NOOP("Notes"), I18N_NOOP("Emails"), I18N_NOOP("Files"), I18N_NOOP("Music"), ++ I18N_NOOP("Browsing History"), I18N_NOOP("Chat Logs"), I18N_NOOP("Feeds"), ++ I18N_NOOP("Pictures"), I18N_NOOP("Videos"), I18N_NOOP("Documentation"), ++ I18N_NOOP("Others")}; ++ ++static QString kerry_categories[14] = {"contacts", "applications", "webpages", "everything", "conversations", ++ "everything", "media", "webpages", "conversations", "webpages", "images", ++ "media", "everything", "everything"}; ++ ++enum MenuOrientation { BottomUp, TopDown, UnDetermined }; ++enum OverflowCategoryState { None, Filling, NotNeeded }; ++ ++class KMenu : public KMenuBase ++{ ++ Q_OBJECT ++ Q_PROPERTY (bool KStyleMenuDropShadow READ useKStyleMenuDropShadow ) ++ ++public: ++ KMenu(); ++ ~KMenu(); ++ ++ int insertClientMenu(KickerClientMenu *p); ++ void removeClientMenu(int id); ++ ++ bool useKStyleMenuDropShadow() const { return true; } ++ ++ virtual void showMenu(); ++ virtual bool eventFilter(QObject*, QEvent*); ++ ++ void clearRecentAppsItems(); ++ void clearRecentDocsItems(); ++ bool highlightMenuItem(const QString& /*id*/) { return false;} ++ ++ void selectFirstItem() {} ++ void popup(const QPoint&, int indexAtPoint); ++ ++ enum MaskEffect { Plain, Dissolve }; ++ ++ virtual QSize sizeHint() const; ++ virtual QSize minimumSizeHint() const; ++ ++ void searchOver(); ++ void initCategoryTitlesUpdate(); ++ bool anotherHitMenuItemAllowed(int cat, bool count=true); ++ void addHitMenuItem(HitMenuItem*); ++ void insertSearchResult(HitMenuItem* item); ++ ++ void updateCategoryTitles(); ++ ++signals: ++ void aboutToHide(); ++ void aboutToShow(); ++ ++public slots: ++ virtual void initialize(); ++ ++ virtual void hide(); ++ virtual void show(); ++ ++ void stackWidgetRaised(QWidget*); ++ ++protected slots: ++ void slotLock(); ++ void slotOpenHomepage(); ++ void slotLogout(); ++ void slotPopulateSessions(); ++ void slotSessionActivated( int ); ++ void slotGoSubMenu(const QString& relPath); ++ void slotGoBack(); ++ void slotGoExitMainMenu(); ++ void slotGoExitSubMenu(const QString& url); ++ void tabClicked(QTab*); ++ ++ void paletteChanged(); ++ virtual void configChanged(); ++ void updateRecent(); ++ ++ void initSearch(); ++ void searchAccept(); ++ void searchChanged(const QString &); ++ // when timeout happens or doQueryNow calls ++ void doQuery (bool return_pressed = false); ++ void searchActionClicked(QListViewItem*); ++ ++ void slotStartService(KService::Ptr); ++ void slotStartURL(const QString&); ++ void slotContextMenuRequested( QListViewItem * item, const QPoint & pos, int col ); ++ ++ void clearedHistory(); ++ ++ void slotSloppyTimeout(); ++ ++ void slotContextMenu(int); ++ void slotFavoritesMoved( QListViewItem*, QListViewItem*, QListViewItem* ); ++ ++ void updateMedia(); ++ void slotFavDropped(QDropEvent * e, QListViewItem *after ); ++ void slotSuspend(int id); ++ ++protected: ++ virtual void paintEvent(QPaintEvent *); ++ virtual void resizeEvent ( QResizeEvent * ); ++ virtual void mousePressEvent ( QMouseEvent * e ); ++ virtual void mouseReleaseEvent ( QMouseEvent * e ); ++ virtual void mouseMoveEvent ( QMouseEvent * e ); ++ ++ void doNewSession(bool lock); ++ void createRecentMenuItems(); ++ void insertStaticItems(); ++ void insertStaticExitItems(); ++ void insertSuspendOption( int &id, int &index ); ++ virtual void clearSubmenus(); ++// void raiseStackWidget(QWidget *view); ++ ++ bool runCommand(); ++ ++ void setupUi(); ++ ++ void saveConfig(); ++ void searchProgramList(QString relPath); ++ void searchBookmarks(KBookmarkGroup); ++ void searchAddressbook(); ++ ++ void createNewProgramList(); ++ void createNewProgramList(QString relPath); ++ ++ void paintSearchTab( bool active ); ++ ++ void goSubMenu(const QString& relPath, bool keyboard = false); ++ void setOrientation(MenuOrientation orientation); ++ ++private: ++ int serviceMenuStartId() { return 5242; } ++ int serviceMenuEndId() { return 5242; } ++ ++ void fillMenu( KServiceGroup::Ptr &_root, KServiceGroup::List &_list, ++ const QString &_relPath, ItemView* view, int & id ); ++ ++ void fillSubMenu(const QString& relPath, ItemView *view); ++ ++ QPopupMenu *sessionsMenu; ++ int client_id; ++ bool delay_init; ++ QIntDict<KickerClientMenu> clients; ++ KActionCollection *actionCollection; ++ PopupMenuList dynamicSubMenus; ++ ++ QTimer m_sloppyTimer; ++ QTimer m_mediaFreeTimer; ++ MediaWatcher * m_mediaWatcher; ++ QRegion m_sloppyRegion; ++ QRect m_sloppySource; ++ bool m_sloppySourceClicked; ++ QWidget * m_sloppyWidget; ++ ItemView * m_recentlyView; ++ ItemView * m_favoriteView; ++ ItemView * m_searchResultsWidget; ++ QListView * m_searchActions; ++ FlipScrollView * m_browserView; ++ ItemView * m_systemView; ++ FlipScrollView * m_exitView; ++ QVBox * m_searchWidget; ++ QLabel * m_resizeHandle; ++ ++ bool m_isresizing; ++ // timer for search without pressing enter feature ++ QTimer *input_timer, *init_search_timer; ++ ++ Query current_query; ++ ++ bool dontQueryNow(const QString &); ++ ++ // start timeout timer to call doQuery is enough time has passed since last keypress ++ void checkToDoQuery (const QString &); ++ // when return is pressed ++ void doQueryNow (); ++ void clearSearchResults(bool showHelp = true); ++ ++ int *max_category_id; // maximum id in this category: max_category_id - base_category_id gives the current number of hits displayed in this category ++ int *categorised_hit_total; // current number of hits returned in each category ++ ++ bool ensureServiceRunning(const QString & service); ++ ++ QString iconForHitMenuItem(HitMenuItem *hit_item); ++ ++ int getHitMenuItemPosition (HitMenuItem *hit_item); ++ QMap<QString, QString> mimetype_iconstore; ++ QMap<QString, QString> media_mimetypes; ++ // report error as a menu item ++ void reportError (QString err); ++ void addToHistory(); ++ ++ int max_items(int category) const; ++ QString TOP_CATEGORY_STRING; ++ bool *already_added; ++ ++ void notifyServiceStarted(KService::Ptr service); ++ void parseLine( bool final ); ++ QString m_iconName; ++ QStringList m_middleFilters; ++ QStringList m_finalFilters; ++ KURIFilterData* m_filterData; ++ QPtrList<HitMenuItem> m_current_menu_items; ++ QListViewItem *m_searchIndex, *m_searchInternet; ++ ++ bool checkUriInMenu(const KURL &uri); ++ ++ QRegExp emailRegExp,uriRegExp,uri2RegExp,authRegExp; ++ ++ KBookmarkManager *bookmarkManager; ++ KABC::AddressBook* m_addressBook; ++ ++ enum ContextMenuEntry { AddItemToPanel, EditItem, AddMenuToPanel, EditMenu, ++ AddItemToDesktop, AddMenuToDesktop, PutIntoRunDialog, ++ AddToFavorites, RemoveFromFavorites, ClearRecentlyUsedApps, ++ ClearRecentlyUsedDocs }; ++ struct PopupPath ++ { ++ QString title, description, icon, path, menuPath; ++ }; ++ ++ enum KickoffTabEntry { FavoriteTab, ApplicationsTab, ComputerTab, ++ HistoryTab, LeaveTab, SearchTab, NumTabs }; ++ ++ KPopupMenu* m_popupMenu; ++ KService* m_popupService; ++ PopupPath m_popupPath; ++ ++ KickoffTabBar* m_tabBar; ++ QTab* m_tabs[NumTabs]; ++ ++ QString newDesktopFile(const KURL& url, const QString &directory); ++ void updateRecentlyUsedApps(KService::Ptr &service); ++ ++ QPixmap main_border_lc; ++ QPixmap main_border_rc; ++ QPixmap main_border_tl; ++ QPixmap main_border_tr; ++ QPixmap button_box_left; ++ ++ QPixmap search_tab_left; ++ QPixmap search_tab_right; ++ QPixmap search_tab_center; ++ ++ QPixmap search_tab_top_left; ++ QPixmap search_tab_top_right; ++ QPixmap search_tab_top_center; ++ ++ QWidgetStack *m_stacker; ++ ++ QStringList m_programsInMenu; ++ QStringList m_newInstalledPrograms, m_seenPrograms; ++ bool m_seenProgramsChanged; ++ QString m_currentDate; ++ ++ MenuOrientation m_orientation; ++ bool m_toolTipsEnabled; ++ int m_media_id; ++ ++ bool m_recentDirty, m_browserDirty, m_kerryInstalled, m_isShowing; ++ ++ KickoffSearch::Plugin* m_search_plugin; ++ QObject* m_search_plugin_interface; ++ ++ OverflowCategoryState m_overflowCategoryState; ++ QPtrList<HitMenuItem> m_overflowList; ++ int m_overflowCategory; ++ ++ void resetOverflowCategory(); ++ void fillOverflowCategory(); ++ ++ QString insertBreaks(const QString& text, QFontMetrics fm, int width, QString leadInsert = QString::null); ++}; ++ ++#endif +--- kicker/ui/appletop_mnu.cpp (Revision 849788) ++++ kicker/ui/appletop_mnu.cpp (Revision 849791) +@@ -30,6 +30,7 @@ + #include "appletop_mnu.h" + #include "container_button.h" + #include "containerarea.h" ++#include "kickerSettings.h" + + PanelAppletOpMenu::PanelAppletOpMenu(int actions, QPopupMenu *opMenu, const QPopupMenu* appletsMenu, + const QString & title, const QString &icon, +@@ -159,6 +160,20 @@ + } + } + ++ if ((actions & PanelAppletOpMenu::KMenuEditor)) ++ { ++ if (needSeparator) ++ { ++ insertSeparator(); ++ needSeparator = false; ++ } ++ ++ if (KickerSettings::legacyKMenu()) ++ insertItem(SmallIcon("suse"), i18n("Switch to SUSE Menu Style"), this, SLOT(toggleLegacy())); ++ else ++ insertItem(SmallIcon("about_kde"), i18n("Switch to KDE Menu Style"), this, SLOT(toggleLegacy())); ++ } ++ + if ((actions & PanelAppletOpMenu::KMenuEditor) && kapp->authorizeKAction("menuedit")) + { + if (needSeparator) +@@ -205,4 +220,11 @@ + QPopupMenu::keyPressEvent(e); + } + ++void PanelAppletOpMenu::toggleLegacy() ++{ ++ KickerSettings::setLegacyKMenu(!KickerSettings::legacyKMenu()); ++ KickerSettings::writeConfig(); ++ Kicker::the()->restart(); ++} ++ + #include "appletop_mnu.moc" +--- kicker/ui/kmenubase.ui (Revision 0) ++++ kicker/ui/kmenubase.ui (Revision 849791) +@@ -0,0 +1,300 @@ ++<!DOCTYPE UI><UI version="3.3" stdsetdef="1"> ++<class>KMenuBase</class> ++<widget class="QDialog"> ++ <property name="name"> ++ <cstring>KMenu</cstring> ++ </property> ++ <property name="geometry"> ++ <rect> ++ <x>0</x> ++ <y>0</y> ++ <width>723</width> ++ <height>580</height> ++ </rect> ++ </property> ++ <property name="caption"> ++ <string>KMenu</string> ++ </property> ++ <property name="frameShadow" stdset="0"> ++ <string>MShadow</string> ++ </property> ++ <property name="frameShape" stdset="0"> ++ <string>MShape</string> ++ </property> ++ <widget class="QLayoutWidget"> ++ <property name="name"> ++ <cstring>m_search</cstring> ++ </property> ++ <property name="geometry"> ++ <rect> ++ <x>20</x> ++ <y>40</y> ++ <width>190</width> ++ <height>54</height> ++ </rect> ++ </property> ++ <hbox> ++ <property name="name"> ++ <cstring>unnamed</cstring> ++ </property> ++ <property name="margin"> ++ <number>0</number> ++ </property> ++ <property name="spacing"> ++ <number>0</number> ++ </property> ++ <widget class="QFrame"> ++ <property name="name"> ++ <cstring>m_searchFrame</cstring> ++ </property> ++ <property name="sizePolicy"> ++ <sizepolicy> ++ <hsizetype>5</hsizetype> ++ <vsizetype>0</vsizetype> ++ <horstretch>0</horstretch> ++ <verstretch>0</verstretch> ++ </sizepolicy> ++ </property> ++ <property name="minimumSize"> ++ <size> ++ <width>0</width> ++ <height>52</height> ++ </size> ++ </property> ++ <property name="maximumSize"> ++ <size> ++ <width>32767</width> ++ <height>52</height> ++ </size> ++ </property> ++ <property name="frameShape"> ++ <enum>StyledPanel</enum> ++ </property> ++ <property name="frameShadow"> ++ <enum>Raised</enum> ++ </property> ++ <property name="lineWidth"> ++ <number>0</number> ++ </property> ++ <hbox> ++ <property name="name"> ++ <cstring>unnamed</cstring> ++ </property> ++ <widget class="QLayoutWidget"> ++ <property name="name"> ++ <cstring>layout18</cstring> ++ </property> ++ <hbox> ++ <property name="name"> ++ <cstring>unnamed</cstring> ++ </property> ++ <widget class="QLabel"> ++ <property name="name"> ++ <cstring>m_searchLabel</cstring> ++ </property> ++ <property name="backgroundOrigin"> ++ <enum>ParentOrigin</enum> ++ </property> ++ <property name="font"> ++ <font> ++ <pointsize>14</pointsize> ++ </font> ++ </property> ++ <property name="text"> ++ <string>Search:</string> ++ </property> ++ </widget> ++ <widget class="KHistoryCombo"> ++ <property name="name"> ++ <cstring>m_kcommand</cstring> ++ </property> ++ <property name="sizePolicy"> ++ <sizepolicy> ++ <hsizetype>7</hsizetype> ++ <vsizetype>0</vsizetype> ++ <horstretch>0</horstretch> ++ <verstretch>0</verstretch> ++ </sizepolicy> ++ </property> ++ </widget> ++ <widget class="QLabel"> ++ <property name="name"> ++ <cstring>m_searchPixmap</cstring> ++ </property> ++ <property name="sizePolicy"> ++ <sizepolicy> ++ <hsizetype>1</hsizetype> ++ <vsizetype>1</vsizetype> ++ <horstretch>0</horstretch> ++ <verstretch>0</verstretch> ++ </sizepolicy> ++ </property> ++ <property name="minimumSize"> ++ <size> ++ <width>32</width> ++ <height>32</height> ++ </size> ++ </property> ++ <property name="maximumSize"> ++ <size> ++ <width>32</width> ++ <height>32</height> ++ </size> ++ </property> ++ <property name="backgroundMode"> ++ <enum>PaletteBackground</enum> ++ </property> ++ <property name="backgroundOrigin"> ++ <enum>ParentOrigin</enum> ++ </property> ++ <property name="scaledContents"> ++ <bool>true</bool> ++ </property> ++ </widget> ++ </hbox> ++ </widget> ++ </hbox> ++ </widget> ++ <spacer> ++ <property name="name"> ++ <cstring>spacer5_2</cstring> ++ </property> ++ <property name="orientation"> ++ <enum>Horizontal</enum> ++ </property> ++ <property name="sizeType"> ++ <enum>Preferred</enum> ++ </property> ++ <property name="sizeHint"> ++ <size> ++ <width>16</width> ++ <height>20</height> ++ </size> ++ </property> ++ </spacer> ++ </hbox> ++ </widget> ++ <widget class="QLayoutWidget"> ++ <property name="name"> ++ <cstring>m_footer</cstring> ++ </property> ++ <property name="geometry"> ++ <rect> ++ <x>20</x> ++ <y>110</y> ++ <width>407</width> ++ <height>34</height> ++ </rect> ++ </property> ++ <hbox> ++ <property name="name"> ++ <cstring>unnamed</cstring> ++ </property> ++ <property name="margin"> ++ <number>4</number> ++ </property> ++ <property name="spacing"> ++ <number>4</number> ++ </property> ++ <widget class="QLabel"> ++ <property name="name"> ++ <cstring>m_userInfo</cstring> ++ </property> ++ <property name="sizePolicy"> ++ <sizepolicy> ++ <hsizetype>3</hsizetype> ++ <vsizetype>0</vsizetype> ++ <horstretch>0</horstretch> ++ <verstretch>0</verstretch> ++ </sizepolicy> ++ </property> ++ <property name="text"> ++ <string>User&nbsp;<b>user</b>&nbsp;on&nbsp;<b>host</b></string> ++ </property> ++ </widget> ++ <spacer> ++ <property name="name"> ++ <cstring>spacer13_2</cstring> ++ </property> ++ <property name="orientation"> ++ <enum>Horizontal</enum> ++ </property> ++ <property name="sizeType"> ++ <enum>MinimumExpanding</enum> ++ </property> ++ <property name="sizeHint"> ++ <size> ++ <width>10</width> ++ <height>20</height> ++ </size> ++ </property> ++ </spacer> ++ <widget class="QToolButton"> ++ <property name="name"> ++ <cstring>m_branding</cstring> ++ </property> ++ <property name="sizePolicy"> ++ <sizepolicy> ++ <hsizetype>4</hsizetype> ++ <vsizetype>4</vsizetype> ++ <horstretch>0</horstretch> ++ <verstretch>0</verstretch> ++ </sizepolicy> ++ </property> ++ <property name="maximumSize"> ++ <size> ++ <width>90</width> ++ <height>24</height> ++ </size> ++ </property> ++ <property name="text"> ++ <string></string> ++ </property> ++ <property name="iconSet"> ++ <iconset>image0</iconset> ++ </property> ++ <property name="usesBigPixmap"> ++ <bool>true</bool> ++ </property> ++ <property name="autoRaise"> ++ <bool>true</bool> ++ </property> ++ </widget> ++ <spacer> ++ <property name="name"> ++ <cstring>spacer13</cstring> ++ </property> ++ <property name="orientation"> ++ <enum>Horizontal</enum> ++ </property> ++ <property name="sizeType"> ++ <enum>Fixed</enum> ++ </property> ++ <property name="sizeHint"> ++ <size> ++ <width>14</width> ++ <height>20</height> ++ </size> ++ </property> ++ </spacer> ++ </hbox> ++ </widget> ++</widget> ++<customwidgets> ++</customwidgets> ++<images> ++ <image name="image0"> ++ <data format="XPM.GZ" length="2522">789cdd933d6fdb30104077ff0a21de8c82b12d5bb2507448f6021d0b141dc82369d9116d7d50b1ada2ffbdbca3c4444950244032b4b790efce7cd29de8eb59f4fddbd768763d692cb73b8820e7753493ad31971f3fbffc9a5c6d36d17219c5f36871f56972e57e104dd7324be325a2464cd24cc60a5120a6731eaf046241c879b64e113bc44dcc751223da802bc41de16ac092508a753a4754885922440a8892301332a5e79e10f91c169b0cf1963083345b231a423ee0bec78dc71c51c420393578249432e664be2354d2bd17628d0889cc0447bc20cab9d490205601a9df29e142cd3d9e0933b59234ba0321576b49d3d8f69878bc41544b952a6abf218c9590f41a9c70a5c0e33d21e885a2e1b4883ad1a9de2032420ac20f8affde3df5415bdea7f8b8c0fbed507fa59b0bf02119739f9172b46e755fc819dbf55bd07ba15fef0ec7f6b41f728c0dcf84bbc76ebedfbfde0d2042eb8fdd5b801de5b794281e06f716f7ee710f619d5227a1b01b1d0aeedc18e366660ec7b2ac18ab1d1a9745acd1ad3161f28631dbbb716d86c29112c2f86363770ec20a383a89b51a9a06b4b5503a2c10dd771b46d98cdcac180a052528cc13b781b6bd7759506d5b435541ddb6161cba16c0f5a174383872b3729057c19dbfe06ed16ddab642b7324638b77b870add3eaae76e1fb577db17e7fdcc5d586bcd5fddc59bdda7deed7d83db580a81ee93bb906eefd4ee0fa24201ddda53f9d4ad4ce92605fae466713843614ceddd17b83008d1b06618bd2b5e42de3da70b7019dfc1b2eb3af7e140a9ae7342d3d152babb75ee1a76ea7c9478ea5c92bd3bf6c7a870f6677cdc8cdd7d840bf40ef1cc7dfb716efd81eef78c7fd6fdfbf3e40f51236246</data> ++ </image> ++</images> ++<includes> ++ <include location="local" impldecl="in implementation">kmenubase.ui.h</include> ++</includes> ++<functions> ++ <function access="private" specifier="non virtual">init()</function> ++</functions> ++<layoutdefaults spacing="6" margin="11"/> ++<includehints> ++ <includehint>kcombobox.h</includehint> ++</includehints> ++</UI> +--- kicker/ui/kickoff_bar.h (Revision 0) ++++ kicker/ui/kickoff_bar.h (Revision 849791) +@@ -0,0 +1,53 @@ ++/***************************************************************** ++ ++ Copyright (c) 1996-2000 the kicker authors. See file AUTHORS. ++ Copyright (c) 2006 Dirk Mueller <mueller@kde.org> ++ ++ This program is free software; you can redistribute it and/or ++ modify it under the terms of the GNU General Public ++ License as published by the Free Software Foundation; either ++ version 2 of the License, or (at your option) any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; see the file COPYING. If not, write to ++ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ++ Boston, MA 02110-1301, USA. ++ ++******************************************************************/ ++ ++#ifndef __kickoff_bar_h__ ++#define __kickoff_bar_h__ ++ ++#include <qtabbar.h> ++ ++class KickoffTabBar : public QTabBar ++{ ++ Q_OBJECT ++public: ++ KickoffTabBar(QWidget* parent, const char* name); ++ ++ void deactivateTabs(bool b); ++ virtual QSize sizeHint() const; ++ ++protected: ++ virtual void paint(QPainter*, QTab*, bool) const; ++ virtual void paintLabel(QPainter* p, const QRect& br, QTab* t, bool has_focus) const; ++ virtual void layoutTabs(); ++ virtual void dragEnterEvent(QDragEnterEvent*); ++ virtual void dragMoveEvent(QDragMoveEvent*); ++ virtual void mousePressEvent ( QMouseEvent * ); ++ ++signals: ++ void tabClicked(QTab*); ++ ++private: ++ bool m_tabsActivated; ++}; ++ ++ ++#endif +--- kicker/ui/k_mnu_stub.cpp (Revision 0) ++++ kicker/ui/k_mnu_stub.cpp (Revision 849791) +@@ -0,0 +1,141 @@ ++/***************************************************************** ++ ++Copyright (c) 2006 Dirk Mueller <mueller@kde.org> ++ ++Permission is hereby granted, free of charge, to any person obtaining a copy ++of this software and associated documentation files (the "Software"), to deal ++in the Software without restriction, including without limitation the rights ++to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++copies of the Software, and to permit persons to whom the Software is ++furnished to do so, subject to the following conditions: ++ ++The above copyright notice and this permission notice shall be included in ++all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN ++AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ ++******************************************************************/ ++ ++#include "k_mnu_stub.h" ++#include "k_new_mnu.h" ++#include "k_mnu.h" ++ ++void KMenuStub::removeClientMenu(int id) ++{ ++ if(m_type == t_KMenu) ++ return m_w.kmenu->removeClientMenu(id); ++ return m_w.panelkmenu->removeClientMenu(id); ++} ++ ++int KMenuStub::insertClientMenu(KickerClientMenu *p) ++{ ++ if(m_type == t_KMenu) ++ return m_w.kmenu->insertClientMenu(p); ++ return m_w.panelkmenu->insertClientMenu(p); ++} ++ ++void KMenuStub::adjustSize() ++{ ++ if(m_type == t_KMenu) ++ return m_w.kmenu->adjustSize(); ++ return m_w.panelkmenu->adjustSize(); ++} ++ ++void KMenuStub::hide() ++{ ++ if(m_type == t_KMenu) ++ return m_w.kmenu->hide(); ++ return m_w.panelkmenu->hide(); ++} ++ ++void KMenuStub::show() ++{ ++ if(m_type == t_KMenu) ++ return m_w.kmenu->show(); ++ return m_w.panelkmenu->show(); ++} ++ ++void KMenuStub::showMenu() ++{ ++ if(m_type == t_KMenu) ++ return m_w.kmenu->showMenu(); ++ return m_w.panelkmenu->showMenu(); ++} ++ ++#if 0 ++void KMenuStub::resize() ++{ ++ if(m_type == t_KMenu) ++ return m_w.kmenu->resize(); ++ return m_w.panelkmenu->resize(); ++} ++#endif ++ ++void KMenuStub::popup(const QPoint &pos, int indexAtPoint) ++{ ++ return m_type == t_KMenu ? ++ m_w.kmenu->popup(pos, indexAtPoint) ++ : m_w.panelkmenu->popup(pos, indexAtPoint); ++} ++ ++void KMenuStub::selectFirstItem() ++{ ++ if(m_type == t_KMenu) ++ return m_w.kmenu->selectFirstItem(); ++ return m_w.panelkmenu->selectFirstItem(); ++} ++ ++void KMenuStub::resize(int w, int h) ++{ ++ if(m_type == t_KMenu) ++ return m_w.kmenu->resize(w, h); ++ return m_w.panelkmenu->resize(w, h); ++} ++ ++QSize KMenuStub::sizeHint() const ++{ ++ if(m_type == t_KMenu) ++ return m_w.kmenu->sizeHint(); ++ return m_w.panelkmenu->sizeHint(); ++} ++ ++bool KMenuStub::highlightMenuItem( const QString &menuId ) ++{ ++ if(m_type == t_KMenu) ++ return m_w.kmenu->highlightMenuItem(menuId); ++ return m_w.panelkmenu->highlightMenuItem(menuId); ++} ++ ++void KMenuStub::clearRecentMenuItems() ++{ ++ if(m_type == t_KMenu) ++ return m_w.kmenu->clearRecentAppsItems(); ++ return m_w.panelkmenu->clearRecentMenuItems(); ++} ++ ++void KMenuStub::initialize() ++{ ++ if(m_type == t_KMenu) ++ return m_w.kmenu->initialize(); ++ return m_w.panelkmenu->initialize(); ++} ++ ++bool KMenuStub::isVisible() const ++{ ++ if(m_type == t_KMenu) ++ return m_w.kmenu->isVisible(); ++ return m_w.panelkmenu->isVisible(); ++} ++ ++QWidget* KMenuStub::widget() ++{ ++ if(m_type == t_KMenu) ++ return m_w.kmenu; ++ return m_w.panelkmenu; ++} ++ +--- kicker/ui/kmenubase.ui.h (Revision 0) ++++ kicker/ui/kmenubase.ui.h (Revision 849791) +@@ -0,0 +1,9 @@ ++#include <X11/Xlib.h> ++ ++void KMenuBase::init() ++{ ++ XSetWindowAttributes attrs; ++ attrs.override_redirect = True; ++ XChangeWindowAttributes( qt_xdisplay(), winId(), CWOverrideRedirect, &attrs ); ++ setWFlags( Qt::WType_Popup ); ++} +--- kicker/ui/mykickoffsearchinterface.h (Revision 0) ++++ kicker/ui/mykickoffsearchinterface.h (Revision 849791) +@@ -0,0 +1,47 @@ ++/*************************************************************************** ++ * Copyright (C) 2006 by Stephan Binner <binner@kde.org> * ++ * * ++ * This program is free software; you can redistribute it and/or modify * ++ * it under the terms of the GNU General Public License as published by * ++ * the Free Software Foundation; either version 2 of the License, or * ++ * (at your option) any later version. * ++ * * ++ * This program is distributed in the hope that it will be useful, * ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of * ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * ++ * GNU General Public License for more details. * ++ * * ++ * You should have received a copy of the GNU General Public License * ++ * along with this program; if not, write to the * ++ * Free Software Foundation, Inc., * ++ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * ++ ***************************************************************************/ ++ ++#ifndef MYKICKOFFSEARCHINTERFACE_H ++#define MYKICKOFFSEARCHINTERFACE_H ++ ++#include "../interfaces/kickoffsearchinterface.h" ++ ++class KMenu; ++ ++using namespace KickoffSearch; ++ ++class MyKickoffSearchInterface :public KickoffSearchInterface ++{ ++ Q_OBJECT ++ ++public: ++ MyKickoffSearchInterface( KMenu*, QObject* parent, const char* name = 0 ); ++ ++ bool anotherHitMenuItemAllowed(int cat); ++ void addHitMenuItem(HitMenuItem* item); ++ void searchOver(); ++ void initCategoryTitlesUpdate(); ++ void updateCategoryTitles(); ++ ++private: ++ KMenu* _menu; ++ ++}; ++ ++#endif /* MYKICKOFFSEARCHINTERFACE_H */ +--- kicker/ui/itemview.h (Revision 0) ++++ kicker/ui/itemview.h (Revision 849791) +@@ -0,0 +1,260 @@ ++/***************************************************************** ++ ++Copyright (c) 1996-2000 the kicker authors. See file AUTHORS. ++ ++Permission is hereby granted, free of charge, to any person obtaining a copy ++of this software and associated documentation files (the "Software"), to deal ++in the Software without restriction, including without limitation the rights ++to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++copies of the Software, and to permit persons to whom the Software is ++furnished to do so, subject to the following conditions: ++ ++The above copyright notice and this permission notice shall be included in ++all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN ++AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ ++******************************************************************/ ++ ++#ifndef __itemview_h__ ++#define __itemview_h__ ++ ++#include <dcopobject.h> ++#include <qintdict.h> ++#include <qpixmap.h> ++#include <qframe.h> ++#include <qtoolbutton.h> ++#include <klistview.h> ++#include <qdragobject.h> ++ ++#include "kmenubase.h" ++#include "kmenuitembase.h" ++#include "service_mnu.h" ++ ++class KickerClientMenu; ++class KBookmarkMenu; ++class KActionCollection; ++class KBookmarkOwner; ++class Panel; ++class QWidgetStack; ++class KHistoryCombo; ++class QScrollView; ++class PopupMenuTitle; ++class QWidget; ++class QVBoxLayout; ++class QTimer; ++class KPixmap; ++ ++class KMenuItem : public QListViewItem ++{ ++public: ++ KMenuItem(int nId, QListView* parent) : QListViewItem(parent), m_id(nId) { init(); } ++ KMenuItem(int nId, QListViewItem* parent) : QListViewItem(parent), m_id(nId) { init(); } ++ ~KMenuItem(); ++ ++ void setIcon(const QString& icon, int size); ++ QString icon() const { return m_icon; } ++ void setTitle( const QString& text ); ++ QString title() const { return m_title; } ++ void setToolTip( const QString& text ); ++ QString toolTip() const { return m_tooltip; } ++ void setDescription(const QString& text); ++ QString description() const { return m_description; } ++ void setService(KService::Ptr& s) { m_s = s; } ++ KService::Ptr service() { return m_s; } ++ void setPath(const QString& u) { m_path = u; } ++ QString path() const { return m_path; } ++ void setMenuPath(const QString& u) { m_menuPath = u; } ++ QString menuPath() const { return m_menuPath; } ++ int id() const { return m_id; } ++ void setHasChildren(bool flag); ++ bool hasChildren() const { return m_has_children; } ++ void makeGradient(KPixmap &off, const QColor& c); ++ ++protected: ++ virtual void paintCell(QPainter* p, const QColorGroup & cg, int column, int width, int align); ++ virtual void paintCellInter(QPainter* p, const QColorGroup & cg, int column, int width, int align); ++ virtual void setup(); ++ ++private: ++ void init(); ++ ++ int m_id; ++ KService::Ptr m_s; ++ QString m_title; ++ QString m_description; ++ QString m_path; ++ QString m_icon; ++ QString m_tooltip; ++ QString m_menuPath; ++ float title_font_size; ++ float description_font_size; ++ bool m_has_children; ++ int m_old_width; ++ QPixmap right_triangle; ++}; ++ ++class KMenuItemSeparator : public KMenuItem ++{ ++public: ++ KMenuItemSeparator(int nId, QListView* parent); ++ virtual void setup(); ++ ++ virtual void paintCell(QPainter* p, const QColorGroup & cg, int column, int width, int align); ++ void setLink(const QString &text, const QString &link = QString::null ); ++ ++ QString linkUrl() const { return m_link_url; } ++ ++ /// returns true if the cursor has to change ++ bool hitsLink(const QPoint &pos); ++ ++protected: ++ void preparePixmap(int width); ++ QPixmap pixmap; ++ int left_margin; ++ ++private: ++ QListView* lv; ++ int cached_width; ++ QString m_link_text, m_link_url; ++ QRect m_link_rect; ++ ++}; ++ ++class KMenuItemHeader : public KMenuItemSeparator ++{ ++public: ++ KMenuItemHeader( int nId, const QString &relpath, QListView* parent); ++ virtual void setup(); ++ ++ virtual void paintCell(QPainter* p, const QColorGroup & cg, int column, int width, int align); ++ ++private: ++ QListView* lv; ++ QStringList paths; ++ QStringList texts; ++ QStringList icons; ++ QPixmap left_triangle; ++}; ++ ++class KMenuSpacer : public KMenuItem ++{ ++public: ++ KMenuSpacer(int nId, QListView* parent); ++ virtual void paintCell(QPainter* p, const QColorGroup & cg, int column, int width, int align); ++ virtual void setup(); ++ ++ void setHeight(int); ++}; ++ ++class ItemView : public KListView ++{ ++ friend class KMenuItem; ++ ++ Q_OBJECT ++public: ++ ItemView(QWidget* parent, const char* name = 0); ++ ++ KMenuItem* insertItem( const QString& icon, const QString& text, const QString& description, int nId, int nIndex, KMenuItem* parentItem = 0 ); ++ KMenuItem* insertItem( const QString& icon, const QString& text, const QString& description, const QString& path, int nId, int nIndex, KMenuItem* parentItem = 0 ); ++ int insertItem( PopupMenuTitle*, int, int); ++ int setItemEnabled(int id, bool enabled); ++ KMenuItemSeparator *insertSeparator(int id, const QString& text, int nIndex); ++ KMenuItemHeader *insertHeader(int id, const QString &relpath); ++ KMenuItem* insertMenuItem(KService::Ptr & s, int nId, int nIndex = -1, KMenuItem* parentItem = 0, ++ const QString &aliasname = QString::null, const QString &label = QString::null, ++ const QString &categoryIcon = QString::null); ++ KMenuItem* insertRecentlyItem(const QString& s, int nId, int nIndex = -1); ++ KMenuItem* insertDocumentItem(const QString& s, int nId, int nIndex = -1 , const QStringList* suppressGenericNames = 0, ++ const QString& aliasname = QString::null); ++ KMenuItem* insertSubItem(const QString& icon, const QString& caption, const QString& description, const QString& path, KMenuItem* parentItem); ++ KMenuItem* findItem(int nId); ++ ++ void setIconSize(int size) { m_iconSize = size; } ++ void setMouseMoveSelects(bool select) { m_mouseMoveSelects = select; } ++ void clear(); ++ int goodHeight(); ++ QString path; ++ void setBackPath( const QString &str ) { m_back_url = str; } ++ QString backPath() const { return m_back_url; } ++ ++public slots: ++ void slotItemClicked(QListViewItem*); ++ void slotMoveContent(); ++ ++signals: ++ void startService(KService::Ptr kservice); ++ void startURL(const QString& u); ++ ++protected: ++ void contentsMouseMoveEvent(QMouseEvent *e); ++ void contentsMousePressEvent ( QMouseEvent * e ); ++ void contentsWheelEvent(QWheelEvent *e); ++ void leaveEvent(QEvent *e); ++ virtual void resizeEvent ( QResizeEvent * e ); ++ virtual void viewportPaintEvent ( QPaintEvent * pe ); ++ virtual QDragObject* dragObject (); ++ virtual bool acceptDrag (QDropEvent* event) const; ++ virtual bool focusNextPrevChild(bool next); ++ ++private slots: ++ void slotItemClicked(int button, QListViewItem * item, const QPoint & pos, int c ); ++ ++private: ++ KMenuItem* itemAtIndex(int nIndex); ++ void moveItemToIndex(KMenuItem*, int); ++ ++ QWidget* m_itemBox; ++ QVBoxLayout* m_itemLayout; ++ KMenuItem *m_lastOne; ++ KMenuSpacer *m_spacer; ++ ++ QString m_back_url; ++ ++ bool m_mouseMoveSelects; ++ int m_iconSize; ++ int m_old_contentY; ++}; ++ ++class FavoritesItemView : public ItemView ++{ ++public: ++ FavoritesItemView(QWidget* parent, const char* name = 0); ++ ++protected: ++ virtual bool acceptDrag (QDropEvent* event) const; ++}; ++ ++class KMenuItemInfo ++{ ++public: ++ int m_id; ++ KService::Ptr m_s; ++ QString m_title; ++ QString m_description; ++ QString m_path; ++ QString m_icon; ++}; ++ ++class KMenuItemDrag : public QDragObject ++{ ++ public: ++ KMenuItemDrag(KMenuItem& item, QWidget *dragSource); ++ ~KMenuItemDrag(); ++ ++ virtual const char * format(int i = 0) const; ++ virtual QByteArray encodedData(const char *) const; ++ ++ static bool canDecode(const QMimeSource * e); ++ static bool decode(const QMimeSource* e, KMenuItemInfo& item); ++ ++ private: ++ QByteArray a; ++}; ++ ++#endif +--- kicker/ui/default-favs (Revision 0) ++++ kicker/ui/default-favs (Revision 849791) +@@ -0,0 +1,9 @@ ++MozillaFirefox.desktop ++kde-Kontact.desktop ++writer.desktop ++kde-amarok.desktop ++kde-digikam.desktop ++kde-Home.desktop ++kde-KControl.desktop ++kde-Help.desktop ++kde-konsole.desktop +--- kicker/ui/query.h (Revision 0) ++++ kicker/ui/query.h (Revision 849791) +@@ -0,0 +1,55 @@ ++/***************************************************************** ++ ++ Copyright (c) 2006 Stephan Binner <binner@kde.org> ++ ++ This program is free software; you can redistribute it and/or ++ modify it under the terms of the GNU General Public ++ License as published by the Free Software Foundation; either ++ version 2 of the License, or (at your option) any later version. ++ ++ This program is distributed in the hope that it will be useful, ++ but WITHOUT ANY WARRANTY; without even the implied warranty of ++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU ++ General Public License for more details. ++ ++ You should have received a copy of the GNU General Public License ++ along with this program; see the file COPYING. If not, write to ++ the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, ++ Boston, MA 02110-1301, USA. ++ ++******************************************************************/ ++ ++#ifndef QUERY_H ++#define QUERY_H ++ ++#include <qstringlist.h> ++#include <qptrlist.h> ++ ++class Alternative ++{ ++public: ++ QStringList includes; ++ QStringList excludes; ++}; ++ ++class Query ++{ ++ public: ++ Query(); ++ void clear(); ++ void set(const QString &); ++ QString get() const; ++ bool matches(const QString &); ++ ++ private: ++ QString query_term; ++ QPtrList<Alternative> alternatives; ++ ++ void add_term(); ++ QString current_part; ++ Alternative *current_alternative; ++ bool within_quotes; ++ bool exclude_part; ++}; ++ ++#endif +--- kicker/ui/k_mnu_stub.h (Revision 0) ++++ kicker/ui/k_mnu_stub.h (Revision 849791) +@@ -0,0 +1,72 @@ ++/***************************************************************** ++ ++Copyright (c) 2006 Dirk Mueller <mueller@kde.org> ++ ++Permission is hereby granted, free of charge, to any person obtaining a copy ++of this software and associated documentation files (the "Software"), to deal ++in the Software without restriction, including without limitation the rights ++to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++copies of the Software, and to permit persons to whom the Software is ++furnished to do so, subject to the following conditions: ++ ++The above copyright notice and this permission notice shall be included in ++all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN ++AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ ++******************************************************************/ ++ ++#ifndef __k_mnu_stub_h__ ++#define __k_mnu_stub_h__ ++ ++#include <qstring.h> ++#include <qpoint.h> ++ ++class KickerClientMenu; ++class KMenu; ++class PanelKMenu; ++ ++ ++ ++ ++class KMenuStub ++{ ++public: ++ KMenuStub(KMenu* _kmenu) ++ : m_type(t_KMenu) { m_w.kmenu = _kmenu; } ++ KMenuStub(PanelKMenu* _panelkmenu) ++ : m_type(t_PanelKMenu) { m_w.panelkmenu = _panelkmenu; } ++ ~KMenuStub() {} ++ ++ void removeClientMenu(int id); ++ int insertClientMenu(KickerClientMenu *p); ++ void adjustSize(); ++ void hide(); ++ void show(); ++ void showMenu(); ++ void resize(); ++ void popup(const QPoint &pos, int indexAtPoint = -1); ++ void selectFirstItem(); ++ void resize(int, int); ++ QSize sizeHint() const; ++ bool highlightMenuItem( const QString &menuId ); ++ void clearRecentMenuItems(); ++ void initialize(); ++ ++ QWidget* widget(); ++ ++ bool isVisible() const; ++private: ++ enum {t_PanelKMenu, t_KMenu} m_type; ++ union { ++ KMenu* kmenu; ++ PanelKMenu* panelkmenu; ++ } m_w; ++}; ++ ++#endif +--- kicker/ui/Makefile.am (Revision 849788) ++++ kicker/ui/Makefile.am (Revision 849791) +@@ -1,38 +1,46 @@ + INCLUDES = -I$(srcdir)/../core -I../core -I$(srcdir)/../buttons \ + -I../../libkicker -I$(srcdir)/../../libkicker \ +- -I$(top_srcdir)/libkonq -I$(top_srcdir)/kdmlib $(all_includes) ++ -I$(top_srcdir)/libkonq -I$(top_srcdir)/kdmlib $(DBUS_INCS) $(all_includes) + + noinst_LTLIBRARIES = libkicker_ui.la + ++libkicker_ui_la_COMPILE_FIRST = kmenubase.h ++ + libkicker_ui_la_SOURCES = addbutton_mnu.cpp appletitem.ui appletview.ui addapplet.cpp \ + addapplet_mnu.cpp appletop_mnu.cpp \ + browser_mnu.cpp client_mnu.cpp dirdrop_mnu.cpp \ +- nonKDEButtonSettings.ui exe_dlg.cpp k_mnu.cpp k_mnu.skel\ +- quickbrowser_mnu.cpp service_mnu.cpp \ +- addextension_mnu.cpp extensionop_mnu.cpp \ +- recentapps.cpp browser_dlg.cpp \ ++ nonKDEButtonSettings.ui exe_dlg.cpp k_new_mnu.cpp k_mnu.cpp k_mnu.skel\ ++ quickbrowser_mnu.cpp service_mnu.cpp kmenubase.ui kmenuitembase.ui \ ++ addextension_mnu.cpp extensionop_mnu.cpp k_mnu_stub.cpp \ ++ recentapps.cpp browser_dlg.cpp itemview.cpp kickoff_bar.cpp \ + removeapplet_mnu.cpp removeextension_mnu.cpp removecontainer_mnu.cpp \ + removebutton_mnu.cpp popupmenutitle.cpp hidebutton.cpp \ +- addappletvisualfeedback.cpp ++ addappletvisualfeedback.cpp flipscrollview.cpp \ ++ media_watcher.cpp media_watcher.skel mykickoffsearchinterface.cpp query.cpp + +-libkicker_ui_la_LIBADD = $(top_builddir)/libkonq/libkonq.la $(top_builddir)/kdmlib/libdmctl.la ++libkicker_ui_la_LIBADD = $(top_builddir)/libkonq/libkonq.la $(top_builddir)/kdmlib/libdmctl.la \ ++ $(LIB_KABC) ../interfaces/libkickoffsearch_interfaces.la -llazy + + libkicker_ui_la_METASOURCES = AUTO + + noinst_HEADERS = addapplet.h appletwidget.h addbutton_mnu.h addapplet_mnu.h appletop_mnu.h \ +- browser_mnu.h client_mnu.h dirdrop_mnu.h exe_dlg.h k_mnu.h \ ++ browser_mnu.h client_mnu.h dirdrop_mnu.h exe_dlg.h k_new_mnu.h k_mnu.h \ + quickbrowser_mnu.h service_mnu.h \ + addextension_mnu.h extensionop_mnu.h \ +- recentapps.h browser_dlg.h \ ++ recentapps.h browser_dlg.h itemview.h query.h \ + removeapplet_mnu.h removeextension_mnu.h removecontainer_mnu.h \ + removebutton_mnu.h popupmenutitle.h hidebutton.h addappletvisualfeedback.h + ++kicker_ui_data_DATA = default-favs ++kicker_ui_datadir = $(kde_datadir)/kicker ++ + removecontainer_mnu.lo: ../../libkicker/kickerSettings.h + removeextension_mnu.lo: ../../libkicker/kickerSettings.h + addextension_mnu.lo: ../core/extensionSettings.h + appletop_mnu.lo: ../../libkicker/kickerSettings.h + extensionop_mnu.lo: ../../libkicker/kickerSettings.h + k_mnu.lo: ../../libkicker/kickerSettings.h ++k_new_mnu.lo: ../../libkicker/kickerSettings.h + removecontainer_mnu.lo: ../core/extensionSettings.h + removeextension_mnu.lo: ../core/extensionSettings.h + service_mnu.lo: ../../libkicker/kickerSettings.h +--- kicker/ui/mykickoffsearchinterface.cpp (Revision 0) ++++ kicker/ui/mykickoffsearchinterface.cpp (Revision 849791) +@@ -0,0 +1,54 @@ ++/*************************************************************************** ++ * Copyright (C) 2006 by Stephan Binner <binner@kde.org> * ++ * * ++ * This program is free software; you can redistribute it and/or modify * ++ * it under the terms of the GNU General Public License as published by * ++ * the Free Software Foundation; either version 2 of the License, or * ++ * (at your option) any later version. * ++ * * ++ * This program is distributed in the hope that it will be useful, * ++ * but WITHOUT ANY WARRANTY; without even the implied warranty of * ++ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * ++ * GNU General Public License for more details. * ++ * * ++ * You should have received a copy of the GNU General Public License * ++ * along with this program; if not, write to the * ++ * Free Software Foundation, Inc., * ++ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. * ++ ***************************************************************************/ ++ ++#include "mykickoffsearchinterface.h" ++#include "../ui/k_new_mnu.h" ++ ++MyKickoffSearchInterface::MyKickoffSearchInterface( KMenu* menu, QObject* parent, const char* name ) ++ : KickoffSearchInterface( parent, name ), _menu( menu ) ++{ ++} ++ ++bool MyKickoffSearchInterface::anotherHitMenuItemAllowed(int cat) ++{ ++ return _menu->anotherHitMenuItemAllowed(cat); ++} ++ ++void MyKickoffSearchInterface::addHitMenuItem(HitMenuItem* item) ++{ ++ _menu->addHitMenuItem(item); ++} ++ ++ ++void MyKickoffSearchInterface::searchOver() ++{ ++ _menu->searchOver(); ++} ++ ++void MyKickoffSearchInterface::initCategoryTitlesUpdate() ++{ ++ _menu->initCategoryTitlesUpdate(); ++} ++ ++void MyKickoffSearchInterface::updateCategoryTitles() ++{ ++ _menu->updateCategoryTitles(); ++} ++ ++#include "mykickoffsearchinterface.moc" +--- kicker/ui/itemview.cpp (Revision 0) ++++ kicker/ui/itemview.cpp (Revision 849791) +@@ -0,0 +1,1257 @@ ++/***************************************************************** ++ ++Copyright (c) 1996-2000 the kicker authors. See file AUTHORS. ++ ++Permission is hereby granted, free of charge, to any person obtaining a copy ++of this software and associated documentation files (the "Software"), to deal ++in the Software without restriction, including without limitation the rights ++to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++copies of the Software, and to permit persons to whom the Software is ++furnished to do so, subject to the following conditions: ++ ++The above copyright notice and this permission notice shall be included in ++all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN ++AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ ++******************************************************************/ ++ ++#include <stdlib.h> ++#include <sys/types.h> ++#include <unistd.h> ++#include <dmctl.h> ++ ++#include <qapplication.h> ++#include <qimage.h> ++#include <qpainter.h> ++#include <qstyle.h> ++#include <qwidgetstack.h> ++#include <qlayout.h> ++#include <qlabel.h> ++#include <qvbox.h> ++#include <qheader.h> ++#include <qdrawutil.h> ++#include <qdragobject.h> ++#include <qcursor.h> ++#include <qpaintdevicemetrics.h> ++#include <qbuffer.h> ++#include <qtooltip.h> ++#include <qstylesheet.h> ++#include <qiconview.h> ++ ++#include <dcopclient.h> ++#include <kapplication.h> ++#include <kaboutkde.h> ++#include <kpixmapeffect.h> ++#include <kaction.h> ++#include <kbookmarkmenu.h> ++#include <kconfig.h> ++#include <kdebug.h> ++#include <kglobal.h> ++#include <kglobalsettings.h> ++#include <kiconloader.h> ++#include <klocale.h> ++#include <kmessagebox.h> ++#include <kstandarddirs.h> ++#include <kcombobox.h> ++#include <kwin.h> ++#include <kdebug.h> ++#include <kmimetype.h> ++#include <kmultipledrag.h> ++ ++#include "client_mnu.h" ++#include "container_base.h" ++#include "global.h" ++#include "kbutton.h" ++#include "kicker.h" ++#include "kickerSettings.h" ++#include "konqbookmarkmanager.h" ++#include "menuinfo.h" ++#include "menumanager.h" ++#include "popupmenutitle.h" ++#include "quickbrowser_mnu.h" ++#include "recentapps.h" ++ ++#include "k_mnu.h" ++#include "k_new_mnu.h" ++#include "itemview.h" ++ ++// -------------------------------------------------------------------------- ++ ++KMenuItem::~KMenuItem() ++{ ++ ItemView *listview = dynamic_cast<ItemView*>( listView() ); ++ if ( listview && listview->m_lastOne == this) { ++ listview->m_lastOne = 0; ++ listview->m_old_contentY = -1; ++ } ++} ++ ++static double pointSize( double pixelSize, QPaintDevice *w ) ++{ ++ return pixelSize * 72. / QPaintDevice::x11AppDpiY( w->x11Screen () ); ++} ++ ++static int pixelSize( double pixelSize, QPaintDevice *w ) ++{ ++ return qRound( pixelSize * QPaintDevice::x11AppDpiY( w->x11Screen () ) / 72. ); ++} ++ ++void KMenuItem::init() ++{ ++ setMultiLinesEnabled(true); ++ m_s = 0; ++ m_path = QString::null; ++ m_icon = QString::null; ++ m_menuPath = QString::null; ++ setDragEnabled(true); ++ m_has_children = false; ++ m_old_width = -1; ++ if ( QApplication::reverseLayout() ) ++ right_triangle.load( locate( "data", "kicker/pics/left_triangle.png" ) ); ++ else ++ right_triangle.load( locate( "data", "kicker/pics/right_triangle.png" ) ); ++} ++ ++void KMenuItem::setTitle(const QString& txt) ++{ ++ m_title = txt; ++ setText( 0, txt ); ++ setup(); ++} ++ ++void KMenuItem::setToolTip(const QString& txt) ++{ ++ m_tooltip = txt; ++} ++ ++void KMenuItem::setDescription(const QString& txt) ++{ ++ m_description = txt; ++ setup(); ++} ++ ++void KMenuItem::setIcon(const QString& icon, int size) ++{ ++ m_icon = icon; ++ QListViewItem::setPixmap(0, KGlobal::iconLoader()->loadIcon(icon, KIcon::Panel, size )); ++} ++ ++void KMenuItem::setHasChildren( bool flag ) ++{ ++ m_has_children = flag; ++ repaint(); ++} ++ ++void KMenuItem::setup() ++{ ++ // if someone configured a larger generalFont than 10pt, he might have a _real_ problem with 7pt ++ // the 7pt could be read out of konquerorrc I guess ++ float min_font_size = 7. * QMAX(1., KGlobalSettings::generalFont().pointSizeFloat() / 10.); ++ ++ const int expected_height = 38; ++ description_font_size = QMAX( pointSize( expected_height * .3, listView() ) + KickerSettings::kickoffFontPointSizeOffset(), min_font_size ) ; ++ title_font_size = QMAX( pointSize( expected_height * .25, listView() ) + KickerSettings::kickoffFontPointSizeOffset(), min_font_size + 1 ); ++ ++ //kdDebug() << description_font_size << " " << title_font_size << " " << pointSize( expected_height * .25, listView() ) << endl; ++ QListViewItem::setup(); ++ setHeight( (int)QMAX( expected_height, pixelSize( title_font_size + description_font_size * 2.3, listView()))); ++} ++ ++void KMenuItem::paintCell(QPainter* p, const QColorGroup & cg, int column, int width, int align) ++{ ++ ItemView *listview = static_cast<ItemView*>( listView() ); ++ int bottom = listView()->itemRect( this ).bottom(); ++ int diff = bottom - listView()->viewport()->height(); ++ ++ KPixmap pm; ++ pm.resize( width, height() ); ++ QPainter pp( &pm ); ++ paintCellInter( &pp, cg, column, width, align ); ++ pp.end(); ++ ++ if ( diff > 0 && diff <= height() ) // cut off ++ { ++ pm.resize( width, height() - diff ); ++ KPixmapEffect::blend( pm, float( diff ) / height(), ++ cg.color( QColorGroup::Background ), ++ KPixmapEffect::VerticalGradient ); ++ p->drawPixmap( 0, 0, pm ); ++ if ( listview->m_lastOne != this ) ++ { ++ listview->m_lastOne = this; ++ listview->m_old_contentY = -1; ++ } ++ } ++ else ++ { ++ p->drawPixmap( 0, 0, pm ); ++ if ( this == listview->m_lastOne ) { ++ if ( bottom < 0 ) ++ listview->m_lastOne = static_cast<KMenuItem*>( itemAbove() ); ++ else ++ listview->m_lastOne = static_cast<KMenuItem*>( itemBelow() ); ++ listview->m_old_contentY = -1; ++ repaint(); ++ } ++ } ++} ++ ++void KMenuItem::makeGradient( KPixmap &off, const QColor &c ) ++{ ++ KPixmap blend; ++ blend.resize( off.width() / 3, off.height() ); ++ bitBlt( &blend, 0, 0, &off, off.width() - blend.width(), 0, blend.width(), blend.height() ); ++ KPixmapEffect::blend( blend, 0.2, c, KPixmapEffect::HorizontalGradient ); ++ QPainter p( &off ); ++ p.drawPixmap( off.width() - blend.width(), 0, blend ); ++ p.end(); ++} ++ ++void KMenuItem::paintCellInter(QPainter* p, const QColorGroup & cg, int column, int width, int align) ++{ ++ const bool reverseLayout = QApplication::reverseLayout(); ++ ++ const BackgroundMode bgmode = listView()->viewport()->backgroundMode(); ++ const QColorGroup::ColorRole crole = QPalette::backgroundRoleFromMode( bgmode ); ++ QColor backg = cg.color( crole ); ++ ++ if ( isSelected() ) ++ backg = cg.color( QColorGroup::Highlight ); ++ p->fillRect( 0, 0, width, height(), backg ); ++ ++ QFontMetrics fm( p->fontMetrics() ); ++ ++ int pixsize = 32; ++ if ( height() < 36 ) ++ pixsize = 16; ++ const int left_margin = 30; ++ const int margin = 3; ++ ++// p->drawText( 2, 2, left_margin - 2, height(), align, QString::number( childCount () ) ); ++ ++ const QPixmap * pix = pixmap( column ); ++ ++ if ( pix ) ++ { ++ QPixmap pix32 = *pix; ++ ++ if ( pix->width() > pixsize ) ++ { ++ QImage i = pix->convertToImage().smoothScale( pixsize, pixsize ); ++ pix32.convertFromImage( i ); ++ } ++ if ( reverseLayout ) ++ p->drawPixmap( width - ( (pixsize - pix32.width()) / 2 + left_margin ) - pix32.width(), ++ ( height() - pix32.height() ) / 2, pix32 ); ++ else ++ p->drawPixmap( (pixsize - pix32.width()) / 2 + left_margin, ++ ( height() - pix32.height() ) / 2, pix32 ); ++ } ++ ++ if ( m_title.isEmpty() ) ++ return; ++ ++ int r = left_margin + pixsize + margin * 2; ++ ++ QFont f1 = p->font(); ++ f1.setPointSizeFloat( title_font_size ); ++ f1.setWeight( QFont::Normal ); // QFont::DemiBold == 63 ++ ++ QFont f2 = p->font(); ++ f2.setPointSizeFloat( description_font_size ); ++ f2.setWeight( QFont::Light ); ++ ++ int f1h = QFontMetrics( f1 ).height(); ++ int f2h = QFontMetrics( f2 ).height(); ++ ++ const int text_margin = 2; ++ int spacing = ( height() - f1h - f2h - text_margin ) / 2; ++ if ( m_description.isEmpty() ) ++ spacing = ( height() - f1h ) / 2; ++ ++ int right_triangle_size = pixelSize( 7, listView() ); ++ ++ int right_margin = listView()->verticalScrollBar()->width(); ++ if ( m_has_children ) ++ right_margin += right_triangle_size * 2; ++ ++ KPixmap off; ++ QPainter pp; ++ ++ off.resize( width-text_margin-r-right_margin, height() ); ++ pp.begin( &off ); ++ pp.fillRect( 0, 0, off.width(), off.height(), backg ); ++ ++ if (isSelected()) ++ pp.setPen( cg.color( QColorGroup::HighlightedText ) ); ++ else ++ pp.setPen( cg.color( QColorGroup::Text ) ); ++ ++ pp.setFont( f1 ); ++ pp.drawText( 0, 0, off.width(), off.height(), align, m_title ); ++ pp.end(); ++ if ( QFontMetrics( f1 ).width( m_title ) > off.width() ) ++ { ++ makeGradient( off, backg ); ++ if ( !m_description.isEmpty() ) ++ setToolTip( m_title + "<br><br>" + m_description ); ++ else ++ setToolTip( m_title ); ++ } ++ if ( reverseLayout ) ++ p->drawPixmap( width - off.width() - r, spacing, off ); ++ else ++ p->drawPixmap( r, spacing, off ); ++ ++ if ( !m_description.isEmpty() ) ++ { ++ pp.begin( &off ); ++ pp.fillRect( 0, 0, off.width(), off.height(), backg ); ++ ++ QColor myColor = cg.color( QColorGroup::Text ).light( 200 ); ++ if ( qGray( myColor.rgb() ) == 0 ) ++ myColor = QColor( 100, 100, 110 ); ++ pp.setPen( myColor ); ++ pp.setPen( isSelected() ? cg.color( QColorGroup::Mid ) : myColor ); ++ pp.setFont( f2 ); ++ pp.drawText( 0, 0, off.width(), off.height(), align, m_description ); ++ pp.end(); ++ if ( QFontMetrics( f2 ).width( m_description ) > off.width() ) ++ { ++ makeGradient( off, backg ); ++ setToolTip( m_title + "<br><br>" + m_description ); ++ } ++ if ( reverseLayout ) ++ p->drawPixmap( width - off.width() - r, spacing + text_margin + f1h, off ); ++ else ++ p->drawPixmap( r, spacing + text_margin + f1h, off ); ++ } ++ ++ if ( m_has_children ) ++ { ++ QImage i = right_triangle.convertToImage().smoothScale( right_triangle_size, ++ right_triangle_size ); ++ QPixmap tri; ++ tri.convertFromImage( i ); ++ ++ if ( reverseLayout ) ++ p->drawPixmap( right_margin - tri.width(), ( height() - f1h ) / 2, tri ); ++ else ++ p->drawPixmap( listView()->width() - right_margin, ( height() - f1h ) / 2, tri ); ++ } ++ ++ if ( m_old_width != width ) ++ { ++ // the listview caches paint events ++ m_old_width = width; ++ repaint(); ++ } ++} ++ ++// -------------------------------------------------------------------------- ++ ++KMenuItemSeparator::KMenuItemSeparator(int nId, QListView* parent) ++ : KMenuItem(nId, parent), lv(parent), cached_width( 0 ) ++{ ++ setEnabled(false); ++ left_margin = 15; ++} ++ ++void KMenuItemSeparator::setup() ++{ ++ KMenuItem::setup(); ++ ++ QFont f = QFont(); ++ QFontMetrics fm(f); ++ f.setPointSize( 8 + KickerSettings::kickoffFontPointSizeOffset() ); ++ if ( itemAbove() && !text( 0 ).isEmpty() ) ++ setHeight( (int)QMAX( 34., fm.height() * 1.4) ); ++ else ++ setHeight( (int)QMAX( 26., fm.height() * 1.4 ) ); ++} ++ ++void KMenuItemSeparator::setLink( const QString &text, const QString &url ) ++{ ++ m_link_text = text; ++ m_link_url = url; ++ m_link_rect = QRect(); ++} ++ ++bool KMenuItemSeparator::hitsLink( const QPoint &pos ) ++{ ++ return m_link_rect.contains( pos ); ++} ++ ++void KMenuItemSeparator::preparePixmap( int width ) ++{ ++ if ( cached_width != width ) ++ { ++ pixmap.load( locate("data", "kicker/pics/menu_separator.png" ) ); ++ QImage i = pixmap.convertToImage().smoothScale( width - 15 - left_margin, pixmap.height() ); ++ pixmap.convertFromImage( i ); ++ cached_width = width; ++ } ++} ++ ++void KMenuItemSeparator::paintCell(QPainter* p, const QColorGroup & cg, int column, int width, int align) ++{ ++ preparePixmap(width); ++ ++ const int h = height(); ++ ++ if (text(0).isEmpty()) { ++ KMenuItem::paintCell(p, cg, column, width, align); ++ p->drawPixmap( 15 , h/2, pixmap ); ++ } ++ else { ++ const BackgroundMode bgmode = lv->viewport()->backgroundMode(); ++ const QColorGroup::ColorRole crole = QPalette::backgroundRoleFromMode( bgmode ); ++ p->fillRect( 0, 0, width, h, cg.brush( crole ) ); ++ ++ int margin = 0; ++ if ( itemAbove() ) { ++ p->drawPixmap( 15 , h/4, pixmap ); ++ margin = h / 4; ++ } ++ QFont f = listView()->font(); ++ f.setWeight( QFont::Normal ); ++ f.setPointSize( 8 + KickerSettings::kickoffFontPointSizeOffset() ); ++ p->setFont( f ); ++ QColor myColor = cg.color( QColorGroup::Text ).light( 200 ); ++ if ( qGray( myColor.rgb() ) == 0 ) ++ myColor = QColor( 100, 100, 110 ); ++ p->setPen( myColor ); ++ int twidth = p->fontMetrics().width(text(0)); ++ int lwidth = 0; ++ int swidth = 0; ++ int fwidth = 0; ++ ++ if ( !m_link_text.isEmpty() ) ++ { ++ swidth = p->fontMetrics().width( " (" ); ++ lwidth = p->fontMetrics().width(m_link_text ); ++ fwidth = p->fontMetrics().width( ")" ); ++ } ++ int pos = int(lv->width() * 0.9 - twidth - swidth - lwidth - fwidth); ++ p->drawText( pos, margin + 5, ++ width, h - ( margin +5 ), AlignTop, text(0) ); ++ if ( !m_link_text.isEmpty() ) ++ { ++ pos += twidth; ++ p->drawText( pos, margin + 5, ++ width, h - ( margin +5 ), AlignTop, " (" ); ++ pos += swidth; ++ p->setPen( cg.color( QColorGroup::Link ) ); ++ f.setUnderline( true ); ++ p->setFont( f ); ++ p->drawText( pos, margin + 5, ++ width, h - ( margin +5 ), AlignTop, m_link_text ); ++ m_link_rect = QRect( pos, margin + 5, lwidth, p->fontMetrics().height() ); ++ pos += lwidth; ++ f.setUnderline( false ); ++ p->setFont( f ); ++ p->drawText( pos, margin + 5, ++ width, h - ( margin +5 ), AlignTop, ")" ); ++ } ++ } ++} ++ ++KMenuItemHeader::KMenuItemHeader(int nId, const QString& relPath, QListView* parent) ++ : KMenuItemSeparator(nId, parent) ++{ ++ setEnabled( false ); ++ QString path; ++ if (relPath.startsWith( "new/" /*"kicker:/new/"*/ )) { ++ paths.append( "kicker:/goup/" ); ++ texts.append( i18n("New Applications") ); ++ icons.append( "clock" ); ++ } ++ else if (relPath == "kicker:/restart/") { ++ texts.append( i18n("Restart Computer") ); ++ } ++ else if (relPath == "kicker:/switchuser/") { ++ texts.append( i18n("Switch User") ); ++ } ++ else { ++ KServiceGroup::Ptr subMenuRoot = KServiceGroup::group(relPath); ++ QStringList items = QStringList::split( '/', relPath ); ++ for ( QStringList::ConstIterator it = items.begin(); it != items.end(); ++it ) ++ { ++ path += *it + "/"; ++ paths.append( "kicker:/goup/" + path ); ++ KServiceGroup::Ptr subMenuRoot = KServiceGroup::group(path); ++ QString groupCaption = subMenuRoot->caption(); ++ texts.append( groupCaption ); ++ icons.append( subMenuRoot->icon() ); ++ } ++ } ++ ++ setPath( "kicker:/goup/" + path ); // the last wins for now ++ left_margin = 10; ++} ++ ++void KMenuItemHeader::setup() ++{ ++ KMenuItem::setup(); ++ ++ QFontMetrics fm( listView()->font() ); ++ setHeight( QMAX( int( texts.count() * fm.height() + ( texts.count() + 1 ) * 2 + 10 ), height()) ); ++ // nada ++} ++ ++void KMenuItemHeader::paintCell(QPainter* p, const QColorGroup & cg, int , int width, int align ) ++{ ++ preparePixmap(width); ++ ++ const BackgroundMode bgmode = listView()->viewport()->backgroundMode(); ++ const QColorGroup::ColorRole crole = QPalette::backgroundRoleFromMode( bgmode ); ++ ++ QBrush br = cg.brush( crole ); ++ if ( isSelected() ) { ++ br = cg.brush( QColorGroup::Highlight ); ++ p->fillRect( 0, 0, width, height() - 3, br ); ++ } else { ++ p->fillRect( 0, 0, width, height(), br ); ++ } ++ ++ QFontMetrics fm( p->fontMetrics() ); ++ const int left_margin = 10; ++ ++ const int margin = 3; ++ ++ int r = left_margin + margin * 2; ++ ++ const int min_font_size = 7; ++ int title_font_pixelSize = qRound( pixelSize( QMAX( pointSize( 12, listView() ) + KickerSettings::kickoffFontPointSizeOffset(), min_font_size + 1 ), listView() ) ); ++ ++ QFont f1 = p->font(); ++ f1.setPixelSize( title_font_pixelSize ); ++ p->setFont( f1 ); ++ int f1h = QFontMetrics( f1 ).height(); ++ ++ p->setPen( cg.color( QColorGroup::Text ) ); ++ ++ const int text_margin = 2; ++ int spacing = ( height() - texts.count() * f1h - QMAX( texts.count() - 1, 0 ) * text_margin ) / 2; ++ ++ for ( uint i = 0; i < texts.count(); ++i ) ++ { ++ if (i==texts.count()-1) { ++ f1.setWeight( QFont::DemiBold ); ++ p->setFont( f1 ); ++ f1h = QFontMetrics( f1 ).height(); ++ } ++ ++ p->drawText( r, spacing, width-text_margin-r, height(), align, texts[i] ); ++ spacing += text_margin + f1h; ++ r += title_font_pixelSize; ++ } ++ ++ p->drawPixmap( left_margin , height() - 2, pixmap ); ++} ++ ++KMenuSpacer::KMenuSpacer(int nId, QListView* parent) ++ : KMenuItem(nId, parent) ++{ ++ setEnabled(false); ++} ++ ++void KMenuSpacer::setup() ++{ ++ // nada ++} ++ ++void KMenuSpacer::paintCell(QPainter* p, const QColorGroup & cg, int , int width, int ) ++{ ++ const BackgroundMode bgmode = listView()->viewport()->backgroundMode(); ++ const QColorGroup::ColorRole crole = QPalette::backgroundRoleFromMode( bgmode ); ++ QBrush br = cg.brush( crole ); ++ ++ p->fillRect( 0, 0, width, height(), br ); ++} ++ ++void KMenuSpacer::setHeight( int i ) ++{ ++ KMenuItem::setHeight( i ); ++} ++ ++class ItemViewTip : public QToolTip ++{ ++public: ++ ItemViewTip( QWidget *parent, QListView *lv ); ++ ++ void maybeTip( const QPoint &pos ); ++ ++private: ++ QListView *view; ++ ++}; ++ ++ItemViewTip::ItemViewTip( QWidget *parent, QListView *lv ) ++ : QToolTip( parent ), view( lv ) ++{ ++} ++ ++void ItemViewTip::maybeTip( const QPoint &pos ) ++{ ++ KMenuItem *item = dynamic_cast<KMenuItem*>( view->itemAt( pos ) ); ++ QPoint contentsPos = view->viewportToContents( pos ); ++ if ( !item ) ++ return; ++ ++ if ( item->toolTip().isNull() ) ++ return; ++ ++ QRect r = view->itemRect( item ); ++ int headerPos = view->header()->sectionPos( 0 ); ++ r.setLeft( headerPos ); ++ r.setRight( headerPos + view->header()->sectionSize( 0 ) ); ++ tip( r, item->toolTip() ); ++} ++ ++// -------------------------------------------------------------------------- ++ ++ItemView::ItemView(QWidget* parent, const char* name) ++ : KListView(parent, name), m_spacer( 0 ), ++ m_mouseMoveSelects(true), m_iconSize(32) ++{ ++ setHScrollBarMode( QScrollView::AlwaysOff ); ++ setFrameStyle( QFrame::NoFrame ); ++ setSelectionMode(QListView::Single); ++ addColumn(""); ++ header()->setStretchEnabled(1, 0); ++ //setColumnWidthMode(0, QListView::Maximum); ++ header()->hide(); ++ setMouseTracking(true); ++ setItemMargin(0); ++ setSorting(-1); ++ setTreeStepSize(38); ++ setFocusPolicy(QWidget::NoFocus); ++ ++ m_lastOne = 0; ++ m_old_contentY = -1; ++ ++ connect(this, SIGNAL(mouseButtonClicked( int, QListViewItem*, const QPoint &, int )), ++ SLOT(slotItemClicked(int, QListViewItem*, const QPoint &, int))); ++ ++ connect(this, SIGNAL(returnPressed(QListViewItem*)), SLOT(slotItemClicked(QListViewItem*))); ++ connect(this, SIGNAL(spacePressed(QListViewItem*)), SLOT(slotItemClicked(QListViewItem*))); ++ ++ new ItemViewTip( viewport(), this ); ++} ++ ++KMenuItemHeader *ItemView::insertHeader(int id, const QString &relpath) ++{ ++ KMenuItemHeader *newItem = new KMenuItemHeader(id, relpath, this ); ++ moveItemToIndex(newItem, 1); ++ setBackPath( "kicker:/goup/" + relpath ); // the last wins for now ++ ++ return newItem; ++} ++ ++KMenuItem* ItemView::findItem(int nId) ++{ ++ for (QListViewItemIterator it(this); it.current(); ++it) ++ { ++ if(static_cast<KMenuItem*>(it.current())->id() == nId) ++ return static_cast<KMenuItem*>(it.current()); ++ } ++ ++ return 0L; ++} ++ ++bool ItemView::focusNextPrevChild(bool /*next*/) ++{ ++ return false; ++} ++ ++KMenuItem* ItemView::itemAtIndex(int nIndex) ++{ ++ if(nIndex <= 0) ++ return 0L; ++ ++ if(nIndex >= childCount()) ++ return static_cast<KMenuItem*>(lastItem()); ++ ++ int i = 1; ++ QListViewItemIterator it(this); ++ for (;it.current(); ++i, ++it) { ++ if(i == nIndex) ++ return static_cast<KMenuItem*>(it.current()); ++ } ++ ++ return static_cast<KMenuItem*>(lastItem()); ++} ++ ++KMenuItem* ItemView::insertItem( const QString& icon, const QString& text, const QString& description, const ++ QString& path, int nId, int nIndex, KMenuItem *parent) ++{ ++ KMenuItem* newItem = findItem(nId); ++ ++ if(!newItem && parent) ++ newItem = new KMenuItem(nId, parent ); ++ else if ( !newItem ) ++ newItem = new KMenuItem(nId, this ); ++ ++ newItem->setIcon(icon, m_iconSize); ++ newItem->setTitle(text); ++ newItem->setDescription(description); ++ newItem->setPath(path); ++ ++ if (nIndex==-1) ++ nIndex=childCount(); ++ ++ moveItemToIndex(newItem, nIndex); ++ ++ return newItem; ++} ++ ++KMenuItem* ItemView::insertItem( const QString& icon, const QString& text, const QString& description, ++ int nId, int nIndex, KMenuItem *parent) ++{ ++ return insertItem( icon, text, description, QString::null, nId, nIndex, parent); ++} ++ ++int ItemView::setItemEnabled(int id, bool enabled) ++{ ++ KMenuItem* item = findItem(id); ++ ++ if(item) ++ item->setEnabled(enabled); ++ ++ return 0; ++} ++ ++KMenuItemSeparator *ItemView::insertSeparator(int nId, const QString& text, int nIndex) ++{ ++ KMenuItemSeparator *newItem = new KMenuItemSeparator(nId, this); ++ ++ newItem->setText(0, text); ++ ++ if (nIndex==-1) ++ nIndex=childCount(); ++ ++ moveItemToIndex(newItem, nIndex); ++ return newItem; ++} ++ ++void ItemView::moveItemToIndex(KMenuItem* item, int nIndex) ++{ ++ ++ if (nIndex <= 0) { ++ takeItem(item); ++ KListView::insertItem(item); ++ } ++ else { ++ item->moveItem(itemAtIndex(nIndex)); ++ } ++} ++ ++void ItemView::slotMoveContent() ++{ ++ if ( !m_spacer ) ++ return; ++ ++ int item_height = 0; ++ QListViewItemIterator it( this ); ++ while ( it.current() ) { ++ if ( !dynamic_cast<KMenuSpacer*>( it.current() ) && !it.current()->parent() && it.current()->isVisible() ) { ++ it.current()->invalidateHeight(); ++ item_height += it.current()->totalHeight(); ++ } ++ ++it; ++ } ++ ++ if ( height() > item_height ) ++ m_spacer->setHeight( height() - item_height ); ++ else ++ m_spacer->setHeight( 0 ); ++} ++ ++KMenuItem *ItemView::insertMenuItem(KService::Ptr& s, int nId, int nIndex, KMenuItem* parentItem, ++ const QString& aliasname, const QString & label, const QString & categoryIcon ) ++{ ++ if (!s) ++ return 0; ++ ++ QString serviceName = aliasname.isEmpty() ? s->name() : aliasname; ++ ++ kdDebug() << "insertMenuItem " << nId << " " << nIndex << " " << s->name() << endl; ++ KMenuItem* newItem = 0; //findItem(nId); ++ if(!newItem) ++ newItem = parentItem ? new KMenuItem(nId, parentItem) : new KMenuItem(nId, this); ++ ++ newItem->setIcon(s->icon()=="unknown" ? categoryIcon : s->icon(), m_iconSize); ++ if ((KickerSettings::DescriptionAndName || KickerSettings::menuEntryFormat() ++ == KickerSettings::DescriptionOnly) && !s->genericName().isEmpty()) { ++ newItem->setTitle(s->genericName()); ++ newItem->setDescription(label.isEmpty() ? serviceName : label); ++ } ++ else { ++ newItem->setTitle(label.isEmpty() ? serviceName : label); ++ newItem->setDescription(s->genericName()); ++ } ++ newItem->setService(s); ++ ++ if (nIndex==-2) ++ return newItem; ++ ++ if (nIndex==-1) ++ nIndex=childCount(); ++ ++ moveItemToIndex(newItem, nIndex); ++ ++ return newItem; ++} ++ ++KMenuItem* ItemView::insertDocumentItem(const QString& s, int nId, int nIndex, const QStringList* /*suppressGenericNames*/, ++ const QString& /*aliasname*/) ++{ ++ KMenuItem* newItem = findItem(nId); ++ ++ if(!newItem) ++ newItem = new KMenuItem(nId, this); ++ ++ KMimeType::Ptr mt = KMimeType::findByURL( s ); ++ newItem->setIcon(KMimeType::iconForURL( s ), m_iconSize); ++ newItem->setTitle(s); ++ newItem->setDescription(mt->comment()); ++ newItem->setPath(s); ++ ++ if (nIndex==-1) ++ nIndex=childCount(); ++ ++ moveItemToIndex(newItem, nIndex); ++ ++ return newItem; ++} ++ ++KMenuItem* ItemView::insertRecentlyItem(const QString& s, int nId, int nIndex) ++{ ++ KDesktopFile f(s, true /* read only */); ++ ++ KMenuItem* newItem = findItem(nId); ++ ++ if(!newItem) ++ newItem = new KMenuItem(nId, this); ++ ++ newItem->setIcon(f.readIcon(), m_iconSize); ++ ++ // work around upstream fixed bug ++ QString name=f.readName(); ++ if (name.isEmpty()) ++ name=f.readURL(); ++ ++ newItem->setTitle(name); ++ ++ QString comment = f.readComment(); ++ if (comment.isEmpty()) { ++ KURL url(f.readURL()); ++ if (!url.host().isEmpty()) ++ comment = i18n("Host: %1").arg(url.host()); ++ } ++ ++ newItem->setDescription(comment); ++ newItem->setPath(s); ++ ++ if (nIndex==-1) ++ nIndex=childCount(); ++ ++ moveItemToIndex(newItem, nIndex); ++ ++ return newItem; ++} ++ ++int ItemView::insertItem(PopupMenuTitle*, int, int) ++{ ++ return 0; ++} ++ ++KMenuItem* ItemView::insertSubItem(const QString& icon, const QString& caption, const QString& description, const QString& path, KMenuItem* parentItem) ++{ ++#warning FIXME ++ KMenuItem* newItem = parentItem ? new KMenuItem(-1, parentItem) : new KMenuItem(-1, this); ++ newItem->setTitle(caption); ++ newItem->setDescription(description); ++ newItem->setIcon(icon, m_iconSize); ++ newItem->setPath(path); ++ ++ return newItem; ++} ++ ++ ++ ++void ItemView::slotItemClicked(int button, QListViewItem * item, const QPoint & /*pos*/, int /*c*/ ) ++{ ++ if (button==1) ++ slotItemClicked(item); ++} ++ ++void ItemView::slotItemClicked(QListViewItem* item) ++{ ++ KMenuItem* kitem = dynamic_cast<KMenuItem*>(item); ++ if ( !kitem ) ++ return; ++ ++ if(kitem->service()) { ++ emit startService(kitem->service()); ++ } ++ else if(!kitem->path().isEmpty()) { ++ emit startURL(kitem->path()); ++ } ++} ++ ++void ItemView::contentsMousePressEvent ( QMouseEvent * e ) ++{ ++ KListView::contentsMousePressEvent( e ); ++ ++ QPoint vp = contentsToViewport(e->pos()); ++ KMenuItemSeparator *si = dynamic_cast<KMenuItemSeparator*>( itemAt( vp ) ); ++ if ( si ) ++ { ++ if ( si->hitsLink( vp - itemRect(si).topLeft() ) ) ++ emit startURL( si->linkUrl() ); ++ } ++} ++ ++void ItemView::contentsMouseMoveEvent(QMouseEvent *e) ++{ ++ QPoint vp = contentsToViewport(e->pos()); ++ QListViewItem * i = itemAt( vp ); ++ ++ bool link_cursor = false; ++ KMenuItemSeparator *si = dynamic_cast<KMenuItemSeparator*>( i ); ++ if ( si ) ++ link_cursor = si->hitsLink( vp - itemRect(si).topLeft() ); ++ ++ if (i && !i->isSelectable() && !link_cursor) { ++ unsetCursor(); ++ viewport()->unsetCursor(); ++ return; ++ } ++ ++ KListView::contentsMouseMoveEvent(e); ++ ++ if (m_mouseMoveSelects) { ++ if(i && i->isEnabled() && !i->isSelected() && ++ // FIXME: This is wrong if you drag over the items. ++ (e->state() & (LeftButton|MidButton|RightButton)) == 0) ++ KListView::setSelected(i, true); ++ else if (!i && selectedItem()) ++ KListView::setSelected(selectedItem(), false); ++ } ++ ++ if ( link_cursor ) ++ setCursor( Qt::PointingHandCursor ); ++ else ++ unsetCursor(); ++ ++} ++ ++void ItemView::leaveEvent(QEvent* e) ++{ ++ KListView::leaveEvent(e); ++ ++ clearSelection(); ++} ++ ++void ItemView::resizeEvent ( QResizeEvent * e ) ++{ ++ KListView::resizeEvent( e ); ++// if ( m_lastOne ) ++// int diff = itemRect( m_lastOne ).bottom() - viewport()->height(); ++} ++ ++void ItemView::viewportPaintEvent ( QPaintEvent * pe ) ++{ ++ //kdDebug() << "viewportPaintEvent " << pe->rect() << " " << contentsY () << " " << m_old_contentY << endl; ++ KListView::viewportPaintEvent( pe ); ++ ++ if ( m_lastOne && m_old_contentY != contentsY() ) { ++ m_old_contentY = contentsY(); ++ m_lastOne->repaint(); ++ } ++} ++ ++void ItemView::clear() ++{ ++ KListView::clear(); ++ m_lastOne = 0; ++ m_old_contentY = -1; ++ m_back_url = QString::null; ++} ++ ++void ItemView::contentsWheelEvent(QWheelEvent *e) ++{ ++ KListView::contentsWheelEvent(e); ++ ++ QPoint vp = contentsToViewport(e->pos()); ++ QListViewItem * i = itemAt( vp ); ++ ++ if(i && i->isEnabled() && !i->isSelected() && ++ // FIXME: This is wrong if you drag over the items. ++ (e->state() & (LeftButton|MidButton|RightButton)) == 0) ++ KListView::setSelected(i, true); ++ else if (!i && selectedItem()) ++ KListView::setSelected(selectedItem(), false); ++} ++ ++QDragObject * ItemView::dragObject() ++{ ++ KMultipleDrag* o = 0; ++ QListViewItem *item = itemAt( viewport()->mapFromGlobal(QCursor::pos()) ); ++ if ( item ) { ++ KMenuItem* kitem = static_cast<KMenuItem*>(item); ++ ++ if (dynamic_cast<KMenuItemHeader*>(item)) ++ return 0; ++ ++ o = new KMultipleDrag(viewport()); ++ QPixmap pix = KGlobal::iconLoader()->loadIcon( kitem->icon(), KIcon::Panel, m_iconSize); ++ QPixmap add = KGlobal::iconLoader()->loadIcon( "add", KIcon::Small ); ++ ++ QPainter p( &pix ); ++ p.drawPixmap(pix.height()-add.height(), pix.width()-add.width(), add); ++ p.end(); ++ ++ QBitmap mask; ++ ++ if (pix.mask()) ++ mask = *pix.mask(); ++ else { ++ mask.resize(pix.size()); ++ mask.fill(Qt::color1); ++ } ++ ++ bitBlt( &mask, pix.width()-add.width(), pix.height()-add.height(), add.mask(), 0, 0, add.width(), add.height(), OrROP ); ++ pix.setMask( mask ); ++ o->setPixmap(pix); ++ ++ if(kitem->service()) { ++ // If the path to the desktop file is relative, try to get the full ++ // path from KStdDirs. ++ QString path = kitem->service()->desktopEntryPath(); ++ path = locate("apps", path); ++ o->addDragObject(new KURLDrag(KURL::List(KURL(path)), 0)); ++ } ++ else if (kitem->path().startsWith("kicker:/new") || kitem->path().startsWith("system:/") ++ || kitem->path().startsWith("kicker:/switchuser_") || kitem->path().startsWith("kicker:/restart_")) { ++ delete o; ++ return 0; ++ } ++ else if (kitem->hasChildren()) { ++ o->addDragObject(new KURLDrag(KURL::List(KURL("programs:/"+kitem->menuPath())), 0)); ++ return o; ++ } ++ else if(!kitem->path().isEmpty() && !kitem->path().startsWith("kicker:/") && !kitem->path().startsWith("kaddressbook:/")) { ++ QString uri = kitem->path(); ++ ++ if (uri.startsWith(locateLocal("data", QString::fromLatin1("RecentDocuments/")))) { ++ KDesktopFile df(uri,true); ++ uri=df.readURL(); ++ } ++ ++ o->addDragObject(new KURLDrag(KURL::List(KURL(uri)), 0)); ++ } ++ ++ o->addDragObject(new KMenuItemDrag(*kitem,this)); ++ } ++ return o; ++} ++ ++int ItemView::goodHeight() ++{ ++ int item_height = 0; ++ QListViewItemIterator it( this ); ++ while ( it.current() ) { ++ if ( !dynamic_cast<KMenuSpacer*>( it.current() ) && !it.current()->parent() && it.current()->isVisible() ) { ++ item_height += it.current()->height(); ++ } ++ ++it; ++ } ++ ++ return item_height; ++} ++ ++ ++KMenuItemDrag::KMenuItemDrag(KMenuItem& item, QWidget *dragSource) ++ : QDragObject(dragSource, 0) ++{ ++ QBuffer buff(a); ++ buff.open(IO_WriteOnly); ++ QDataStream s(&buff); ++ ++ s << item.id() << (item.service() ? item.service()->storageId() : QString::null) ++ << item.title() << item.description() << item.icon() << item.path(); ++} ++ ++KMenuItemDrag::~KMenuItemDrag() ++{ ++} ++ ++const char * KMenuItemDrag::format(int i) const ++{ ++ if (i == 0) ++ return "application/kmenuitem"; ++ ++ return 0; ++} ++ ++QByteArray KMenuItemDrag::encodedData(const char* mimeType) const ++{ ++ if (QString("application/kmenuitem") == mimeType) ++ return a; ++ ++ return QByteArray(); ++} ++ ++bool KMenuItemDrag::canDecode(const QMimeSource * e) ++{ ++ if (e->provides( "application/kmenuitem" ) ) ++ return true; ++ ++ return false; ++} ++ ++bool ItemView::acceptDrag (QDropEvent* event) const ++{ ++ if ( !acceptDrops() ) ++ return false; ++ ++ if (KMenuItemDrag::canDecode(event)) ++ return true; ++ ++ if (QTextDrag::canDecode(event)) { ++ QString text; ++ QTextDrag::decode(event,text); ++ return !text.startsWith("programs:/"); ++ } ++ ++ return itemsMovable(); ++} ++ ++bool KMenuItemDrag::decode(const QMimeSource* e, KMenuItemInfo& item) ++{ ++ QByteArray a = e->encodedData("application/kmenuitem"); ++ ++ if (a.isEmpty()) { ++ QStringList l; ++ bool ret = QUriDrag::decodeToUnicodeUris( e, l ); ++ if ( ret ) ++ { ++ for ( QStringList::ConstIterator it = l.begin(); it != l.end(); ++it ) ++ { ++ QString url = *it; ++ kdDebug () << "Url " << url << endl; ++ item.m_path = KURL( url ).path(); ++ if ( KDesktopFile::isDesktopFile( item.m_path ) ) ++ { ++ KDesktopFile df( item.m_path, true ); ++ item.m_description = df.readGenericName(); ++ item.m_icon = df.readIcon(); ++ item.m_title = df.readName(); ++ } ++ else ++ { ++ item.m_title = item.m_path; ++ item.m_icon = KMimeType::iconForURL( url ); ++ item.m_title = item.m_path.section( '/', -1, -1 ); ++ int last_slash = url.findRev ('/', -1); ++ if (last_slash == 0) ++ item.m_description = i18n("Directory: /)"); ++ else ++ item.m_description = i18n("Directory: ") + url.section ('/', -2, -2); ++ } ++ ++ return true; ++ } ++ } ++ return false; ++ } ++ ++ QBuffer buff(a); ++ buff.open(IO_ReadOnly); ++ QDataStream s(&buff); ++ ++ KMenuItemInfo i; ++ QString storageId; ++ s >> i.m_id >> storageId >> i.m_title >> i.m_description >> i.m_icon >> i.m_path; ++ ++ i.m_s = storageId.isEmpty() ? 0 : KService::serviceByStorageId(storageId); ++ item = i; ++ ++ return true; ++} ++ ++FavoritesItemView::FavoritesItemView(QWidget* parent, const char* name) ++ : ItemView(parent, name) ++{ ++} ++ ++bool FavoritesItemView::acceptDrag (QDropEvent* event) const ++{ ++ if (event->source()==this->viewport()) ++ return true; ++ ++ if (KMenuItemDrag::canDecode(event)) { ++ KMenuItemInfo item; ++ KMenuItemDrag::decode(event,item); ++ QStringList favs = KickerSettings::favorites(); ++ ++ if (item.m_s) ++ return favs.find(item.m_s->storageId())==favs.end(); ++ else { ++ QStringList::Iterator it; ++ ++ QString uri = item.m_path; ++ ++ if (uri.startsWith(locateLocal("data", QString::fromLatin1("RecentDocuments/")))) { ++ KDesktopFile df(uri,true); ++ uri=df.readURL(); ++ } ++ ++ for (it = favs.begin(); it != favs.end(); ++it) { ++ if ((*it)[0]=='/') { ++ KDesktopFile df((*it),true); ++ if (df.readURL().replace("file://",QString::null)==uri) ++ break; ++ } ++ } ++ return it==favs.end(); ++ } ++ } ++ ++ if (QTextDrag::canDecode(event)) { ++ QString text; ++ QTextDrag::decode(event,text); ++ QStringList favs = KickerSettings::favorites(); ++ ++ if (text.endsWith(".desktop")) { ++ KService::Ptr p = KService::serviceByDesktopPath(text.replace("file://",QString::null)); ++ return (p && favs.find(p->storageId())==favs.end()); ++ } ++ else { ++ QStringList::Iterator it; ++ for (it = favs.begin(); it != favs.end(); ++it) { ++ if ((*it)[0]=='/') { ++ KDesktopFile df((*it),true); ++ if (df.readURL().replace("file://",QString::null)==text) ++ break; ++ } ++ } ++ return it==favs.end(); ++ } ++ } ++ ++ return itemsMovable(); ++} ++ ++#include "itemview.moc" ++ ++// vim:cindent:sw=4: +--- kicker/ui/media_watcher.cpp (Revision 0) ++++ kicker/ui/media_watcher.cpp (Revision 849791) +@@ -0,0 +1,57 @@ ++/***************************************************************** ++ ++Copyright (c) 2006 Stephan Kulow <coolo@novell.com> ++ ++Permission is hereby granted, free of charge, to any person obtaining a copy ++of this software and associated documentation files (the "Software"), to deal ++in the Software without restriction, including without limitation the rights ++to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++copies of the Software, and to permit persons to whom the Software is ++furnished to do so, subject to the following conditions: ++ ++The above copyright notice and this permission notice shall be included in ++all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN ++AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ ++******************************************************************/ ++ ++#include "media_watcher.h" ++#include <kapplication.h> ++#include <kdebug.h> ++#include <dcopclient.h> ++#include <dcopref.h> ++ ++MediaWatcher::MediaWatcher( QObject *parent ) : ++ QObject( parent ), DCOPObject("mediawatcher") ++{ ++ connectDCOPSignal( "kded", "mediamanager", "mediumAdded(QString,bool)", ++ "slotMediumAdded(QString,bool)", true ); ++ connectDCOPSignal( "kded", "mediamanager", "mediumRemoved(QString,bool)", ++ "slotMediumAdded(QString,bool)", true ); ++ connectDCOPSignal( "kded", "mediamanager", "mediumChanged(QString,bool)", ++ "slotMediumAdded(QString,bool)", true ); ++ ++ updateDevices(); ++} ++ ++void MediaWatcher::updateDevices() ++{ ++ DCOPRef nsd( "kded", "mediamanager" ); ++ nsd.setDCOPClient( kapp->dcopClient() ); ++ m_devices = nsd.call( "fullList" ); ++} ++ ++void MediaWatcher::slotMediumAdded( QString item, bool a ) ++{ ++ updateDevices(); ++ ++ emit mediumChanged(); ++} ++ ++#include "media_watcher.moc" + +Eigenschaftsänderungen: kicker/ui +___________________________________________________________________ +Geändert: svn:ignore + - nonKDEButtonSettings.h +appletitem.h +appletview.cpp +nonKDEButtonSettings.cpp +k_mnu.kidl +appletview.h +appletitem.cpp +k_mnu_skel.cpp +.deps +.libs +Makefile +Makefile.in +*.moc + + + nonKDEButtonSettings.h +appletitem.h +appletview.cpp +nonKDEButtonSettings.cpp +k_mnu.kidl +appletview.h +appletitem.cpp +k_mnu_skel.cpp +.deps +.libs +Makefile +Makefile.in +*.moc +kmenuitembase.cpp +media_watcher.kidl +kmenubase.cpp +kmenuitembase.h +kmenubase.h +media_watcher_skel.cpp + + +--- kicker/buttons/knewbutton.cpp (Revision 0) ++++ kicker/buttons/knewbutton.cpp (Revision 849791) +@@ -0,0 +1,455 @@ ++/***************************************************************** ++ ++Copyright (c) 2006 Stephan Binner <binner@kde.org> ++ Stephan Kulow <coolo@kde.org> ++ Dirk Mueller <mueller@kde.org> ++ ++Permission is hereby granted, free of charge, to any person obtaining a copy ++of this software and associated documentation files (the "Software"), to deal ++in the Software without restriction, including without limitation the rights ++to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++copies of the Software, and to permit persons to whom the Software is ++furnished to do so, subject to the following conditions: ++ ++The above copyright notice and this permission notice shall be included in ++all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN ++AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ ++******************************************************************/ ++ ++#include <cassert> ++#include <cmath> ++ ++#include <qtooltip.h> ++#include <qpainter.h> ++#include <qcursor.h> ++#include <private/qeffects_p.h> ++ ++#include <klocale.h> ++#include <kapplication.h> ++#include <kstandarddirs.h> ++#include <kiconloader.h> ++#include <kdebug.h> ++ ++#include "kickerSettings.h" ++ ++#include "config.h" ++#include "global.h" ++ ++#include "menumanager.h" ++#include "k_mnu_stub.h" ++#include "k_new_mnu.h" ++ ++#include "knewbutton.h" ++#include "knewbutton.moc" ++ ++KNewButton *KNewButton::m_self = 0; ++ ++KNewButton::KNewButton( QWidget* parent ) ++ : KButton( parent ), ++ m_oldPos(0,0) ++{ ++ Q_ASSERT( !m_self ); ++ m_self = this; ++ m_hoverTimer = -1; ++ m_openTimer = -1; ++ m_active = false; ++ m_mouseInside = false; ++ m_drag = false; ++ ++ setIconAlignment((Qt::AlignmentFlags)(AlignTop|AlignRight)); ++ setAcceptDrops(true); ++ setIcon("kmenu-suse"); ++ setDrawArrow(false); ++ ++ m_movie = new QMovie(locate("data", "kicker/pics/kmenu_basic.mng")); ++ m_movie->connectUpdate(this, SLOT(updateMovie())); ++ m_movie->connectStatus(this, SLOT(slotStatus(int))); ++ m_movie->connectResize(this, SLOT(slotSetSize(const QSize&))); ++ ++ QApplication::desktop()->screen()->installEventFilter(this); ++ setMouseTracking(true); ++} ++ ++KNewButton::~KNewButton() ++{ ++ if ( m_self == this ) ++ m_self = 0; ++ setMouseTracking(false); ++ delete m_movie; ++} ++ ++void KNewButton::slotStatus(int status) ++{ ++ if(status == QMovie::EndOfLoop) ++ slotStopAnimation(); ++} ++ ++QColor KNewButton::borderColor() const ++{ ++ QImage img = m_active_pixmap.convertToImage(); ++ ++ for (int i = 0; i < img.width(); ++i) { ++ QRgb rgb = img.pixel(orientation() == Qt::Horizontal ? img.width() - i - 1 : ++ i, 2); ++ ++ if (qGreen(rgb) > 0x50) ++ return rgb; ++ } ++ ++ return img.pixel( orientation() == Qt::Horizontal ? img.width() - 2 : 2, 2); ++} ++ ++void KNewButton::show() ++{ ++ KButton::show(); ++ ++ if (KickerSettings::firstRun()) { ++ QTimer::singleShot(500,this,SLOT(slotExecMenu())); ++ KickerSettings::setFirstRun(false); ++ KickerSettings::writeConfig(); ++ } ++} ++ ++void KNewButton::updateMovie() ++{ ++ m_oldPos = QPoint( -1, -1 ); ++ drawEye(); ++ ++ if (!m_active && m_movie->running()) ++ m_movie->pause(); ++} ++ ++void KNewButton::setPopupDirection(KPanelApplet::Direction d) ++{ ++ KButton::setPopupDirection(d); ++ ++ delete m_movie; ++ ++ switch (d) { ++ case KPanelApplet::Left: ++ setIconAlignment((Qt::AlignmentFlags)(AlignTop|AlignLeft)); ++ m_movie = new QMovie(locate("data", "kicker/pics/kmenu_vertical.mng")); ++ break; ++ case KPanelApplet::Right: ++ setIconAlignment((Qt::AlignmentFlags)(AlignTop|AlignRight)); ++ m_movie = new QMovie(locate("data", "kicker/pics/kmenu_vertical.mng")); ++ break; ++ case KPanelApplet::Up: ++ setIconAlignment((Qt::AlignmentFlags)(AlignTop|AlignHCenter)); ++ m_movie = new QMovie(locate("data", "kicker/pics/kmenu_basic.mng")); ++ break; ++ case KPanelApplet::Down: ++ setIconAlignment((Qt::AlignmentFlags)(AlignBottom|AlignHCenter)); ++ m_movie = new QMovie(locate("data", "kicker/pics/kmenu_flipped.mng")); ++ } ++ ++ m_movie->connectUpdate(this, SLOT(updateMovie())); ++ m_movie->connectStatus(this, SLOT(slotStatus(int))); ++ m_movie->connectResize(this, SLOT(slotSetSize(const QSize&))); ++} ++ ++void KNewButton::slotSetSize(const QSize& s) ++{ ++ m_iconSize = s; ++} ++ ++double KNewButton::buttonScaleFactor(const QSize& s) const ++{ ++ double sf = 1.0; ++ ++ switch (popupDirection()) { ++ case KPanelApplet::Left: ++ case KPanelApplet::Right: ++// sf = kMin(double(s.width()) / m_iconSize.height(), double(s.height()) / m_iconSize.width()); ++// break; ++ case KPanelApplet::Up: ++ case KPanelApplet::Down: ++ sf = kMin(double(s.width()) / m_iconSize.width(), double(s.height()) / m_iconSize.height()); ++ break; ++ } ++ ++ if (sf > 0.8) sf = 1.0; ++ return sf; ++} ++ ++int KNewButton::widthForHeight(int height) const ++{ ++ int r = m_iconSize.width() * buttonScaleFactor(QSize(m_iconSize.width(), height)); ++ ++ if (!m_movie->running() && height != m_active_pixmap.height()) ++ { ++ KNewButton* that = const_cast<KNewButton*>(this); ++ QTimer::singleShot(0, that, SLOT(slotStopAnimation())); ++ } ++ ++ return r; ++} ++ ++int KNewButton::preferredDimension(int panelDim) const ++{ ++ return kMax(m_icon.width(), m_icon.height()); ++} ++ ++int KNewButton::heightForWidth(int width) const ++{ ++ int r = m_iconSize.width() * buttonScaleFactor(QSize(width, m_iconSize.height())); ++ if (!m_movie->running() && width != m_active_pixmap.width()) ++ { ++ KNewButton* that = const_cast<KNewButton*>(this); ++ QTimer::singleShot(0, that, SLOT(slotStopAnimation())); ++ } ++ return r; ++} ++ ++bool KNewButton::eventFilter(QObject *o, QEvent *e) ++{ ++ if (e->type() == QEvent::MouseButtonRelease || ++ e->type() == QEvent::MouseButtonPress || ++ e->type() == QEvent::MouseButtonDblClick ) ++ { ++ QMouseEvent *me = static_cast<QMouseEvent *>(e); ++ if (rect().contains(mapFromGlobal(me->globalPos()))) ++ { ++ if (m_pressedDuringPopup && m_popup && m_openTimer != -1 ++ && (me->button() & Qt::LeftButton) ) ++ return true; ++ } ++ } ++ ++ if (KickerSettings::kickoffDrawGeekoEye() && e->type() == QEvent::MouseMove) ++ { ++ QMouseEvent *me = static_cast<QMouseEvent *>(e); ++ if ((me->state() & MouseButtonMask) == NoButton) ++ drawEye(); ++ } ++ ++ return KButton::eventFilter(o, e); ++} ++ ++void KNewButton::drawEye() ++{ ++#define eye_x 62 ++#define eye_y 13 ++ QPoint mouse = QCursor::pos(); ++ QPoint me = mapToGlobal(QPoint(eye_x, eye_y)); ++ double a = atan2(mouse.y() - me.y(), mouse.x() - me.x()); ++ int dx = int(2.1 * cos(a)); ++ int dy = int(2.1 * sin(a)); ++ ++ QPoint newpos(eye_x+dx,eye_y+dy); ++ if (newpos!=m_oldPos) { ++ m_oldPos = newpos; ++ QPixmap pixmap = m_active_pixmap; ++ ++ double sf = 1.0; ++ ++ if(!m_movie->framePixmap().isNull()) ++ { ++ pixmap = m_movie->framePixmap(); ++ pixmap.detach(); ++ m_iconSize = pixmap.size(); ++ sf = buttonScaleFactor(size()); ++ ++ if (KickerSettings::kickoffDrawGeekoEye()) { ++ QPainter p(&pixmap); ++ p.setPen(white); ++ p.setBrush(white); ++ // p.setPen(QColor(110,185,55)); ++ p.drawRect(eye_x+dx, eye_y+dy, 2, 2); ++ p. end(); ++ } ++ } ++ ++ QWMatrix matrix; ++ switch (popupDirection()) { ++ case KPanelApplet::Left: ++ matrix.scale(sf, -sf); ++ matrix.rotate(90); ++ break; ++ case KPanelApplet::Up: ++ matrix.scale(sf, sf); ++ break; ++ case KPanelApplet::Right: ++ matrix.scale(sf, -sf); ++ matrix.rotate(90); ++ break; ++ case KPanelApplet::Down: ++ matrix.scale(sf, sf); ++ break; ++ } ++ m_active_pixmap = pixmap.xForm(matrix); ++ ++ repaint(false); ++ } ++#undef eye_x ++#undef eye_y ++} ++ ++void KNewButton::enterEvent(QEvent* e) ++{ ++ KButton::enterEvent(e); ++ ++ QSize s(size()); ++ s *= 0.25; ++ s = s.expandedTo(QSize(6,6)); ++ ++ switch (popupDirection()) { ++ case KPanelApplet::Left: ++ m_sloppyRegion = QRect(rect().topRight() - QPoint(s.width()-1, 0), s); ++ break; ++ case KPanelApplet::Right: ++ m_sloppyRegion = QRect(rect().topLeft(), s); ++ break; ++ case KPanelApplet::Up: ++ m_sloppyRegion = QRect(rect().bottomLeft() - QPoint(0, s.height()-1), s); ++ break; ++ case KPanelApplet::Down: ++ m_sloppyRegion = QRect(rect().topLeft(), s); ++ } ++ ++ m_active = true; ++ m_movie->unpause(); ++ m_movie->restart(); ++} ++ ++void KNewButton::rewindMovie() ++{ ++ m_oldPos = QPoint( -1, -1 ); ++ m_movie->unpause(); ++} ++ ++void KNewButton::dragEnterEvent(QDragEnterEvent* /*e*/) ++{ ++ if (m_hoverTimer != -1) ++ killTimer(m_hoverTimer); ++ ++ m_hoverTimer = startTimer(QApplication::startDragTime()); ++ m_mouseInside = true; ++ m_drag = true; ++} ++ ++void KNewButton::dragLeaveEvent(QDragLeaveEvent* /*e*/) ++{ ++ m_mouseInside = false; ++ m_drag = false; ++} ++ ++void KNewButton::leaveEvent(QEvent* e) ++{ ++ m_mouseInside = false; ++ if (m_hoverTimer != -1) ++ killTimer(m_hoverTimer); ++ m_hoverTimer = -1; ++ ++ KButton::leaveEvent(e); ++} ++ ++void KNewButton::mouseMoveEvent(QMouseEvent* e) ++{ ++ KButton::mouseMoveEvent(e); ++ ++ m_mouseInside = m_sloppyRegion.contains(e->pos()); ++ ++ if ( m_sloppyRegion.contains(e->pos())) ++ { ++ if (m_hoverTimer == -1 && KickerSettings::openOnHover()) ++ m_hoverTimer = startTimer(kMax(200,QApplication::doubleClickInterval()/2)); ++ } ++ else if (m_hoverTimer != -1) ++ { ++ killTimer(m_hoverTimer); ++ m_hoverTimer = -1; ++ } ++} ++ ++void KNewButton::slotStopAnimation() ++{ ++ m_active = false; ++ m_movie->pause(); ++ m_movie->restart(); ++ QTimer::singleShot(200, this, SLOT(rewindMovie())); ++} ++ ++const QPixmap& KNewButton::labelIcon() const ++{ ++ return m_active_pixmap; ++} ++ ++void KNewButton::slotExecMenu() ++{ ++ if (m_openTimer != -1) ++ killTimer(m_openTimer); ++ ++ m_openTimer = startTimer(QApplication::doubleClickInterval() * 3); ++ ++ if (m_active) ++ { ++ m_active = false; ++ m_movie->pause(); ++ m_movie->restart(); ++ } ++ ++ KButton::slotExecMenu(); ++ ++ assert(!KickerTip::tippingEnabled()); ++ assert(dynamic_cast<KMenu*>(m_popup)); ++ ++ disconnect(dynamic_cast<KMenu*>(m_popup), SIGNAL(aboutToHide()), this, ++ SLOT(slotStopAnimation())); ++ connect(dynamic_cast<KMenu*>(m_popup), SIGNAL(aboutToHide()), ++ SLOT(slotStopAnimation())); ++ ++ m_popup->move(KickerLib::popupPosition(popupDirection(), m_popup, this)); ++ // I wish KMenu would properly done itself when it closes. But it doesn't. ++ ++ bool useEffect = true; // could be QApplication::isEffectEnabled() ++ useEffect = false; // too many Qt bugs to be useful ++ if (m_drag) ++ useEffect = false; ++ ++ m_drag = false; // once is enough ++ ++ if (useEffect) ++ { ++ switch (popupDirection()) { ++ case KPanelApplet::Left: ++ qScrollEffect(m_popup, QEffects::LeftScroll); ++ break; ++ case KPanelApplet::Up: ++ qScrollEffect(m_popup, QEffects::UpScroll); ++ break; ++ case KPanelApplet::Right: ++ qScrollEffect(m_popup, QEffects::RightScroll); ++ break; ++ case KPanelApplet::Down: ++ qScrollEffect(m_popup, QEffects::DownScroll); ++ break; ++ } ++ } ++ else ++ static_cast<KMenu*>(m_popup)->show(); ++} ++ ++void KNewButton::timerEvent(QTimerEvent* e) ++{ ++ if (e->timerId() == m_hoverTimer) ++ { ++ if (m_mouseInside && !isDown()) ++ showMenu(); ++ ++ killTimer(m_hoverTimer); ++ m_hoverTimer = -1; ++ } ++ if (e->timerId() == m_openTimer) ++ { ++ killTimer(m_openTimer); ++ m_openTimer = -1; ++ } ++} +--- kicker/buttons/knewbutton.h (Revision 0) ++++ kicker/buttons/knewbutton.h (Revision 849791) +@@ -0,0 +1,98 @@ ++/***************************************************************** ++ ++Copyright (c) 2006 Stephan Binner <binner@kde.org> ++ Stephan Kulow <coolo@kde.org> ++ Dirk Mueller <mueller@kde.org> ++ ++Permission is hereby granted, free of charge, to any person obtaining a copy ++of this software and associated documentation files (the "Software"), to deal ++in the Software without restriction, including without limitation the rights ++to use, copy, modify, merge, publish, distribute, sublicense, and/or sell ++copies of the Software, and to permit persons to whom the Software is ++furnished to do so, subject to the following conditions: ++ ++The above copyright notice and this permission notice shall be included in ++all copies or substantial portions of the Software. ++ ++THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN ++AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN ++CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++ ++******************************************************************/ ++ ++#ifndef __knewbutton_h__ ++#define __knewbutton_h__ ++ ++#include "kbutton.h" ++ ++#include <qmovie.h> ++#include <qpoint.h> ++ ++/** ++ * Button that contains the PanelKMenu and client menu manager. ++ */ ++class KNewButton : public KButton ++{ ++ Q_OBJECT ++ ++public: ++ KNewButton( QWidget *parent ); ++ ~KNewButton(); ++ ++ static KNewButton *self() { return m_self; } ++ ++ void loadConfig( const KConfigGroup& config ); ++ ++ virtual const QPixmap& labelIcon() const; ++ ++ virtual int widthForHeight(int height) const; ++ virtual int preferredDimension(int panelDim) const; ++ virtual int heightForWidth(int width) const; ++ ++ QColor borderColor() const; ++ ++ virtual void setPopupDirection(KPanelApplet::Direction d); ++ ++private slots: ++ void slotStatus(int); ++ void slotSetSize(const QSize&); ++ void slotStopAnimation(); ++ void rewindMovie(); ++ void updateMovie(); ++ ++protected: ++ virtual void show(); ++ virtual void slotExecMenu(); ++ virtual QString tileName() { return "KMenu"; } ++ virtual QString defaultIcon() const { return "go"; } ++ ++ virtual void enterEvent(QEvent* e); ++ virtual void leaveEvent(QEvent* e); ++ virtual void mouseMoveEvent(QMouseEvent* e); ++ virtual void dragEnterEvent(QDragEnterEvent*); ++ virtual void dragLeaveEvent(QDragLeaveEvent*); ++ virtual bool eventFilter(QObject *, QEvent *); ++ void timerEvent(QTimerEvent*); ++ ++private: ++ void drawEye(); ++ double buttonScaleFactor(const QSize& s) const; ++ ++ QMovie* m_movie; ++ QPixmap m_active_pixmap; ++ QPoint m_oldPos; ++ QSize m_iconSize; ++ QRect m_sloppyRegion; ++ int m_hoverTimer; ++ int m_openTimer; ++ bool m_active; ++ bool m_mouseInside; ++ bool m_drag; ++ ++ static KNewButton *m_self; ++}; ++ ++#endif +--- kicker/buttons/browserbutton.cpp (Revision 849788) ++++ kicker/buttons/browserbutton.cpp (Revision 849791) +@@ -65,7 +65,7 @@ + topMenu = new PanelBrowserMenu( path ); + setPopup(topMenu); + +- _menuTimer = new QTimer( this ); ++ _menuTimer = new QTimer( this, "_menuTimer" ); + connect( _menuTimer, SIGNAL(timeout()), SLOT(slotDelayedPopup()) ); + + QToolTip::add(this, i18n("Browse: %1").arg(path)); +--- kicker/buttons/kbutton.cpp (Revision 849788) ++++ kicker/buttons/kbutton.cpp (Revision 849791) +@@ -33,6 +33,7 @@ + + #include "menumanager.h" + #include "k_mnu.h" ++#include "k_mnu_stub.h" + + #include "kbutton.h" + #include "kbutton.moc" +@@ -43,7 +44,7 @@ + QToolTip::add(this, i18n("Applications, tasks and desktop sessions")); + setTitle(i18n("K Menu")); + +- setPopup(MenuManager::the()->kmenu()); ++ setPopup(MenuManager::the()->kmenu()->widget()); + MenuManager::the()->registerKButton(this); + setIcon("kmenu"); + +--- kicker/buttons/Makefile.am (Revision 849788) ++++ kicker/buttons/Makefile.am (Revision 849791) +@@ -1,10 +1,10 @@ + INCLUDES = -I$(srcdir)/../core -I$(srcdir)/../../libkicker -I../../libkicker \ +- -I$(srcdir)/../ui -I$(top_srcdir)/libkonq $(all_includes) ++ -I../ui -I$(srcdir)/../ui -I$(top_srcdir)/libkonq $(all_includes) + + noinst_LTLIBRARIES = libkicker_buttons.la + + libkicker_buttons_la_SOURCES = servicebutton.cpp bookmarksbutton.cpp \ +- browserbutton.cpp \ ++ browserbutton.cpp knewbutton.cpp \ + desktopbutton.cpp extensionbutton.cpp kbutton.cpp \ + nonkdeappbutton.cpp servicemenubutton.cpp urlbutton.cpp \ + windowlistbutton.cpp +--- applets/media/mediumbutton.cpp (Revision 849788) ++++ applets/media/mediumbutton.cpp (Revision 849791) +@@ -45,7 +45,8 @@ + #include <konq_drag.h> + + MediumButton::MediumButton(QWidget *parent, const KFileItem &fileItem) +- : PanelPopupButton(parent), mActions(this, this), mFileItem(fileItem) ++ : PanelPopupButton(parent), mActions(this, this), mFileItem(fileItem), mOpenTimer(0, ++ "MediumButton::mOpenTimer") + { + KAction *a = KStdAction::paste(this, SLOT(slotPaste()), + &mActions, "pasteto"); +@@ -74,9 +75,9 @@ + + MediumButton::~MediumButton() + { +- QPopupMenu *menu = popup(); +- setPopup(0); +- delete menu; ++ QPopupMenu *menu = static_cast<QPopupMenu*>(popup()); ++ setPopup(0); ++ delete menu; + } + + const KFileItem &MediumButton::fileItem() const +@@ -94,29 +95,29 @@ + + void MediumButton::initPopup() + { +- QPopupMenu *old_popup = popup(); +- +- KFileItemList items; +- items.append(&mFileItem); +- +- KonqPopupMenu::KonqPopupFlags kpf = +- KonqPopupMenu::ShowProperties +- | KonqPopupMenu::ShowNewWindow; +- +- KParts::BrowserExtension::PopupFlags bef = +- KParts::BrowserExtension::DefaultPopupItems; +- +- KonqPopupMenu *new_popup = new KonqPopupMenu(0L, items, +- KURL("media:/"), mActions, 0L, +- this, kpf, bef); +- KPopupTitle *title = new KPopupTitle(new_popup); +- title->setTitle(mFileItem.text()); +- +- new_popup->insertItem(title, -1, 0); +- +- setPopup(new_popup); +- +- if (old_popup!=0L) delete old_popup; ++ QPopupMenu *old_popup = static_cast<QPopupMenu*>(popup()); ++ ++ KFileItemList items; ++ items.append(&mFileItem); ++ ++ KonqPopupMenu::KonqPopupFlags kpf = ++ KonqPopupMenu::ShowProperties ++ | KonqPopupMenu::ShowNewWindow; ++ ++ KParts::BrowserExtension::PopupFlags bef = ++ KParts::BrowserExtension::DefaultPopupItems; ++ ++ KonqPopupMenu *new_popup = new KonqPopupMenu(0L, items, ++ KURL("media:/"), mActions, 0L, ++ this, kpf, bef); ++ KPopupTitle *title = new KPopupTitle(new_popup); ++ title->setTitle(mFileItem.text()); ++ ++ new_popup->insertItem(title, -1, 0); ++ ++ setPopup(new_popup); ++ ++ if (old_popup!=0L) delete old_popup; + } + + void MediumButton::refreshType() +--- applets/naughty/NaughtyProcessMonitor.cpp (Revision 849788) ++++ applets/naughty/NaughtyProcessMonitor.cpp (Revision 849791) +@@ -94,7 +94,7 @@ + d = new NaughtyProcessMonitorPrivate; + d->interval_ = interval * 1000; + d->triggerLevel_ = triggerLevel; +- d->timer_ = new QTimer(this); ++ d->timer_ = new QTimer(this, "NaughtyProcessMonitorPrivate::timer"); + connect(d->timer_, SIGNAL(timeout()), this, SLOT(slotTimeout())); + } + +--- applets/launcher/quicklauncher.cpp (Revision 849788) ++++ applets/launcher/quicklauncher.cpp (Revision 849791) +@@ -110,7 +110,7 @@ + m_configAction = new KAction(i18n("Configure Quicklauncher..."), "configure", KShortcut(), + this, SLOT(slotConfigure()), this); + +- m_saveTimer = new QTimer(this); ++ m_saveTimer = new QTimer(this, "m_saveTimer"); + connect(m_saveTimer, SIGNAL(timeout()), this, SLOT(saveConfig())); + + m_popularity = new PopularityStatistics(); +--- applets/trash/trashbutton.cpp (Revision 849788) ++++ applets/trash/trashbutton.cpp (Revision 849791) +@@ -78,7 +78,7 @@ + + void TrashButton::initPopup() + { +- QPopupMenu *old_popup = popup(); ++ QPopupMenu *old_popup = static_cast<QPopupMenu*>(popup()); + + KFileItemList items; + items.append(&mFileItem); +--- applets/systemtray/systemtrayapplet.cpp (Revision 849788) ++++ applets/systemtray/systemtrayapplet.cpp (Revision 849791) +@@ -375,7 +375,7 @@ + connect(m_expandButton, SIGNAL(clicked()), + this, SLOT(toggleExpanded())); + +- m_autoRetractTimer = new QTimer(this); ++ m_autoRetractTimer = new QTimer(this, "m_autoRetractTimer"); + connect(m_autoRetractTimer, SIGNAL(timeout()), + this, SLOT(checkAutoRetract())); + } +--- applets/clock/clock.cpp (Revision 849788) ++++ applets/clock/clock.cpp (Revision 849791) +@@ -863,8 +863,8 @@ + _calendar(0), + _disableCalendar(false), + _clock(0), +- _timer(new QTimer(this)), +- m_layoutTimer(new QTimer(this)), ++ _timer(new QTimer(this, "ClockApplet::_timer")), ++ m_layoutTimer(new QTimer(this, "m_layoutTimer")), + m_layoutDelay(0), + m_followBackgroundSetting(true), + m_dateFollowBackgroundSetting(true), +--- applets/minipager/pagerbutton.cpp (Revision 849788) ++++ applets/minipager/pagerbutton.cpp (Revision 849791) +@@ -70,6 +70,8 @@ + m_bgPixmap(0), + m_isCommon(false), + m_currentWindow(0), ++ m_updateCompressor(0, "KMiniPagerButton::updateCompressor"), ++ m_dragSwitchTimer(0, "KMiniPagerButton::dragSwitchTimer"), + m_inside(false) + { + setToggleButton(true); +--- data/kmenu_side/Makefile.am (Revision 849788) ++++ data/kmenu_side/Makefile.am (Revision 849791) +@@ -1,6 +1,5 @@ +-kicker_kmenuside_pics_data_DATA = kside.png kside_tile.png ++kicker_kmenuside_pics_data_DATA = kside.png kside_tile.png ++kicker_kmenuside_pics_datadir = $(kde_datadir)/kicker/pics + +-kicker_kmenuside_pics_datadir = $(kde_datadir)/kicker/pics/ +- + EXTRA_DIST = $(kicker_kmenuside_pics_data_DATA) + +--- data/Makefile.am (Revision 849788) ++++ data/Makefile.am (Revision 849791) +@@ -1 +1 @@ +-SUBDIRS = icons tiles app_start_anim wallpaper kmenu_side ++SUBDIRS = icons tiles app_start_anim wallpaper kmenu_side kickoff +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/cr32-action-suspend2disk.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/search-tab-left.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/main_corner_tr.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/cr48-app-recently_used.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/search-tab-top-left.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/right_triangle.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/cr16-action-suspend2disk.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/crsc-action-suspend2ram.svgz +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/cr128-action-suspend2ram.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/cr32-action-leave.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/left_triangle.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/menu_separator.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/cr32-action-suspend2ram.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/cr48-action-leave.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/cr16-action-suspend2ram.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/search-tab-top-center.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/search-tab-center.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/cr64-action-suspend2ram.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/cr48-action-suspend2ram.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/search-gradient.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/crsc-action-leave.svgz +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/kmenu_vertical.mng +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/cr64-action-suspend2disk.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/cr48-action-suspend2disk.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/resize_handle.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/kmenu_basic.mng +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/kmenu_flipped.mng +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/search-running.mng +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/search-tab-right.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/search-tab-top-right.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +--- data/kickoff/Makefile.am (Revision 0) ++++ data/kickoff/Makefile.am (Revision 849791) +@@ -0,0 +1,14 @@ ++kicker_kmenuside_pics_data_DATA = resize_handle.png \ ++ main_corner_tl.png main_corner_tr.png search-gradient.png \ ++ menu_separator.png search-tab-center.png search-tab-left.png \ ++ search-tab-right.png search-tab-top-center.png search-tab-top-left.png \ ++ left_triangle.png right_triangle.png \ ++ kmenu_basic.mng kmenu_flipped.mng kmenu_vertical.mng \ ++ search-tab-top-right.png search-gradient-topdown.png search-running.mng ++ ++kicker_kmenuside_pics_datadir = $(kde_datadir)/kicker/pics ++ ++EXTRA_DIST = $(kicker_kmenuside_pics_data_DATA) ++ ++kickerdir = $(kde_datadir)/kicker/icons ++kicker_ICON = leave recently_used suspend2disk suspend2ram +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/cr128-action-suspend2disk.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/crsc-action-suspend2disk.svgz +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/search-gradient-topdown.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + +Kann nicht anzeigen: Dateityp ist als binär angegeben. +svn:mime-type = application/octet-stream + +Eigenschaftsänderungen: data/kickoff/main_corner_tl.png +___________________________________________________________________ +Hinzugefügt: svn:mime-type + + application/octet-stream + + +Eigenschaftsänderungen: data/kickoff +___________________________________________________________________ +Hinzugefügt: svn:ignore + + Makefile +Makefile.in + + |