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 
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( true )
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( true )
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                 m_isModified = true;
00678                 updateGeometry();
00679             }
00680         }
00681     }
00682 }
00683 
00684 void KURLBar::slotContextMenuRequested( QListBoxItem *_item, const QPoint& pos )
00685 {
00686     if (m_isImmutable)
00687         return;
00688 
00689     KURLBarItem *item = dynamic_cast<KURLBarItem*>( _item );
00690 
00691     static const int IconSize   = 10;
00692     static const int AddItem    = 20;
00693     static const int EditItem   = 30;
00694     static const int RemoveItem = 40;
00695 
00696     KURL lastURL = m_activeItem ? m_activeItem->url() : KURL();
00697 
00698     bool smallIcons = m_iconSize < KIcon::SizeMedium;
00699     QPopupMenu *popup = new QPopupMenu();
00700     popup->insertItem( smallIcons ?
00701                        i18n("&Large Icons") : i18n("&Small Icons"),
00702                        IconSize );
00703     popup->insertSeparator();
00704 
00705     if (item != 0L && item->isPersistent())
00706     {
00707         popup->insertItem(SmallIconSet("edit"), i18n("&Edit Entry..."), EditItem);
00708         popup->insertSeparator();
00709     }
00710 
00711     popup->insertItem(SmallIconSet("filenew"), i18n("&Add Entry..."), AddItem);
00712 
00713     if (item != 0L && item->isPersistent())
00714     {
00715         popup->insertItem( SmallIconSet("editdelete"), i18n("&Remove Entry"),
00716                           RemoveItem );
00717     }
00718 
00719     int result = popup->exec( pos );
00720     switch ( result ) {
00721         case IconSize:
00722             setIconSize( smallIcons ? KIcon::SizeMedium : KIcon::SizeSmallMedium );
00723             m_listBox->triggerUpdate( true );
00724             break;
00725         case AddItem:
00726             addNewItem();
00727             break;
00728         case EditItem:
00729             editItem( static_cast<KURLBarItem *>( item ) );
00730             break;
00731         case RemoveItem:
00732             delete item;
00733             m_isModified = true;
00734             break;
00735         default: // abort
00736             break;
00737     }
00738 
00739     // reset current item
00740     m_activeItem = 0L;
00741     setCurrentItem( lastURL );
00742 }
00743 
00744 bool KURLBar::addNewItem()
00745 {
00746     KURLBarItem *item = new KURLBarItem( this, d->currentURL,
00747                                          i18n("Enter a description") );
00748     if ( editItem( item ) ) {
00749         m_listBox->insertItem( item );
00750         return true;
00751     }
00752 
00753     delete item;
00754     return false;
00755 }
00756 
00757 bool KURLBar::editItem( KURLBarItem *item )
00758 {
00759     if ( !item || !item->isPersistent() ) // should never happen tho
00760         return false;
00761 
00762     KURL url            = item->url();
00763     QString description = item->description();
00764     QString icon        = item->icon();
00765     bool appLocal       = item->applicationLocal();
00766 
00767     if ( KURLBarItemDialog::getInformation( m_useGlobal,
00768                                             url, description,
00769                                             icon, appLocal,
00770                                             m_iconSize, this ))
00771     {
00772         item->setURL( url );
00773         item->setDescription( description );
00774         item->setIcon( icon );
00775         item->setApplicationLocal( appLocal );
00776         m_listBox->triggerUpdate( true );
00777         m_isModified = true;
00778         updateGeometry();
00779         return true;
00780     }
00781 
00782     return false;
00783 }
00784 
00787 
00788 
00789 KURLBarListBox::KURLBarListBox( QWidget *parent, const char *name )
00790     : KListBox( parent, name )
00791 {
00792     m_toolTip = new KURLBarToolTip( this );
00793     setAcceptDrops( true );
00794     viewport()->setAcceptDrops( true );
00795 }
00796 
00797 KURLBarListBox::~KURLBarListBox()
00798 {
00799     delete m_toolTip;
00800 }
00801 
00802 QDragObject * KURLBarListBox::dragObject()
00803 {
00804     KURL::List urls;
00805     KURLBarItem *item = static_cast<KURLBarItem*>( firstItem() );
00806 
00807     while ( item ) {
00808         if ( item->isSelected() )
00809             urls.append( item->url() );
00810         item = static_cast<KURLBarItem*>( item->next() );
00811     }
00812 
00813     if ( !urls.isEmpty() ) // ### use custom drag-object with description etc.?
00814         return new KURLDrag( urls, this, "urlbar drag" );
00815 
00816     return 0L;
00817 }
00818 
00819 void KURLBarListBox::contentsDragEnterEvent( QDragEnterEvent *e )
00820 {
00821     e->accept( KURLDrag::canDecode( e ));
00822 }
00823 
00824 void KURLBarListBox::contentsDropEvent( QDropEvent *e )
00825 {
00826     emit dropped( e );
00827 }
00828 
00829 void KURLBarListBox::contextMenuEvent( QContextMenuEvent *e )
00830 {
00831     if (e)
00832     {
00833         emit contextMenuRequested( itemAt( e->globalPos() ), e->globalPos() );
00834         e->consume(); // Consume the event to avoid multiple contextMenuEvent calls...
00835     }
00836 }
00837 
00838 void KURLBarListBox::setOrientation( Qt::Orientation orient )
00839 {
00840     if ( orient == Vertical ) {
00841         setColumnMode( 1 );
00842         setRowMode( Variable );
00843     }
00844     else {
00845         setRowMode( 1 );
00846         setColumnMode( Variable );
00847     }
00848 
00849     m_orientation = orient;
00850 }
00851 
00854 
00855 
00856 bool KURLBarItemDialog::getInformation( bool allowGlobal, KURL& url,
00857                                         QString& description, QString& icon,
00858                                         bool& appLocal, int iconSize,
00859                                         QWidget *parent )
00860 {
00861     KURLBarItemDialog *dialog = new KURLBarItemDialog( allowGlobal, url,
00862                                                        description, icon,
00863                                                        appLocal,
00864                                                        iconSize, parent );
00865     if ( dialog->exec() == QDialog::Accepted ) {
00866         // set the return parameters
00867         url         = dialog->url();
00868         description = dialog->description();
00869         icon        = dialog->icon();
00870         appLocal    = dialog->applicationLocal();
00871 
00872         delete dialog;
00873         return true;
00874     }
00875 
00876     delete dialog;
00877     return false;
00878 }
00879 
00880 KURLBarItemDialog::KURLBarItemDialog( bool allowGlobal, const KURL& url,
00881                                       const QString& description,
00882                                       QString icon, bool appLocal,
00883                                       int iconSize,
00884                                       QWidget *parent, const char *name )
00885     : KDialogBase( parent, name, true,
00886                    i18n("Edit Quick Access Entry"), Ok | Cancel, Ok, true )
00887 {
00888     QVBox *box = new QVBox( this );
00889     QString text = i18n("<qt><b>Please provide a description, URL and icon for this Quick Access entry.</b></br></qt>");
00890     QLabel *label = new QLabel( text, box );
00891     box->setSpacing( spacingHint() );
00892 
00893     QGrid *grid = new QGrid( 2, box );
00894     grid->setSpacing( spacingHint() );
00895 
00896     QString whatsThisText = i18n("<qt>This is the text that will appear in the Quick Access panel.<p>"
00897                                  "The description should consist of one or two words "
00898                                  "that will help you remember what this entry refers to.</qt>");
00899     label = new QLabel( i18n("&Description:"), grid );
00900     m_edit = new KLineEdit( grid, "description edit" );
00901     m_edit->setText( description.isEmpty() ? url.fileName() : description );
00902     label->setBuddy( m_edit );
00903     QWhatsThis::add( label, whatsThisText );
00904     QWhatsThis::add( m_edit, whatsThisText );
00905 
00906     whatsThisText = i18n("<qt>This is the location associated with the entry. Any valid URL may be used. For example:<p>"
00907                          "%1<br>http://www.kde.org<br>ftp://ftp.kde.org/pub/kde/stable<p>"
00908                          "By clicking on the button next to the text edit box you can browse to an "
00909                          "appropriate URL.</qt>").arg(QDir::homeDirPath());
00910     label = new QLabel( i18n("&URL:"), grid );
00911     m_urlEdit = new KURLRequester( url.prettyURL(), grid );
00912     m_urlEdit->setMode( KFile::Directory );
00913     label->setBuddy( m_urlEdit );
00914     QWhatsThis::add( label, whatsThisText );
00915     QWhatsThis::add( m_urlEdit, whatsThisText );
00916 
00917     whatsThisText = i18n("<qt>This is the icon that will appear in the Quick Access panel.<p>"
00918                          "Click on the button to select a different icon.</qt>");
00919     label = new QLabel( i18n("Choose an &icon:"), grid );
00920     m_iconButton = new KIconButton( grid, "icon button" );
00921     m_iconButton->setIconSize( iconSize );
00922     if ( icon.isEmpty() )
00923         icon = KMimeType::iconForURL( url );
00924     m_iconButton->setIcon( icon );
00925     label->setBuddy( m_iconButton );
00926     QWhatsThis::add( label, whatsThisText );
00927     QWhatsThis::add( m_iconButton, whatsThisText );
00928 
00929     if ( allowGlobal ) {
00930         QString appName;
00931         if ( KGlobal::instance()->aboutData() )
00932             appName = KGlobal::instance()->aboutData()->programName();
00933         if ( appName.isEmpty() )
00934             appName = QString::fromLatin1( KGlobal::instance()->instanceName() );
00935         m_appLocal = new QCheckBox( i18n("&Only show when using this application (%1)").arg( appName ), box );
00936         m_appLocal->setChecked( appLocal );
00937         QWhatsThis::add( m_appLocal,
00938                          i18n("<qt>Select this setting if you want this "
00939                               "entry to show only when using the current application (%1).<p>"
00940                               "If this setting is not selected, the entry will be available in all "
00941                               "applications.</qt>")
00942                               .arg(appName));
00943     }
00944     else
00945         m_appLocal = 0L;
00946     connect(m_urlEdit->lineEdit(),SIGNAL(textChanged ( const QString & )),this,SLOT(urlChanged(const QString & )));
00947     m_edit->setFocus();
00948     setMainWidget( box );
00949 }
00950 
00951 KURLBarItemDialog::~KURLBarItemDialog()
00952 {
00953 }
00954 
00955 void KURLBarItemDialog::urlChanged(const QString & text )
00956 {
00957     enableButtonOK( !text.isEmpty() );
00958 }
00959 
00960 KURL KURLBarItemDialog::url() const
00961 {
00962     QString text = m_urlEdit->url();
00963     KURL u;
00964     if ( text.at(0) == '/' )
00965         u.setPath( text );
00966     else
00967         u = text;
00968 
00969     return u;
00970 }
00971 
00972 QString KURLBarItemDialog::description() const
00973 {
00974     return m_edit->text();
00975 }
00976 
00977 QString KURLBarItemDialog::icon() const
00978 {
00979     return m_iconButton->icon();
00980 }
00981 
00982 bool KURLBarItemDialog::applicationLocal() const
00983 {
00984     if ( !m_appLocal )
00985         return true;
00986 
00987     return m_appLocal->isChecked();
00988 }
00989 
00990 void KURLBarItem::virtual_hook( int, void* )
00991 { /*BASE::virtual_hook( id, data );*/ }
00992 
00993 void KURLBar::virtual_hook( int, void* )
00994 { /*BASE::virtual_hook( id, data );*/ }
00995 
00996 void KURLBarListBox::virtual_hook( int id, void* data )
00997 { KListBox::virtual_hook( id, data ); }
00998 
00999 
01000 #include "kurlbar.moc"
KDE Logo
This file is part of the documentation for kio Library Version 3.3.0.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Nov 27 13:45:40 2004 by doxygen 1.3.9.1 written by Dimitri van Heesch, © 1997-2003