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