kio Library API Documentation

kurlbar.cpp

00001 /* This file is part of the KDE libraries
00002     Copyright (C) 2001,2002,2003 Carsten Pfeiffer <pfeiffer@kde.org>
00003 
00004     library is free software; you can redistribute it and/or
00005     modify it under the terms of the GNU Library General Public
00006     License as published by the Free Software Foundation, version 2.
00007 
00008     This library is distributed in the hope that it will be useful,
00009     but WITHOUT ANY WARRANTY; without even the implied warranty of
00010     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00011     Library General Public License for more details.
00012 
00013     You should have received a copy of the GNU Library General Public License
00014     along with this library; see the file COPYING.LIB.  If not, write to
00015     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
00016     Boston, MA 02111-1307, USA.
00017 */
00018 
00019 #include <unistd.h>
00020 
00021 #include <qcheckbox.h>
00022 #include <qdrawutil.h>
00023 #include <qfontmetrics.h>
00024 #include <qlabel.h>
00025 #include <qgrid.h>
00026 #include <qpainter.h>
00027 #include <qpopupmenu.h>
00028 #include <qvbox.h>
00029 #include <qwhatsthis.h>
00030 
00031 #include <kaboutdata.h>
00032 #include <kconfig.h>
00033 #include <kdebug.h>
00034 #include <kglobal.h>
00035 #include <kicondialog.h>
00036 #include <kiconloader.h>
00037 #include <kinstance.h>
00038 #include <klineedit.h>
00039 #include <klocale.h>
00040 #include <kmimetype.h>
00041 #include <kprotocolinfo.h>
00042 #include <kstringhandler.h>
00043 #include <kurldrag.h>
00044 #include <kurlrequester.h>
00045 #include <kstandarddirs.h>
00046 #include "kurlbar.h"
00047 
00052 class KURLBarToolTip : public QToolTip
00053 {
00054 public:
00055     KURLBarToolTip( QListBox *view ) : QToolTip( view ), m_view( view ) {}
00056 
00057 protected:
00058     virtual void maybeTip( const QPoint& point ) {
00059         QListBoxItem *item = m_view->itemAt( point );
00060         if ( item ) {
00061             QString text = static_cast<KURLBarItem*>( item )->toolTip();
00062             if ( !text.isEmpty() )
00063                 tip( m_view->itemRect( item ), text );
00064         }
00065     }
00066 
00067 private:
00068     QListBox *m_view;
00069 };
00070 
00071 
00074 
00075 class KURLBarItem::KURLBarItemPrivate
00076 {
00077 public:
00078     KURLBarItemPrivate()
00079     {
00080         isPersistent = true;
00081     }
00082 
00083     bool isPersistent;
00084 };
00085 
00086 KURLBarItem::KURLBarItem( KURLBar *parent,
00087                           const KURL& url, bool persistent, const QString& description,
00088                           const QString& icon, KIcon::Group group )
00089     : QListBoxPixmap( KIconLoader::unknown() /*, parent->listBox()*/ ),
00090       m_url( url ),
00091       m_pixmap( 0L ),
00092       m_parent( parent ),
00093       m_appLocal( false )
00094 {
00095     init( icon, group, description, persistent );
00096 }
00097 
00098 KURLBarItem::KURLBarItem( KURLBar *parent,
00099                           const KURL& url, const QString& description,
00100                           const QString& icon, KIcon::Group group )
00101     : QListBoxPixmap( KIconLoader::unknown() /*, parent->listBox()*/ ),
00102       m_url( url ),
00103       m_pixmap( 0L ),
00104       m_parent( parent ),
00105       m_appLocal( false )
00106 {
00107     init( icon, group, description, true /*persistent*/ );
00108 }
00109 
00110 void KURLBarItem::init( const QString& icon, KIcon::Group group,
00111                         const QString& description, bool persistent )
00112 {
00113     d = new KURLBarItemPrivate;
00114     d->isPersistent = persistent;
00115 
00116     setCustomHighlighting( true );
00117     setIcon( icon, group );
00118     setDescription( description );
00119 }
00120 
00121 KURLBarItem::~KURLBarItem()
00122 {
00123     delete d;
00124 }
00125 
00126 void KURLBarItem::setURL( const KURL& url )
00127 {
00128     m_url = url;
00129     if ( m_description.isEmpty() )
00130         setText( url.fileName() );
00131 }
00132 
00133 void KURLBarItem::setIcon( const QString& icon, KIcon::Group group )
00134 {
00135     m_icon  = icon;
00136     m_group = group;
00137 
00138     if ( icon.isEmpty() )
00139         m_pixmap = KMimeType::pixmapForURL( m_url, 0, group, iconSize() );
00140     else
00141         m_pixmap = KGlobal::iconLoader()->loadIcon( icon, group, iconSize(),
00142                                                     KIcon::DefaultState );
00143 }
00144 
00145 void KURLBarItem::setDescription( const QString& desc )
00146 {
00147     m_description = desc;
00148     setText( desc.isEmpty() ? m_url.fileName() : desc );
00149 }
00150 
00151 void KURLBarItem::setApplicationLocal( bool local )
00152 {
00153     if ( !local && !isPersistent() )
00154     {
00155         kdWarning() << "KURLBar: dynamic (non-persistent) items can not be global." << endl;
00156         return;
00157     }
00158 
00159     m_appLocal = local;
00160 }
00161 
00162 void KURLBarItem::setToolTip( const QString& tip )
00163 {
00164     m_toolTip = tip;
00165 }
00166 
00167 QString KURLBarItem::toolTip() const
00168 {
00169     return m_toolTip.isEmpty() ? m_url.prettyURL() : m_toolTip;
00170 }
00171 
00172 int KURLBarItem::iconSize() const
00173 {
00174     return m_parent->iconSize();
00175 }
00176 
00177 void KURLBarItem::paint( QPainter *p )
00178 {
00179     QListBox *box = listBox();
00180     int w = width( box );
00181     static const int margin = KDialog::spacingHint();
00182 
00183     if ( m_parent->iconSize() < KIcon::SizeMedium ) {
00184         // small icon -> draw icon next to text
00185 
00186         // ### mostly cut & paste of QListBoxPixmap::paint() until Qt 3.1
00187         // (where it will properly use pixmap() instead of the internal pixmap)
00188         const QPixmap *pm = pixmap();
00189         int yPos = QMAX( 0, (height(box) - pm->height())/2 );
00190 
00191         p->drawPixmap( margin, yPos, *pm );
00192         if ( !text().isEmpty() ) {
00193             QFontMetrics fm = p->fontMetrics();
00194             if ( pm->height() < fm.height() )
00195                 yPos = fm.ascent() + fm.leading()/2;
00196             else
00197                 yPos = pm->height()/2 - fm.height()/2 + fm.ascent();
00198 
00199             yPos += margin;
00200             int stringWidth = box->width() - pm->width() - 2 - (margin * 2);
00201             QString visibleText = KStringHandler::rPixelSqueeze( text(), fm, stringWidth );
00202             p->drawText( pm->width() + margin + 2, yPos, visibleText );
00203         }
00204         // end cut & paste (modulo pixmap centering)
00205     }
00206 
00207     else {
00208         // big icons -> draw text below icon
00209         int y = margin;
00210         const QPixmap *pm = pixmap();
00211 
00212         if ( !pm->isNull() ) {
00213             int x = (w - pm->width()) / 2;
00214             x = QMAX( x, margin );
00215             p->drawPixmap( x, y, *pm );
00216         }
00217 
00218         if ( !text().isEmpty() ) {
00219             QFontMetrics fm = p->fontMetrics();
00220             y += pm->height() + fm.height() - fm.descent();
00221 
00222             int stringWidth = box->width() - (margin * 2);
00223             QString visibleText = KStringHandler::rPixelSqueeze( text(), fm, stringWidth );
00224             int x = (w - fm.width( visibleText )) / 2;
00225             x = QMAX( x, margin );
00226 
00227             p->drawText( x, y, visibleText );
00228         }
00229     }
00230 
00231     // draw sunken selection
00232     if ( isCurrent() || isSelected() ) {
00233         qDrawShadePanel( p, 1, 0, w -2, height(box),
00234                          box->colorGroup(), true, 1, 0L );
00235     }
00236 }
00237 
00238 QSize KURLBarItem::sizeHint() const
00239 {
00240     int wmin = 0;
00241     int hmin = 0;
00242     const KURLBarListBox *lb =static_cast<const KURLBarListBox*>(listBox());
00243 
00244     if ( m_parent->iconSize() < KIcon::SizeMedium ) {
00245         wmin = QListBoxPixmap::width( lb ) + KDialog::spacingHint() * 2;
00246         hmin = QListBoxPixmap::height( lb ) + KDialog::spacingHint() * 2;
00247     }
00248     else {
00249         wmin = QMAX(lb->fontMetrics().width(text()), pixmap()->width()) + KDialog::spacingHint() * 2;
00250         hmin = lb->fontMetrics().lineSpacing() + pixmap()->height() + KDialog::spacingHint() * 2;
00251     }
00252 
00253     if ( lb->isVertical() )
00254         wmin = QMIN( wmin, lb->viewport()->sizeHint().width() );
00255     else
00256         hmin = QMIN( hmin, lb->viewport()->sizeHint().height() );
00257 
00258     return QSize( wmin, hmin );
00259 }
00260 
00261 int KURLBarItem::width( const QListBox *lb ) const
00262 {
00263     if ( static_cast<const KURLBarListBox *>( lb )->isVertical() )
00264         return QMAX( sizeHint().width(), lb->viewport()->width() );
00265     else
00266         return sizeHint().width();
00267 }
00268 
00269 int KURLBarItem::height( const QListBox *lb ) const
00270 {
00271     if ( static_cast<const KURLBarListBox *>( lb )->isVertical() )
00272         return sizeHint().height();
00273     else
00274         return QMAX( sizeHint().height(), lb->viewport()->height() );
00275 }
00276 
00277 bool KURLBarItem::isPersistent() const
00278 {
00279     return d->isPersistent;
00280 }
00281 
00284 
00285 class KURLBar::KURLBarPrivate
00286 {
00287 public:
00288     KURLBarPrivate()
00289     {
00290         currentURL.setPath( QDir::homeDirPath() );
00291     }
00292 
00293     KURL currentURL;
00294 };
00295 
00296 
00297 KURLBar::KURLBar( bool useGlobalItems, QWidget *parent, const char *name, WFlags f )
00298     : QFrame( parent, name, f ),
00299       m_activeItem( 0L ),
00300       m_useGlobal( useGlobalItems ),
00301       m_isModified( false ),
00302       m_isImmutable( false ),
00303       m_listBox( 0L ),
00304       m_iconSize( KIcon::SizeMedium )
00305 {
00306     d = new KURLBarPrivate();
00307 
00308     setListBox( 0L );
00309     setSizePolicy( QSizePolicy( isVertical() ?
00310                                 QSizePolicy::Maximum :
00311                                 QSizePolicy::Preferred,
00312                                 isVertical() ?
00313                                 QSizePolicy::Preferred :
00314                                 QSizePolicy::Maximum ));
00315     QWhatsThis::add(this, i18n("<qt>The <b>Quick Access</b> panel provides easy access to commonly used file locations.<p>"
00316                                "Clicking on one of the shortcut entries will take you to that location.<p>"
00317                                "By right clicking on an entry you can add, edit and remove shortcuts.</qt>"));
00318 }
00319 
00320 KURLBar::~KURLBar()
00321 {
00322     delete d;
00323 }
00324 
00325 KURLBarItem * KURLBar::insertItem(const KURL& url, const QString& description,
00326                                   bool applicationLocal,
00327                                   const QString& icon, KIcon::Group group )
00328 {
00329 // UGLY HACK, devices:/ and lan:/ don't work in dir selection dialog, better not show it
00330 if ((url.protocol() == "devices") || (url.protocol() == "lan"))
00331 {
00332   QObject *obj = topLevelWidget();
00333   if (obj && (qstrcmp(obj->className(), "KDirSelectDialog") == 0))
00334      return 0;
00335 }
00336 // END UGLY HACK
00337 
00338     KURLBarItem *item = new KURLBarItem(this, url, description, icon, group);
00339     item->setApplicationLocal( applicationLocal );
00340     m_listBox->insertItem( item );
00341     return item;
00342 }
00343 
00344 KURLBarItem * KURLBar::insertDynamicItem(const KURL& url, const QString& description,
00345                                          const QString& icon, KIcon::Group group )
00346 {
00347     KURLBarItem *item = new KURLBarItem(this, url, false, description, icon, group);
00348     m_listBox->insertItem( item );
00349     return item;
00350 }
00351 
00352 void KURLBar::setOrientation( Qt::Orientation orient )
00353 {
00354     m_listBox->setOrientation( orient );
00355     setSizePolicy( QSizePolicy( isVertical() ?
00356                                 QSizePolicy::Maximum :
00357                                 QSizePolicy::Preferred,
00358                                 isVertical() ?
00359                                 QSizePolicy::Preferred :
00360                                 QSizePolicy::Maximum ));
00361 }
00362 
00363 Qt::Orientation KURLBar::orientation() const
00364 {
00365     return m_listBox->orientation();
00366 }
00367 
00368 void KURLBar::setListBox( KURLBarListBox *view )
00369 {
00370     delete m_listBox;
00371 
00372     if ( !view ) {
00373         m_listBox = new KURLBarListBox( this, "urlbar listbox" );
00374         setOrientation( Vertical );
00375     }
00376     else {
00377         m_listBox = view;
00378         if ( m_listBox->parentWidget() != this )
00379             m_listBox->reparent( this, QPoint(0,0) );
00380         m_listBox->resize( width(), height() );
00381     }
00382 
00383     m_listBox->setSelectionMode( KListBox::Single );
00384     QPalette pal = palette();
00385     QColor gray = pal.color( QPalette::Normal, QColorGroup::Mid );
00386     QColor selectedTextColor = pal.color( QPalette::Normal, QColorGroup::BrightText );
00387     pal.setColor( QPalette::Normal,   QColorGroup::Base, gray );
00388     pal.setColor( QPalette::Normal,   QColorGroup::HighlightedText, selectedTextColor );
00389     pal.setColor( QPalette::Inactive, QColorGroup::Base, gray );
00390     pal.setColor( QPalette::Inactive, QColorGroup::HighlightedText, selectedTextColor );
00391 
00392     setPalette( pal );
00393     m_listBox->viewport()->setBackgroundMode( PaletteMid );
00394     m_listBox->setFocusPolicy( TabFocus );
00395 
00396     connect( m_listBox, SIGNAL( mouseButtonClicked( int, QListBoxItem *, const QPoint & ) ),
00397              SLOT( slotSelected( int, QListBoxItem * )));
00398     connect( m_listBox, SIGNAL( dropped( QDropEvent * )),
00399              this, SLOT( slotDropped( QDropEvent * )));
00400     connect( m_listBox, SIGNAL( contextMenuRequested( QListBoxItem *,
00401                                                       const QPoint& )),
00402              SLOT( slotContextMenuRequested( QListBoxItem *, const QPoint& )));
00403     connect( m_listBox, SIGNAL( returnPressed( QListBoxItem * ) ),
00404              SLOT( slotSelected( QListBoxItem * ) ));
00405 }
00406 
00407 void KURLBar::setIconSize( int size )
00408 {
00409     if ( size == m_iconSize )
00410         return;
00411 
00412     m_iconSize = size;
00413 
00414     // reload the icons with the new size
00415     KURLBarItem *item = static_cast<KURLBarItem*>( m_listBox->firstItem() );
00416     while ( item ) {
00417         item->setIcon( item->icon(), item->iconGroup() );
00418         item = static_cast<KURLBarItem*>( item->next() );
00419     }
00420 
00421     resize( sizeHint() );
00422     updateGeometry();
00423 }
00424 
00425 void KURLBar::clear()
00426 {
00427     m_listBox->clear();
00428 }
00429 
00430 void KURLBar::resizeEvent( QResizeEvent *e )
00431 {
00432     QFrame::resizeEvent( e );
00433     m_listBox->resize( width(), height() );
00434 }
00435 
00436 QSize KURLBar::sizeHint() const
00437 {
00438     return m_listBox->sizeHint();
00439 
00440 #if 0
00441     // this code causes vertical and or horizontal scrollbars appearing
00442     // depending on the text, font, moonphase and earth rotation. Just using
00443     // m_listBox->sizeHint() fixes this (although the widget can then be
00444     // resized to a smaller size so that scrollbars appear).
00445     int w = 0;
00446     int h = 0;
00447     KURLBarItem *item;
00448     bool vertical = isVertical();
00449 
00450     for ( item = static_cast<KURLBarItem*>( m_listBox->firstItem() );
00451           item;
00452           item = static_cast<KURLBarItem*>( item->next() ) ) {
00453 
00454         QSize sh = item->sizeHint();
00455 
00456         if ( vertical ) {
00457             w = QMAX( w, sh.width() );
00458             h += sh.height();
00459         }
00460         else {
00461             w += sh.width();
00462             h = QMAX( h, sh.height() );
00463         }
00464     }
00465 
00466 //     if ( vertical && m_listBox->verticalScrollBar()->isVisible() )
00467 //         w += m_listBox->verticalScrollBar()->width();
00468 //     else if ( !vertical && m_listBox->horizontalScrollBar()->isVisible() )
00469 //         h += m_listBox->horizontalScrollBar()->height();
00470 
00471     if ( w == 0 && h == 0 )
00472         return QSize( 100, 200 );
00473     else
00474         return QSize( 6 + w, h );
00475 #endif
00476 }
00477 
00478 QSize KURLBar::minimumSizeHint() const
00479 {
00480     QSize s = sizeHint(); // ###
00481     int w = s.width()  + m_listBox->verticalScrollBar()->width();
00482     int h = s.height() + m_listBox->horizontalScrollBar()->height();
00483     return QSize( w, h );
00484 }
00485 
00486 void KURLBar::slotSelected( int button, QListBoxItem *item )
00487 {
00488     if ( button != Qt::LeftButton )
00489         return;
00490 
00491     slotSelected( item );
00492 }
00493 
00494 void KURLBar::slotSelected( QListBoxItem *item )
00495 {
00496     if ( item && item != m_activeItem )
00497         m_activeItem = static_cast<KURLBarItem*>( item );
00498 
00499     if ( m_activeItem ) {
00500         m_listBox->setCurrentItem( m_activeItem );
00501         emit activated( m_activeItem->url() );
00502     }
00503 }
00504 
00505 void KURLBar::setCurrentItem( const KURL& url )
00506 {
00507     d->currentURL = url;
00508 
00509     QString u = url.url(-1);
00510 
00511     if ( m_activeItem && m_activeItem->url().url(-1) == u )
00512         return;
00513 
00514     bool hasURL = false;
00515     QListBoxItem *item = m_listBox->firstItem();
00516     while ( item ) {
00517         if ( static_cast<KURLBarItem*>( item )->url().url(-1) == u ) {
00518             m_activeItem = static_cast<KURLBarItem*>( item );
00519             m_listBox->setCurrentItem( item );
00520             m_listBox->setSelected( item, true );
00521             hasURL = true;
00522             break;
00523         }
00524         item = item->next();
00525     }
00526 
00527     if ( !hasURL ) {
00528         m_activeItem = 0L;
00529         m_listBox->clearSelection();
00530     }
00531 }
00532 
00533 KURLBarItem * KURLBar::currentItem() const
00534 {
00535     QListBoxItem *item = m_listBox->item( m_listBox->currentItem() );
00536     if ( item )
00537         return static_cast<KURLBarItem *>( item );
00538     return 0L;
00539 }
00540 
00541 KURL KURLBar::currentURL() const
00542 {
00543     KURLBarItem *item = currentItem();
00544     return item ? item->url() : KURL();
00545 }
00546 
00547 void KURLBar::readConfig( KConfig *appConfig, const QString& itemGroup )
00548 {
00549     m_isImmutable = appConfig->groupIsImmutable( itemGroup );
00550     KConfigGroupSaver cs( appConfig, itemGroup );
00551     m_iconSize = appConfig->readNumEntry( "Speedbar IconSize", m_iconSize );
00552 
00553     if ( m_useGlobal ) { // read global items
00554         KConfig *globalConfig = KGlobal::config();
00555         KConfigGroupSaver cs( globalConfig, (QString)(itemGroup +" (Global)"));
00556         int num = globalConfig->readNumEntry( "Number of Entries" );
00557         for ( int i = 0; i < num; i++ ) {
00558             readItem( i, globalConfig, false );
00559         }
00560     }
00561 
00562     // read application local items
00563     int num = appConfig->readNumEntry( "Number of Entries" );
00564     for ( int i = 0; i < num; i++ ) {
00565         readItem( i, appConfig, true );
00566     }
00567 }
00568 
00569 void KURLBar::readItem( int i, KConfig *config, bool applicationLocal )
00570 {
00571     QString number = QString::number( i );
00572     KURL url = KURL::fromPathOrURL( config->readPathEntry( QString("URL_") + number ));
00573     if ( !url.isValid() || !KProtocolInfo::isKnownProtocol( url ))
00574         return; // nothing we could do.
00575 
00576     insertItem( url,
00577                 config->readEntry( QString("Description_") + number ),
00578                 applicationLocal,
00579                 config->readEntry( QString("Icon_") + number ),
00580                 static_cast<KIcon::Group>(
00581                     config->readNumEntry( QString("IconGroup_") + number )) );
00582 }
00583 
00584 void KURLBar::writeConfig( KConfig *config, const QString& itemGroup )
00585 {
00586     KConfigGroupSaver cs1( config, itemGroup );
00587     config->writeEntry( "Speedbar IconSize", m_iconSize );
00588 
00589     if ( !m_isModified )
00590         return;
00591 
00592     int i = 0;
00593     int numLocal = 0;
00594     KURLBarItem *item = static_cast<KURLBarItem*>( m_listBox->firstItem() );
00595 
00596     while ( item )
00597     {
00598         if ( item->isPersistent() ) // we only save persistent items
00599         {
00600             if ( item->applicationLocal() )
00601             {
00602                 writeItem( item, numLocal, config, false );
00603                 numLocal++;
00604             }
00605 
00606             i++;
00607         }
00608         item = static_cast<KURLBarItem*>( item->next() );
00609     }
00610     config->writeEntry("Number of Entries", numLocal);
00611 
00612 
00613     // write the global entries to kdeglobals, if any
00614     bool haveGlobalEntries = (i > numLocal);
00615     if ( m_useGlobal && haveGlobalEntries ) {
00616         config->setGroup( itemGroup + " (Global)" );
00617 
00618         int numGlobals = 0;
00619         item = static_cast<KURLBarItem*>( m_listBox->firstItem() );
00620 
00621         while ( item )
00622         {
00623             if ( item->isPersistent() ) // we only save persistent items
00624             {
00625                 if ( !item->applicationLocal() )
00626                 {
00627                     writeItem( item, numGlobals, config, true );
00628                     numGlobals++;
00629                 }
00630             }
00631 
00632             item = static_cast<KURLBarItem*>( item->next() );
00633         }
00634         config->writeEntry("Number of Entries", numGlobals, true, true);
00635     }
00636 
00637     m_isModified = false;
00638 }
00639 
00640 void KURLBar::writeItem( KURLBarItem *item, int i, KConfig *config,
00641                          bool global )
00642 {
00643     if ( !item->isPersistent() )
00644         return;
00645 
00646     QString Description = "Description_";
00647     QString URL = "URL_";
00648     QString Icon = "Icon_";
00649     QString IconGroup = "IconGroup_";
00650 
00651     QString number = QString::number( i );
00652     config->writePathEntry( URL + number, item->url().prettyURL(), true, global );
00653 
00654     config->writeEntry( Description + number, item->description(),true,global);
00655     config->writeEntry( Icon + number, item->icon(), true, global );
00656     config->writeEntry( IconGroup + number, item->iconGroup(), true, global );
00657 }
00658 
00659 
00660 void KURLBar::slotDropped( QDropEvent *e )
00661 {
00662     KURL::List urls;
00663     if ( KURLDrag::decode( e, urls ) ) {
00664         KURL url;
00665         QString description;
00666         QString icon;
00667         bool appLocal = false;
00668 
00669         KURL::List::Iterator it = urls.begin();
00670         for ( ; it != urls.end(); ++it ) {
00671             url = *it;
00672             if ( KURLBarItemDialog::getInformation( m_useGlobal,
00673                                                     url, description, icon,
00674                                                     appLocal, m_iconSize,
00675                                                     this ) ) {
00676                 (void) insertItem( url, description, appLocal, icon );
00677                 if( !appLocal)
00678                     createItemOnMDKMerge( url, description, icon );
00679                 m_isModified = true;
00680                 updateGeometry();
00681             }
00682         }
00683     }
00684 }
00685 
00686 void KURLBar::slotContextMenuRequested( QListBoxItem *_item, const QPoint& pos )
00687 {
00688     if (m_isImmutable)
00689         return;
00690 
00691     KURLBarItem *item = dynamic_cast<KURLBarItem*>( _item );
00692 
00693     static const int IconSize   = 10;
00694     static const int AddItem    = 20;
00695     static const int EditItem   = 30;
00696     static const int RemoveItem = 40;
00697 
00698     KURL lastURL = m_activeItem ? m_activeItem->url() : KURL();
00699 
00700     bool smallIcons = m_iconSize < KIcon::SizeMedium;
00701     QPopupMenu *popup = new QPopupMenu();
00702     popup->insertItem( smallIcons ?
00703                        i18n("&Large Icons") : i18n("&Small Icons"),
00704                        IconSize );
00705     popup->insertSeparator();
00706 
00707     if (item != 0L && item->isPersistent())
00708     {
00709         popup->insertItem(SmallIconSet("edit"), i18n("&Edit Entry..."), EditItem);
00710         popup->insertSeparator();
00711     }
00712 
00713     popup->insertItem(SmallIconSet("filenew"), i18n("&Add Entry..."), AddItem);
00714 
00715     if (item != 0L && item->isPersistent())
00716     {
00717         popup->insertItem( SmallIconSet("editdelete"), i18n("&Remove Entry"),
00718                           RemoveItem );
00719     }
00720 
00721     int result = popup->exec( pos );
00722     switch ( result ) {
00723         case IconSize:
00724             setIconSize( smallIcons ? KIcon::SizeMedium : KIcon::SizeSmallMedium );
00725             m_listBox->triggerUpdate( true );
00726             break;
00727         case AddItem:
00728             addNewItem();
00729             break;
00730         case EditItem:
00731             editItem( static_cast<KURLBarItem *>( item ) );
00732             break;
00733         case RemoveItem:
00734             delete item;
00735             m_isModified = true;
00736             break;
00737         default: // abort
00738             break;
00739     }
00740 
00741     // reset current item
00742     m_activeItem = 0L;
00743     setCurrentItem( lastURL );
00744 }
00745 
00746 bool KURLBar::addNewItem()
00747 {
00748     KURLBarItem *item = new KURLBarItem( this, d->currentURL,
00749                                          i18n("Enter a description") );
00750     if ( editItem( item ) ) {
00751         m_listBox->insertItem( item );
00752         return true;
00753     }
00754 
00755     delete item;
00756     return false;
00757 }
00758 
00759 bool KURLBar::editItem( KURLBarItem *item )
00760 {
00761     if ( !item || !item->isPersistent() ) // should never happen tho
00762         return false;
00763 
00764     KURL url            = item->url();
00765     QString description = item->description();
00766     QString icon        = item->icon();
00767     bool appLocal       = item->applicationLocal();
00768 
00769     QString oldDescription = description;
00770 
00771     if ( KURLBarItemDialog::getInformation( m_useGlobal,
00772                                             url, description,
00773                                             icon, appLocal,
00774                                             m_iconSize, this ))
00775     {
00776         if( !appLocal)        
00777                 createItemOnMDKMerge( url, description, icon );
00778         item->setURL( url );
00779         item->setDescription( description );
00780         item->setIcon( icon );
00781         item->setApplicationLocal( appLocal );
00782         m_listBox->triggerUpdate( true );
00783         m_isModified = true;
00784         updateGeometry();
00785         return true;
00786     }
00787 
00788     return false;
00789 }
00790 
00791 void  KURLBar::createItemOnMDKMerge( const KURL &url, const QString & description, const QString &icon )
00792 {
00793     if ( !QFile::exists( KStandardDirs::mandrake_merge_directory() ) )
00794         KStandardDirs::makeDir( QFile::encodeName( KStandardDirs::mandrake_merge_directory() ) );
00795     KDesktopFile df(KStandardDirs::mandrake_merge_directory() + description);
00796     df.writeEntry( "Name", description );
00797     df.writeEntry( "Icon", icon );
00798     df.writeEntry( "Type", "Link" );
00799     df.writeEntry( "URL", url.url() );
00800     df.sync();
00801 }
00802 
00805 
00806 
00807 KURLBarListBox::KURLBarListBox( QWidget *parent, const char *name )
00808     : KListBox( parent, name )
00809 {
00810     m_toolTip = new KURLBarToolTip( this );
00811     setAcceptDrops( true );
00812     viewport()->setAcceptDrops( true );
00813 }
00814 
00815 KURLBarListBox::~KURLBarListBox()
00816 {
00817     delete m_toolTip;
00818 }
00819 
00820 QDragObject * KURLBarListBox::dragObject()
00821 {
00822     KURL::List urls;
00823     KURLBarItem *item = static_cast<KURLBarItem*>( firstItem() );
00824 
00825     while ( item ) {
00826         if ( item->isSelected() )
00827             urls.append( item->url() );
00828         item = static_cast<KURLBarItem*>( item->next() );
00829     }
00830 
00831     if ( !urls.isEmpty() ) // ### use custom drag-object with description etc.?
00832         return new KURLDrag( urls, this, "urlbar drag" );
00833 
00834     return 0L;
00835 }
00836 
00837 void KURLBarListBox::contentsDragEnterEvent( QDragEnterEvent *e )
00838 {
00839     e->accept( KURLDrag::canDecode( e ));
00840 }
00841 
00842 void KURLBarListBox::contentsDropEvent( QDropEvent *e )
00843 {
00844     emit dropped( e );
00845 }
00846 
00847 void KURLBarListBox::contextMenuEvent( QContextMenuEvent *e )
00848 {
00849     if (e)
00850     {
00851         emit contextMenuRequested( itemAt( e->globalPos() ), e->globalPos() );
00852         e->consume(); // Consume the event to avoid multiple contextMenuEvent calls...
00853     }
00854 }
00855 
00856 void KURLBarListBox::setOrientation( Qt::Orientation orient )
00857 {
00858     if ( orient == Vertical ) {
00859         setColumnMode( 1 );
00860         setRowMode( Variable );
00861     }
00862     else {
00863         setRowMode( 1 );
00864         setColumnMode( Variable );
00865     }
00866 
00867     m_orientation = orient;
00868 }
00869 
00872 
00873 
00874 bool KURLBarItemDialog::getInformation( bool allowGlobal, KURL& url,
00875                                         QString& description, QString& icon,
00876                                         bool& appLocal, int iconSize,
00877                                         QWidget *parent )
00878 {
00879     KURLBarItemDialog *dialog = new KURLBarItemDialog( allowGlobal, url,
00880                                                        description, icon,
00881                                                        appLocal,
00882                                                        iconSize, parent );
00883     if ( dialog->exec() == QDialog::Accepted ) {
00884         // set the return parameters
00885         url         = dialog->url();
00886         description = dialog->description();
00887         icon        = dialog->icon();
00888         appLocal    = dialog->applicationLocal();
00889 
00890         delete dialog;
00891         return true;
00892     }
00893 
00894     delete dialog;
00895     return false;
00896 }
00897 
00898 KURLBarItemDialog::KURLBarItemDialog( bool allowGlobal, const KURL& url,
00899                                       const QString& description,
00900                                       QString icon, bool appLocal,
00901                                       int iconSize,
00902                                       QWidget *parent, const char *name )
00903     : KDialogBase( parent, name, true,
00904                    i18n("Edit Quick Access Entry"), Ok | Cancel, Ok, true )
00905 {
00906     QVBox *box = new QVBox( this );
00907     QString text = i18n("<qt><b>Please provide a description, URL and icon for this Quick Access entry.</b></br></qt>");
00908     QLabel *label = new QLabel( text, box );
00909     box->setSpacing( spacingHint() );
00910 
00911     QGrid *grid = new QGrid( 2, box );
00912     grid->setSpacing( spacingHint() );
00913 
00914     QString whatsThisText = i18n("<qt>This is the text that will appear in the Quick Access panel.<p>"
00915                                  "The description should consist of one or two words "
00916                                  "that will help you remember what this entry refers to.</qt>");
00917     label = new QLabel( i18n("&Description:"), grid );
00918     m_edit = new KLineEdit( grid, "description edit" );
00919     m_edit->setText( description.isEmpty() ? url.fileName() : description );
00920     label->setBuddy( m_edit );
00921     QWhatsThis::add( label, whatsThisText );
00922     QWhatsThis::add( m_edit, whatsThisText );
00923 
00924     whatsThisText = i18n("<qt>This is the location associated with the entry. Any valid URL may be used. For example:<p>"
00925                          "%1<br>http://www.kde.org<br>ftp://ftp.kde.org/pub/kde/stable<p>"
00926                          "By clicking on the button next to the text edit box you can browse to an "
00927                          "appropriate URL.</qt>").arg(QDir::homeDirPath());
00928     label = new QLabel( i18n("&URL:"), grid );
00929     m_urlEdit = new KURLRequester( url.prettyURL(), grid );
00930     m_urlEdit->setMode( KFile::Directory );
00931     label->setBuddy( m_urlEdit );
00932     QWhatsThis::add( label, whatsThisText );
00933     QWhatsThis::add( m_urlEdit, whatsThisText );
00934 
00935     whatsThisText = i18n("<qt>This is the icon that will appear in the Quick Access panel.<p>"
00936                          "Click on the button to select a different icon.</qt>");
00937     label = new QLabel( i18n("Choose an &icon:"), grid );
00938     m_iconButton = new KIconButton( grid, "icon button" );
00939     m_iconButton->setIconSize( iconSize );
00940     if ( icon.isEmpty() )
00941         icon = KMimeType::iconForURL( url );
00942     m_iconButton->setIcon( icon );
00943     label->setBuddy( m_iconButton );
00944     QWhatsThis::add( label, whatsThisText );
00945     QWhatsThis::add( m_iconButton, whatsThisText );
00946 
00947     if ( allowGlobal ) {
00948         QString appName;
00949         if ( KGlobal::instance()->aboutData() )
00950             appName = KGlobal::instance()->aboutData()->programName();
00951         if ( appName.isEmpty() )
00952             appName = QString::fromLatin1( KGlobal::instance()->instanceName() );
00953         m_appLocal = new QCheckBox( i18n("&Only show when using this application (%1)").arg( appName ), box );
00954         m_appLocal->setChecked( appLocal );
00955         QWhatsThis::add( m_appLocal,
00956                          i18n("<qt>Select this setting if you want this "
00957                               "entry to show only when using the current application (%1).<p>"
00958                               "If this setting is not selected, the entry will be available in all "
00959                               "applications.</qt>")
00960                               .arg(appName));
00961     }
00962     else
00963         m_appLocal = 0L;
00964     connect(m_urlEdit->lineEdit(),SIGNAL(textChanged ( const QString & )),this,SLOT(urlChanged(const QString & )));
00965     m_edit->setFocus();
00966     setMainWidget( box );
00967 }
00968 
00969 KURLBarItemDialog::~KURLBarItemDialog()
00970 {
00971 }
00972 
00973 void KURLBarItemDialog::urlChanged(const QString & text )
00974 {
00975     enableButtonOK( !text.isEmpty() );
00976 }
00977 
00978 KURL KURLBarItemDialog::url() const
00979 {
00980     QString text = m_urlEdit->url();
00981     KURL u;
00982     if ( text.at(0) == '/' )
00983         u.setPath( text );
00984     else
00985         u = text;
00986 
00987     return u;
00988 }
00989 
00990 QString KURLBarItemDialog::description() const
00991 {
00992     return m_edit->text();
00993 }
00994 
00995 QString KURLBarItemDialog::icon() const
00996 {
00997     return m_iconButton->icon();
00998 }
00999 
01000 bool KURLBarItemDialog::applicationLocal() const
01001 {
01002     if ( !m_appLocal )
01003         return true;
01004 
01005     return m_appLocal->isChecked();
01006 }
01007 
01008 void KURLBarItem::virtual_hook( int, void* )
01009 { /*BASE::virtual_hook( id, data );*/ }
01010 
01011 void KURLBar::virtual_hook( int, void* )
01012 { /*BASE::virtual_hook( id, data );*/ }
01013 
01014 void KURLBarListBox::virtual_hook( int id, void* data )
01015 { KListBox::virtual_hook( id, data ); }
01016 
01017 
01018 #include "kurlbar.moc"
KDE Logo
This file is part of the documentation for kio Library Version 3.3.90.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Wed Mar 30 10:15:31 2005 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003