TDE base libraries and programs
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

3894 lines
134 KiB

/*****************************************************************
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 <tqimage.h>
#include <tqpainter.h>
#include <tqstyle.h>
#include <tqwidgetstack.h>
#include <tqlayout.h>
#include <tqlabel.h>
#include <tqregexp.h>
#include <tqfile.h>
#include <tqstylesheet.h>
#include <tqaccel.h>
#include <tqcursor.h>
#include <tqdir.h>
#include <tqsimplerichtext.h>
#include <tqtooltip.h>
#include <tqtabbar.h>
#include <dcopclient.h>
#include <tdeapplication.h>
#include <tdeabouttde.h>
#include <tdeaction.h>
#include <kbookmarkmenu.h>
#include <tdeconfig.h>
#include <kdebug.h>
#include <tdeglobal.h>
#include <tdeglobalsettings.h>
#include <tdehardwaredevices.h>
#include <kiconloader.h>
#include <klineedit.h>
#include <tdelocale.h>
#include <tdemessagebox.h>
#include <kstandarddirs.h>
#include <kcombobox.h>
#include <twin.h>
#include <kdebug.h>
#include <kuser.h>
#include <kurllabel.h>
#include <krun.h>
#include <kmimetype.h>
#include <tderecentdocument.h>
#include <tdecompletionbox.h>
#include <kurifilter.h>
#include <kbookmarkmanager.h>
#include <kbookmark.h>
#include <kprocess.h>
#include <tdeio/jobclasses.h>
#include <tdeio/job.h>
#include <dcopref.h>
#include <konq_popupmenu.h>
#include <konqbookmarkmanager.h>
#include <tdeparts/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"
#include "config.h"
#ifdef COMPILE_HALBACKEND
#ifndef NO_QT3_DBUS_SUPPORT
/* We acknowledge the the dbus API is unstable */
#define DBUS_API_SUBJECT_TO_CHANGE
#include <dbus/connection.h>
#endif // NO_QT3_DBUS_SUPPORT
#include <hal/libhal.h>
#endif // COMPILE_HALBACKEND
#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 TQString calculate(const TQString &exp)
{
TQString result, cmd;
const TQString bc = TDEStandardDirs::findExe("bc");
if ( !bc.isEmpty() )
cmd = TQString("echo %1 | %2").arg(TDEProcess::quote(exp), TDEProcess::quote(bc));
else
cmd = TQString("echo $((%1))").arg(exp);
FILE *fs = popen(TQFile::encodeName(cmd).data(), "r");
if (fs)
{
TQTextStream ts(fs, IO_ReadOnly);
result = ts.read().stripWhiteSpace();
pclose(fs);
}
return result;
}
static TQString workaroundStringFreeze(const TQString& str)
{
TQString s = str;
s.replace("<u>","&");
TQRegExp 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( TQLabel *label, int oldsize )
{
TQSimpleRichText st( label->text(), TDEGlobalSettings::toolBarFont() );
st.setWidth( oldsize );
return TQMAX( st.widthUsed(), oldsize );
}
KMenu::KMenu()
: KMenuBase(0, "SUSE::Kickoff::KMenu")
, m_sloppyTimer(0, "KNewMenu::sloppyTimer"), m_mediaFreeTimer(0, "KNewMenu::mediaFreeTimer"),
m_iconName(TQString()), m_orientation(UnDetermined), m_search_plugin( 0 )
{
setMouseTracking(true);
connect(&m_sloppyTimer, TQT_SIGNAL(timeout()), TQT_SLOT(slotSloppyTimeout()));
// set the first client id to some arbitrarily large value.
client_id = 10000;
// Don't automatically clear the main menu.
actionCollection = new TDEActionCollection(this);
connect(Kicker::the(), TQT_SIGNAL(configurationChanged()),
this, TQT_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&nbsp;<b>%1</b>&nbsp;on&nbsp;<b>%2</b>" )
.arg( user->loginName() ).arg( hostname ) );
setupUi();
m_userInfo->setBackgroundMode( PaletteBase );
TQColor userInfoColor = TQApplication::palette().color( TQPalette::Normal, TQColorGroup::Mid );
if ( tqGray( 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, TQT_SIGNAL(tabClicked(TQTab*)), TQT_SLOT(tabClicked(TQTab*)));
const int tab_icon_size = 32;
m_tabs[FavoriteTab] = new TQTab;
m_tabBar->addTab(m_tabs[FavoriteTab]);
m_tabBar->setToolTip(FavoriteTab, "<qt>" + i18n( "Most commonly used applications and documents" ) + "</qt>" );
m_tabs[ApplicationsTab] = new TQTab;
m_tabBar->addTab(m_tabs[ApplicationsTab]);
m_tabBar->setToolTip(ApplicationsTab, "<qt>" + i18n( "List of installed applications" ) +
"</qt>" );
m_tabs[ComputerTab] = new TQTab;
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 TQTab;
m_tabBar->addTab(m_tabs[SearchTab]);
#endif
m_tabs[HistoryTab] = new TQTab;
m_tabBar->addTab(m_tabs[HistoryTab]);
m_tabBar->setToolTip(HistoryTab, "<qt>" + i18n( "Recently used applications and documents" ) +
"</qt>" );
m_tabs[LeaveTab] = new TQTab;
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, TQT_SIGNAL(selected(int)), m_stacker, TQT_SLOT(raiseWidget(int)));
connect(m_stacker, TQT_SIGNAL(aboutToShow(int)), m_tabBar, TQT_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, TQT_SIGNAL( backButtonClicked() ), TQT_SLOT( slotGoBack() ) );
m_exitView = new FlipScrollView(m_stacker, "m_exitView");
m_stacker->addWidget(m_exitView, LeaveTab);
connect( m_exitView, TQT_SIGNAL( backButtonClicked() ), TQT_SLOT( slotGoExitMainMenu() ) );
m_searchWidget = new TQVBox (m_stacker, "m_searchWidget");
m_searchWidget->setSpacing(0);
m_stacker->addWidget(m_searchWidget, 5);
// search provider icon
TQPixmap icon;
KURIFilterData data;
TQStringList list;
data.setData( TQString("some keyword") );
list << "kurisearchfilter" << "kuriikwsfilter";
if ( KURIFilter::self()->filterURI(data, list) ) {
TQString iconPath = locate("cache", KMimeType::favIconForURL(data.uri()) + ".png");
if ( iconPath.isEmpty() )
icon = SmallIcon("enhanced_browsing");
else
icon = TQPixmap( 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(TQ_NoFocus);
m_searchActions->setItemMargin(4);
m_searchInternet = new TQListViewItem(m_searchActions, i18n("Search Internet"));
m_searchInternet->setPixmap(0,icon);
setTabOrder(m_kcommand, m_searchResultsWidget);
m_kerryInstalled = !TDEStandardDirs::findExe(TQString::fromLatin1("kerry")).isEmpty();
m_isShowing = false;
if (!m_kerryInstalled) {
m_searchIndex = 0;
m_searchActions->setMaximumHeight(5+m_searchInternet->height());
}
else {
m_searchIndex = new TQListViewItem(m_searchActions, i18n("Search Index"));
m_searchIndex->setPixmap(0,SmallIcon("kerry"));
m_searchActions->setMaximumHeight(5+m_searchIndex->height()*2);
}
connect(m_searchActions, TQT_SIGNAL(clicked(TQListViewItem*)), TQT_SLOT(searchActionClicked(TQListViewItem*)));
connect(m_searchActions, TQT_SIGNAL(returnPressed(TQListViewItem*)), TQT_SLOT(searchActionClicked(TQListViewItem*)));
connect(m_searchActions, TQT_SIGNAL(spacePressed(TQListViewItem*)), TQT_SLOT(searchActionClicked(TQListViewItem*)));
connect(m_searchResultsWidget, TQT_SIGNAL(startService(KService::Ptr)), TQT_SLOT(slotStartService(KService::Ptr)));
connect(m_searchResultsWidget, TQT_SIGNAL(startURL(const TQString&)), TQT_SLOT(slotStartURL(const TQString&)));
connect(m_searchResultsWidget, TQT_SIGNAL(rightButtonPressed( TQListViewItem*, const TQPoint &, int )), TQT_SLOT(slotContextMenuRequested( TQListViewItem*, const TQPoint &, int )));
connect(m_recentlyView, TQT_SIGNAL(startService(KService::Ptr)), TQT_SLOT(slotStartService(KService::Ptr)));
connect(m_recentlyView, TQT_SIGNAL(startURL(const TQString&)), TQT_SLOT(slotStartURL(const TQString&)));
connect(m_recentlyView, TQT_SIGNAL(rightButtonPressed( TQListViewItem*, const TQPoint &, int )), TQT_SLOT(slotContextMenuRequested( TQListViewItem*, const TQPoint &, int )));
connect(m_favoriteView, TQT_SIGNAL(startService(KService::Ptr)), TQT_SLOT(slotStartService(KService::Ptr)));
connect(m_favoriteView, TQT_SIGNAL(startURL(const TQString&)), TQT_SLOT(slotStartURL(const TQString&)));
connect(m_favoriteView, TQT_SIGNAL(rightButtonPressed( TQListViewItem*, const TQPoint &, int )), TQT_SLOT(slotContextMenuRequested( TQListViewItem*, const TQPoint &, int )));
connect(m_favoriteView, TQT_SIGNAL(moved(TQListViewItem*, TQListViewItem*, TQListViewItem*)), TQT_SLOT(slotFavoritesMoved( TQListViewItem*, TQListViewItem*, TQListViewItem* )));
connect(m_systemView, TQT_SIGNAL(startURL(const TQString&)), TQT_SLOT(slotStartURL(const TQString&)));
connect(m_systemView, TQT_SIGNAL(startService(KService::Ptr)), TQT_SLOT(slotStartService(KService::Ptr)));
connect(m_systemView, TQT_SIGNAL(rightButtonPressed( TQListViewItem*, const TQPoint &, int )), TQT_SLOT(slotContextMenuRequested( TQListViewItem*, const TQPoint &, int )));
connect(m_browserView, TQT_SIGNAL(startURL(const TQString&)), TQT_SLOT(slotGoSubMenu(const TQString&)));
connect(m_browserView, TQT_SIGNAL(startService(KService::Ptr)), TQT_SLOT(slotStartService(KService::Ptr)));
connect(m_browserView, TQT_SIGNAL(rightButtonPressed( TQListViewItem*, const TQPoint &, int )), TQT_SLOT(slotContextMenuRequested( TQListViewItem*, const TQPoint &, int )));
connect(m_exitView, TQT_SIGNAL(startURL(const TQString&)), TQT_SLOT(slotStartURL(const TQString&)));
connect(m_exitView, TQT_SIGNAL(rightButtonPressed( TQListViewItem*, const TQPoint &, int )), TQT_SLOT(slotContextMenuRequested( TQListViewItem*, const TQPoint &, int )));
m_kcommand->setDuplicatesEnabled( false );
m_kcommand->setLineEdit(new KLineEdit(m_kcommand, "m_kcommand-lineedit"));
m_kcommand->setCompletionMode( TDEGlobalSettings::CompletionAuto );
connect(m_kcommand, TQT_SIGNAL(cleared()), TQT_SLOT(clearedHistory()));
connect(m_kcommand->lineEdit(), TQT_SIGNAL(returnPressed()), TQT_SLOT(searchAccept()));
connect(m_kcommand->lineEdit(), TQT_SIGNAL(textChanged(const TQString &)), TQT_SLOT(searchChanged(const TQString &)));
// 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 TQTimer (this, "input_timer");
connect( input_timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(doQuery()) );
init_search_timer = new TQTimer (this, "init_search_timer");
connect( init_search_timer, TQT_SIGNAL(timeout()), this, TQT_SLOT(initSearch()) );
init_search_timer->start(2000, true);
connect( m_favoriteView, TQT_SIGNAL( dropped (TQDropEvent *, TQListViewItem * ) ),
TQT_SLOT( slotFavDropped( TQDropEvent *, TQListViewItem * ) ) );
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 = TQRegExp("^([\\w\\-]+\\.)*[\\w\\-]+@([\\w\\-]+\\.)*[\\w\\-]+$");
authRegExp = TQRegExp("^[a-zA-Z]+://\\w+(:\\w+)?@([\\w\\-]+\\.)*[\\w\\-]+(:\\d+)?(/.*)?$");
uriRegExp = TQRegExp("^[a-zA-Z]+://([\\w\\-]+\\.)*[\\w\\-]+(:\\d+)?(/.*)?$");
uri2RegExp = TQRegExp("^([\\w\\-]+\\.)+[\\w\\-]+(:\\d+)?(/.*)?$");
m_resizeHandle = new TQLabel(this);
m_resizeHandle->setBackgroundOrigin( TQLabel::ParentOrigin );
m_resizeHandle->setScaledContents(true);
m_resizeHandle->setFixedSize( 16, 16 );
m_searchFrame->stackUnder( m_resizeHandle );
m_isresizing = false;
m_searchPixmap->setPixmap( BarIcon( "find", 32 ) );
TQFont 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" ) );
#ifdef COMPILE_HALBACKEND
m_halCtx = NULL;
m_halCtx = libhal_ctx_new();
DBusError error;
dbus_error_init(&error);
m_dbusConn = dbus_connection_open_private(DBUS_SYSTEM_BUS, &error);
if (!m_dbusConn) {
dbus_error_free(&error);
libhal_ctx_free(m_halCtx);
m_halCtx = NULL;
} else {
dbus_bus_register(m_dbusConn, &error);
if (dbus_error_is_set(&error)) {
dbus_error_free(&error);
libhal_ctx_free(m_halCtx);
m_dbusConn = NULL;
m_halCtx = NULL;
} else {
libhal_ctx_set_dbus_connection(m_halCtx, m_dbusConn);
if (!libhal_ctx_init(m_halCtx, &error)) {
if (dbus_error_is_set(&error)) {
dbus_error_free(&error);
}
libhal_ctx_free(m_halCtx);
m_dbusConn = NULL;
m_halCtx = NULL;
}
}
}
#endif
}
void KMenu::setupUi()
{
m_stacker = new TQWidgetStack( this, "m_stacker" );
m_stacker->setGeometry( TQRect( 90, 260, 320, 220 ) );
m_stacker->setSizePolicy( TQSizePolicy( (TQSizePolicy::SizeType)3, (TQSizePolicy::SizeType)3, 1, 1, m_stacker->sizePolicy().hasHeightForWidth() ) );
m_stacker->setPaletteBackgroundColor( TQColor( 255, 255, 255 ) );
// m_stacker->setFocusPolicy( TQ_StrongFocus );
m_stacker->setLineWidth( 0 );
m_stacker->setFocusPolicy(TQ_NoFocus);
connect(m_stacker, TQT_SIGNAL(aboutToShow(TQWidget*)), TQT_SLOT(stackWidgetRaised(TQWidget*)));
m_kcommand->setName("m_kcommand");
}
KMenu::~KMenu()
{
saveConfig();
clearSubmenus();
delete m_filterData;
#ifdef COMPILE_HALBACKEND
if (m_halCtx) {
DBusError error;
dbus_error_init(&error);
libhal_ctx_shutdown(m_halCtx, &error);
libhal_ctx_free(m_halCtx);
}
#endif
}
bool KMenu::eventFilter ( TQObject * receiver, TQEvent* e)
{
//kdDebug() << "eventFilter receiver=" << receiver->name() << " type=" << e->type() << endl;
TQWidget* raiseWidget = 0;
TQRect raiseRect;
if (e->type() == TQEvent::KeyPress ||
e->type() == TQEvent::MouseButtonPress ||
e->type() == TQEvent::MouseMove
|| e->type() == TQEvent::FocusIn
|| e->type() == TQEvent::Wheel) {
TQPoint p;
if (e->type() == TQEvent::MouseMove || e->type() == TQEvent::MouseButtonPress) {
TQMouseEvent* me = TQT_TQMOUSEEVENT(e);
p = me->globalPos();
}
else if (e->type() == TQEvent::Wheel) {
TQWheelEvent* we = TQT_TQWHEELEVENT(e);
p = we->globalPos();
}
while (receiver) {
if (TQT_BASE_OBJECT(receiver) == TQT_BASE_OBJECT(m_tabBar) && (e->type()!=TQEvent::MouseMove || KickerSettings::kickoffSwitchTabsOnHover() ) ) {
TQTab* 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 = TQRect( 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 ( (TQT_BASE_OBJECT(receiver) == TQT_BASE_OBJECT(m_searchPixmap) ||
( ( TQT_BASE_OBJECT(receiver) == TQT_BASE_OBJECT(m_searchLabel) || TQT_BASE_OBJECT(receiver)==TQT_BASE_OBJECT(m_kcommand->lineEdit()) ) &&
( e->type() == TQEvent::KeyPress || e->type() == TQEvent::Wheel
|| e->type() == TQEvent::MouseButtonPress ) ) ) &&
!m_isShowing) {
raiseWidget = m_searchWidget;
raiseRect = TQRect( m_searchFrame->mapToGlobal(m_searchFrame->rect().topLeft()),
m_searchFrame->size());
}
if(raiseWidget)
break;
if(receiver->isWidgetType())
receiver = TQT_TQOBJECT(TQT_TQWIDGET(receiver)->parentWidget(true));
else
break;
}
if (e->type() == TQEvent::FocusIn && receiver && raiseWidget) {
m_searchResultsWidget->setFocusPolicy(TQ_StrongFocus);
m_searchActions->setFocusPolicy(raiseWidget == m_searchWidget ?
TQ_StrongFocus : TQ_NoFocus);
setTabOrder(raiseWidget, m_searchResultsWidget);
if (raiseWidget != m_stacker->visibleWidget()
&& TQT_TQWIDGET(receiver)->focusPolicy() == TQ_NoFocus
&& m_stacker->id(raiseWidget) >= 0) {
m_stacker->raiseWidget(raiseWidget);
return true;
}
if (raiseWidget->focusPolicy() != TQ_NoFocus)
return false;
}
if (m_sloppyRegion.contains(p)) {
if (e->type() == TQEvent::MouseButtonPress /*&& m_sloppyTimer.isActive()*/)
m_sloppySourceClicked = true;
if (!m_sloppyTimer.isActive() || m_sloppySource != raiseRect) {
int timeout= style().styleHint(TQStyle::SH_PopupMenu_SubMenuPopupDelay);
if (m_sloppySourceClicked)
timeout = 3000;
m_sloppyTimer.start(timeout);
}
m_sloppyWidget = raiseWidget;
m_sloppySource = raiseRect;
return false;
}
}
if(e->type() == TQEvent::Enter && receiver->isWidgetType()) {
TQT_TQWIDGET(receiver)->setMouseTracking(true);
TQToolTip::hide();
}
if ( ( e->type() == TQEvent::DragEnter || e->type() == TQEvent::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() == TQEvent::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 (TQT_TQKEYEVENT(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() == TQEvent::Wheel && raiseWidget )
{
// due to an ugly TQt bug we have to kill wheel events
// that cause focus switches
r = true;
}
if (e->type() == TQEvent::Enter && TQT_BASE_OBJECT(receiver) == TQT_BASE_OBJECT(m_stacker))
{
TQRect r(m_stacker->mapToGlobal(TQPoint(-8,-32)), m_stacker->size());
r.setSize(r.size()+TQSize(16,128));
m_sloppyRegion = TQRegion(r);
}
// redo the sloppy region
if (e->type() == TQEvent::MouseMove && !r && raiseWidget)
{
TQPointArray points(4);
// hmm, eventually this should be mouse position + 10px, not
// just worst case. but worst case seems to work fine enough.
TQPoint 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+TQPoint(+raiseRect.width()/4,0));
points.setPoint(3, edge+TQPoint(-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+TQPoint(-raiseRect.width()/4,0));
points.setPoint(3, edge+TQPoint(+raiseRect.width()/4,0));
}
m_sloppyRegion = TQRegion(points);
}
return r;
}
void KMenu::slotSloppyTimeout()
{
if (m_sloppyRegion.contains(TQCursor::pos()) && !m_sloppySource.isNull())
{
if ( m_sloppySource.contains(TQCursor::pos()))
{
m_stacker->raiseWidget(m_sloppyWidget);
m_sloppyWidget = 0;
m_sloppySource = TQRect();
m_sloppyRegion = TQRegion();
m_sloppySourceClicked = false;
}
}
m_sloppyTimer.stop();
}
void KMenu::paintSearchTab( bool active )
{
TQPixmap canvas( m_searchFrame->size() );
TQPainter p( &canvas );
TQPixmap 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(TQWidget* raiseWidget)
{
paintSearchTab(raiseWidget == m_searchWidget);
if (raiseWidget == m_browserView) {
if ( m_tabBar->currentTab() == ApplicationsTab)
slotGoSubMenu(TQString());
if (m_browserDirty ) {
createNewProgramList();
m_browserView->prepareRightMove();
m_browserView->currentView()->clear();
fillSubMenu(TQString(), 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 TQtab 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<TQScrollView*>(raiseWidget))
// m_activeTab->setFocusProxy(static_cast<TQScrollView*>(raiseWidget)->viewport());
if (0 && /*raiseWidget == m_stacker->visibleWidget() &&*/ !raiseWidget->hasFocus()) {
if (dynamic_cast<TQScrollView*>(raiseWidget))
static_cast<TQScrollView*>(raiseWidget)->viewport()->setFocus();
else
raiseWidget->setFocus();
}
m_activeTab = frame;
m_sloppyRegion = TQRegion();
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(TQTab* t)
{
if (t==m_tabs[ApplicationsTab])
slotGoSubMenu(TQString());
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(TQString());
}
}
void KMenu::slotGoExitSubMenu(const TQString& url)
{
m_exitView->prepareRightMove();
m_exitView->showBackButton(true);
int nId = serviceMenuEndId() + 1;
int index = 1;
if (url=="kicker:/restart/") {
TQStringList rebootOptions;
int def, cur;
if ( DM().bootOptions( rebootOptions, def, cur ) )
{
if ( cur == -1 )
cur = def;
int boot_index = 0;
TQStringList::ConstIterator it = rebootOptions.begin();
for (; it != rebootOptions.end(); ++it, ++boot_index)
{
TQString 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 ),
TQString( "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++, TQString(), index++ );
for (SessList::ConstIterator it = sess.begin(); it != sess.end(); ++it) {
if ((*it).vt && !(*it).self) {
TQString user, loc;
DM().sess2Str2( *it, user, loc );
TQStringList list = TQStringList::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) , TQString("kicker:/switchuser_%1").arg((*it).vt), nId++, index++ );
}
}
}
m_exitView->rightView()->insertHeader( nId++, "kicker:/switchuser/" );
}
m_exitView->flipScroll(TQString());
}
void KMenu::slotGoSubMenu(const TQString& relPath)
{
goSubMenu(relPath);
}
void KMenu::goSubMenu(const TQString& relPath, bool keyboard)
{
if ( relPath.startsWith( "kicker:/goup/" ) )
{
TQString 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;
TQString currel = rel;
rel = rel.left( index + 1 );
if ( rel == "/" )
rel = TQString();
kdDebug() << "goup, rel '" << rel << "' " << rel.isEmpty() << endl;
fillSubMenu( rel, m_browserView->prepareLeftMove() );
m_browserView->flipScroll(keyboard ? currel : TQString());
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 (TQStringList::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/": TQString());
}
void KMenu::fillSubMenu(const TQString& 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" ),
TQString(), "kicker:/new/", nId++, -1 );
item->setHasChildren( true );
view->insertSeparator( nId++, TQString(), -1 );
}
view->path = relPath;
fillMenu (root, list, relPath, view, nId);
}
void KMenu::fillMenu(KServiceGroup::Ptr&
#ifdef KDELIBS_SUSE
_root
#endif
, KServiceGroup::List& _list,
const TQString& _relPath,
ItemView* view,
int& id)
{
bool separatorNeeded = false;
KServiceGroup::List::ConstIterator it = _list.begin();
#ifdef KDELIBS_SUSE
KSortableValueList<TDESharedPtr<KSycocaEntry>,TQCString> slist;
KSortableValueList<TDESharedPtr<KSycocaEntry>,TQCString> glist;
TQMap<TQString,TQString> specialTitle;
TQMap<TQString,TQString> categoryIcon;
TQMap<TQString,TQString> 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));
TQString 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
TQString 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;
TQString 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, TQString(), 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);
TQIconSet 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 TQt docs.)
subMenus.append(m);
#endif
}
if (e->isType(KST_KService))
{
KService::Ptr s(static_cast<KService *>(e));
if (_relPath.isEmpty()) {
TQStringList favs = KickerSettings::favorites();
if (favs.find(s->storageId())!=favs.end())
continue;
}
#ifdef KDELIBS_SUSE
KMenuItem *item = view->insertMenuItem(s, id++, -1, 0, TQString(), 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, TQT_SIGNAL(tdedisplayPaletteChanged()),
this, TQT_SLOT(paletteChanged()));
connect(kapp, TQT_SIGNAL(tdedisplayPaletteChanged()),
this, TQT_SLOT(paletteChanged()));
/*
If the user configured ksmserver to
*/
TDEConfig ksmserver("ksmserverrc", false, false);
ksmserver.setGroup("General");
connect( m_branding, TQT_SIGNAL(clicked()), TQT_SLOT(slotOpenHomepage()));
m_tabBar->setTabEnabled(LeaveTab, kapp->authorize("logout"));
// load search field history
TQStringList 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 );
TQStringList compList = KickerSettings::completionItems();
if( compList.isEmpty() )
m_kcommand->completionObject()->setItems( histList );
else
m_kcommand->completionObject()->setItems( compList );
TDECompletionBox* 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");
TQStringList favs = KickerSettings::favorites();
if (favs.isEmpty()) {
TQFile f(locate("data", "kicker/default-favs"));
if (f.open(IO_ReadOnly)) {
TQTextStream is(&f);
while (!is.eof())
favs << is.readLine();
f.close();
}
KickerSettings::setFavorites(favs);
KickerSettings::writeConfig();
}
int nId = serviceMenuEndId() + 1;
int index = 1;
for (TQStringList::ConstIterator it = favs.begin(); it != favs.end(); ++it)
{
if ((*it)[0]=='/') {
KDesktopFile df((*it),true);
TQString url = df.readURL();
if (!KURL(url).isLocalFile() || TQFile::exists(url.replace("file://",TQString())))
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, TQString(), 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++ );
TDEConfig 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;
TQStringList 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++);
#ifdef KICKOFF_DIST_CONFIG_SHORTCUT1
KService::Ptr kdcs1 = KService::serviceByStorageId(KICKOFF_DIST_CONFIG_SHORTCUT1);
m_systemView->insertMenuItem(kdcs1, nId++, index++);
#endif
#ifdef KICKOFF_DIST_CONFIG_SHORTCUT2
KService::Ptr kdcs2 = KService::serviceByStorageId(KICKOFF_DIST_CONFIG_SHORTCUT2);
m_systemView->insertMenuItem(kdcs2, nId++, index++);
#endif
KService::Ptr p = KService::serviceByStorageId("KControl.desktop");
m_systemView->insertMenuItem(p, nId++, index++);
// run command
if (kapp->authorize("run_command"))
{
m_systemView->insertItem( "run", i18n("Run Command..."),
"", "kicker:/runusercommand", nId++, index++ );
}
m_systemView->insertSeparator( nId++, i18n("System Folders"), index++ );
m_systemView->insertItem( "folder_home", i18n( "Home Folder" ),
TQDir::homeDirPath(), "file://"+TQDir::homeDirPath(), nId++, index++ );
if ( TDEStandardDirs::exists( TDEGlobalSettings::documentPath() + "/" ) )
{
TQString documentPath = TDEGlobalSettings::documentPath();
if ( documentPath.endsWith( "/" ) )
documentPath = documentPath.left( documentPath.length() - 1 );
if (documentPath!=TQDir::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( TQT_TQOBJECT(this) );
connect( m_mediaWatcher, TQT_SIGNAL( mediumChanged() ), TQT_SLOT( updateMedia() ) );
m_media_id = 0;
connect(&m_mediaFreeTimer, TQT_SIGNAL(timeout()), TQT_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();
TQCString appname( "kdesktop" );
if ( kicker_screen_number )
appname.sprintf("kdesktop-screen-%d", kicker_screen_number);
kapp->dcopClient()->send(appname, "KScreensaverIface", "lock()", TQString(""));
}
void KMenu::slotOpenHomepage()
{
accept();
kapp->invokeBrowser("http://www.trinitydesktop.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(
TQT_TQWIDGET(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 TDE 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()
{
TQString 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 )
{
TQCString appname( "kdesktop" );
int kicker_screen_number = tqt_xscreen();
if ( kicker_screen_number )
appname.sprintf("kdesktop-screen-%d", kicker_screen_number);
kapp->dcopClient()->send(appname, "KScreensaverIface", "lock()", TQString(""));
}
}
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 );
TQString cmd;
KURL uri = m_filterData->uri();
if ( uri.isLocalFile() && !uri.hasRef() && uri.query().isEmpty() )
cmd = uri.path();
else
cmd = uri.url();
TQString 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( TQStyleSheet::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( TQStyleSheet::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)
{
TQPoint center = kButton->center();
TQRect screen = TQApplication::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 = TQToolTip::isGloballyEnabled();
TQToolTip::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 ? tqsizeBDiagCursor : tqsizeFDiagCursor);
TQPixmap 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
? TQTabBar::RoundedBelow : TQTabBar::RoundedAbove);
TQPixmap respix = TQPixmap( locate("data", "kicker/pics/resize_handle.png" ) );
if ( m_orientation == TopDown ) {
TQWMatrix m;
m.rotate( 90.0 );
respix=respix.xForm(m);
}
m_resizeHandle->setPixmap(respix);
{
TQWidget *footer = m_footer->mainWidget();
TQPixmap pix( 64, footer->height() );
TQPainter p( &pix );
p.fillRect( 0, 0, 64, footer->height(), m_branding->colorGroup().brush( TQColorGroup::Base ) );
p.end();
footer->setPaletteBackgroundPixmap( pix );
}
resizeEvent(new TQResizeEvent(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();
TQToolTip::setGloballyEnabled(m_toolTipsEnabled);
// remove focus from lineedit again, otherwise it doesn't kill its timers
m_stacker->raiseWidget(FavoriteTab);
TQWidget::hide();
}
void KMenu::paintEvent(TQPaintEvent * e)
{
KMenuBase::paintEvent(e);
TQPainter p(this);
p.setClipRegion(e->region());
const BackgroundMode bgmode = backgroundMode();
const TQColorGroup::ColorRole crole = TQPalette::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 );
TQStringList 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 (TQValueList<TQString>::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 );
TQStringList fileList = TDERecentDocument::recentDocuments();
kdDebug() << "createRecentMenuItems=" << fileList << endl;
for (TQStringList::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 (TQApplication::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 TQPoint&, int)
{
showMenu();
}
void KMenu::clearRecentAppsItems()
{
RecentlyLaunchedApps::the().clearRecentApps();
RecentlyLaunchedApps::the().save();
RecentlyLaunchedApps::the().m_bNeedToUpdate = true;
updateRecent();
}
void KMenu::clearRecentDocsItems()
{
TDERecentDocument::clear();
updateRecent();
}
void KMenu::searchChanged(const TQString & text)
{
if (!text.isEmpty()) {
const TQColor on = TQColor( 244, 244, 244 );
const TQColor off = TQColor( 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 TQString& 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
TQChar 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 = TQDate::currentDate().toString(Qt::ISODate);
bool initialize = (m_seenPrograms.count() == 0);
createNewProgramList(TQString());
if (initialize) {
for (TQStringList::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(TQString 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() ) {
TQString shortStorageId = s->storageId().replace(".desktop",TQString());
TQStringList::Iterator it_find = m_seenPrograms.begin();
TQStringList::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)!="-") {
TQDate date = TQDate::fromString(*(it_find),Qt::ISODate);
if (date.daysTo(TQDate::currentDate())<3) {
if (m_newInstalledPrograms.find(s->storageId())==m_newInstalledPrograms.end())
m_newInstalledPrograms+=s->storageId();
}
else {
m_seenProgramsChanged=true;
(*it_find)="-";
}
}
}
}
}
}
}
}
void KMenu::searchProgramList(TQString 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;
TQString 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());
TQString 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(), TQString(), 0, APPS, s->icon(), score);
if (hit_item == NULL)
continue;
hit_item->service = s;
insertSearchResult(hit_item);
TQString exe = s->exec();
int pos = exe.find(' ');
if (pos>0)
exe=exe.left(pos);
m_programsInMenu+=TDEGlobal::dirs()->findExe(exe);
}
}