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