kio Library API Documentation

kurlbar.cpp

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