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"