00001 
00002 
00003 
00004 
00005 
00006 
00007 
00008 
00009 
00010 
00011 
00012 
00013 
00014 
00015 
00016 
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()  ),
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()  ),
00101       m_url( url ),
00102       m_pixmap( 0L ),
00103       m_parent( parent ),
00104       m_appLocal( true )
00105 {
00106     init( icon, group, description, true  );
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         
00183 
00184         
00185         
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         
00199     }
00200 
00201     else {
00202         
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     
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     
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     
00424     
00425     
00426     
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 
00449 
00450 
00451 
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 ) { 
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     
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; 
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() ) 
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     
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() ) 
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: 
00713             break;
00714     }
00715 
00716     
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() ) 
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() ) 
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(); 
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         
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 {  }
00970 
00971 void KURLBar::virtual_hook( int, void* )
00972 {  }
00973 
00974 void KURLBarListBox::virtual_hook( int id, void* data )
00975 { KListBox::virtual_hook( id, data ); }
00976 
00977 
00978 #include "kurlbar.moc"