author | zautrix <zautrix> | 2004-06-26 19:01:18 (UTC) |
---|---|---|
committer | zautrix <zautrix> | 2004-06-26 19:01:18 (UTC) |
commit | b9aad1f15dc600e4dbe4c62d3fcced6363188ba3 (patch) (unidiff) | |
tree | 2c3d4004fb21c72cba65793859f9bcd8ffd3a49c /microkde/kio/kfile | |
download | kdepimpi-b9aad1f15dc600e4dbe4c62d3fcced6363188ba3.zip kdepimpi-b9aad1f15dc600e4dbe4c62d3fcced6363188ba3.tar.gz kdepimpi-b9aad1f15dc600e4dbe4c62d3fcced6363188ba3.tar.bz2 |
Initial revision
-rw-r--r-- | microkde/kio/kfile/kurlrequester.cpp | 406 | ||||
-rw-r--r-- | microkde/kio/kfile/kurlrequester.h | 269 |
2 files changed, 675 insertions, 0 deletions
diff --git a/microkde/kio/kfile/kurlrequester.cpp b/microkde/kio/kfile/kurlrequester.cpp new file mode 100644 index 0000000..6d39308 --- a/dev/null +++ b/microkde/kio/kfile/kurlrequester.cpp | |||
@@ -0,0 +1,406 @@ | |||
1 | /* This file is part of the KDE libraries | ||
2 | Copyright (C) 1999,2000,2001 Carsten Pfeiffer <pfeiffer@kde.org> | ||
3 | |||
4 | library is free software; you can redistribute it and/or | ||
5 | modify it under the terms of the GNU Library General Public | ||
6 | License version 2, as published by the Free Software Foundation. | ||
7 | |||
8 | This library is distributed in the hope that it will be useful, | ||
9 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
10 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
11 | Library General Public License for more details. | ||
12 | |||
13 | You should have received a copy of the GNU Library General Public License | ||
14 | along with this library; see the file COPYING.LIB. If not, write to | ||
15 | the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | ||
16 | Boston, MA 02111-1307, USA. | ||
17 | */ | ||
18 | |||
19 | |||
20 | #include <sys/stat.h> | ||
21 | #ifdef _WIN32_ | ||
22 | |||
23 | #else | ||
24 | #include <unistd.h> | ||
25 | #endif | ||
26 | #include <qstring.h> | ||
27 | //US #include <qtooltip.h> | ||
28 | |||
29 | #include <qpushbutton.h> | ||
30 | |||
31 | //US #include <kaccel.h> | ||
32 | //US #include <kcombobox.h> | ||
33 | #include <kdebug.h> | ||
34 | #include <kdialog.h> | ||
35 | #include <kfiledialog.h> | ||
36 | #include <kglobal.h> | ||
37 | #include <kiconloader.h> | ||
38 | #include <klineedit.h> | ||
39 | #include <klocale.h> | ||
40 | //US #include <kurlcompletion.h> | ||
41 | //US #include <kurldrag.h> | ||
42 | //US #include <kprotocolinfo.h> | ||
43 | |||
44 | |||
45 | #include "kurlrequester.h" | ||
46 | |||
47 | |||
48 | class KURLDragPushButton : public QPushButton | ||
49 | { | ||
50 | public: | ||
51 | KURLDragPushButton( QWidget *parent, const char *name=0 ) | ||
52 | : QPushButton( parent, name ) { | ||
53 | //US setDragEnabled( true ); | ||
54 | } | ||
55 | ~KURLDragPushButton() {} | ||
56 | |||
57 | void setURL( const KURL& url ) { | ||
58 | m_urls.clear(); | ||
59 | m_urls.append( url ); | ||
60 | } | ||
61 | |||
62 | /* not needed so far | ||
63 | void setURLs( const KURL::List& urls ) { | ||
64 | m_urls = urls; | ||
65 | } | ||
66 | const KURL::List& urls() const { return m_urls; } | ||
67 | */ | ||
68 | |||
69 | protected: | ||
70 | /*US | ||
71 | virtual QDragObject *dragObject() { | ||
72 | if ( m_urls.isEmpty() ) | ||
73 | return 0L; | ||
74 | |||
75 | QDragObject *drag = KURLDrag::newDrag( m_urls, this, "url drag" ); | ||
76 | return drag; | ||
77 | } | ||
78 | */ | ||
79 | private: | ||
80 | KURL::List m_urls; | ||
81 | |||
82 | }; | ||
83 | |||
84 | |||
85 | /* | ||
86 | ************************************************************************* | ||
87 | */ | ||
88 | |||
89 | class KURLRequester::KURLRequesterPrivate | ||
90 | { | ||
91 | public: | ||
92 | KURLRequesterPrivate() { | ||
93 | edit = 0L; | ||
94 | //UScombo = 0L; | ||
95 | //US fileDialogMode = KFile::File | KFile::ExistingOnly | KFile::LocalOnly; | ||
96 | } | ||
97 | |||
98 | void setText( const QString& text ) { | ||
99 | /*US | ||
100 | if ( combo ) | ||
101 | { | ||
102 | if (combo->editable()) | ||
103 | { | ||
104 | combo->setEditText( text ); | ||
105 | } | ||
106 | else | ||
107 | { | ||
108 | combo->insertItem( text ); | ||
109 | combo->setCurrentItem( combo->count()-1 ); | ||
110 | } | ||
111 | } | ||
112 | else | ||
113 | */ | ||
114 | { | ||
115 | edit->setText( text ); | ||
116 | } | ||
117 | } | ||
118 | |||
119 | void connectSignals( QObject *receiver ) { | ||
120 | QObject *sender; | ||
121 | /*USif ( combo ) | ||
122 | sender = combo; | ||
123 | else | ||
124 | */ | ||
125 | sender = edit; | ||
126 | |||
127 | connect( sender, SIGNAL( textChanged( const QString& )), | ||
128 | receiver, SIGNAL( textChanged( const QString& ))); | ||
129 | connect( sender, SIGNAL( returnPressed() ), | ||
130 | receiver, SIGNAL( returnPressed() )); | ||
131 | //USconnect( sender, SIGNAL( returnPressed( const QString& ) ), | ||
132 | //US receiver, SIGNAL( returnPressed( const QString& ) )); | ||
133 | } | ||
134 | /*US | ||
135 | void setCompletionObject( KCompletion *comp ) { | ||
136 | if ( combo ) | ||
137 | combo->setCompletionObject( comp ); | ||
138 | else | ||
139 | edit->setCompletionObject( comp ); | ||
140 | } | ||
141 | */ | ||
142 | /** | ||
143 | * replaces ~user or $FOO, if necessary | ||
144 | */ | ||
145 | QString url() { | ||
146 | QString txt = /*US combo ? combo->currentText() : */ edit->text(); | ||
147 | /*US KURLCompletion *comp; | ||
148 | if ( combo ) | ||
149 | comp = dynamic_cast<KURLCompletion*>(combo->completionObject()); | ||
150 | else | ||
151 | comp = dynamic_cast<KURLCompletion*>(edit->completionObject()); | ||
152 | |||
153 | if ( comp ) | ||
154 | return comp->replacedPath( txt ); | ||
155 | else | ||
156 | */ | ||
157 | return txt; | ||
158 | } | ||
159 | |||
160 | KLineEdit *edit; | ||
161 | //US KComboBox *combo; | ||
162 | int fileDialogMode; | ||
163 | QString fileDialogFilter; | ||
164 | }; | ||
165 | |||
166 | |||
167 | /*US | ||
168 | KURLRequester::KURLRequester( QWidget *editWidget, QWidget *parent, | ||
169 | const char *name ) | ||
170 | : QHBox( parent, name ) | ||
171 | { | ||
172 | d = new KURLRequesterPrivate; | ||
173 | |||
174 | // must have this as parent | ||
175 | editWidget->reparent( this, 0, QPoint(0,0) ); | ||
176 | //US d->edit = dynamic_cast<KLineEdit*>( editWidget ); | ||
177 | d->edit = (KLineEdit*)( editWidget ); | ||
178 | //US d->combo = dynamic_cast<KComboBox*>( editWidget ); | ||
179 | |||
180 | init(); | ||
181 | } | ||
182 | */ | ||
183 | |||
184 | KURLRequester::KURLRequester( QWidget *parent, const char *name ) | ||
185 | : QHBox( parent, name ) | ||
186 | { | ||
187 | d = new KURLRequesterPrivate; | ||
188 | init(); | ||
189 | } | ||
190 | |||
191 | |||
192 | KURLRequester::KURLRequester( const QString& url, QWidget *parent, | ||
193 | const char *name ) | ||
194 | : QHBox( parent, name ) | ||
195 | { | ||
196 | d = new KURLRequesterPrivate; | ||
197 | init(); | ||
198 | setURL( url ); | ||
199 | } | ||
200 | |||
201 | |||
202 | KURLRequester::~KURLRequester() | ||
203 | { | ||
204 | //US delete myCompletion; | ||
205 | delete myFileDialog; | ||
206 | delete d; | ||
207 | } | ||
208 | |||
209 | |||
210 | void KURLRequester::init() | ||
211 | { | ||
212 | myFileDialog = 0L; | ||
213 | myShowLocalProt = false; | ||
214 | |||
215 | if (/*US !d->combo && */ !d->edit ) | ||
216 | d->edit = new KLineEdit( this, "KURLRequester::KLineEdit" ); | ||
217 | |||
218 | myButton = new KURLDragPushButton( this, "kfile button"); | ||
219 | QIconSet iconSet = SmallIconSet("fileopen"); | ||
220 | QPixmap pixMap = iconSet.pixmap( QIconSet::Small, QIconSet::Normal ); | ||
221 | myButton->setIconSet( iconSet ); | ||
222 | myButton->setFixedSize( pixMap.width()+8, pixMap.height()+8 ); | ||
223 | //US QToolTip::add(myButton, i18n("Open file dialog")); | ||
224 | |||
225 | connect( myButton, SIGNAL( pressed() ), SLOT( slotUpdateURL() )); | ||
226 | |||
227 | setSpacing( KDialog::spacingHint() ); | ||
228 | |||
229 | QWidget *widget = /*US d->combo ? (QWidget*) d->combo : */ (QWidget*) d->edit; | ||
230 | setFocusProxy( widget ); | ||
231 | |||
232 | d->connectSignals( this ); | ||
233 | connect( myButton, SIGNAL( clicked() ), this, SLOT( slotOpenDialog() )); | ||
234 | /*US | ||
235 | myCompletion = new KURLCompletion(); | ||
236 | d->setCompletionObject( myCompletion ); | ||
237 | |||
238 | KAccel *accel = new KAccel( this ); | ||
239 | accel->insert( KStdAccel::Open, this, SLOT( slotOpenDialog() )); | ||
240 | accel->readSettings(); | ||
241 | */ | ||
242 | } | ||
243 | |||
244 | |||
245 | void KURLRequester::setURL( const QString& url ) | ||
246 | { | ||
247 | bool hasLocalPrefix = (url.startsWith("file:")); | ||
248 | |||
249 | if ( !myShowLocalProt && hasLocalPrefix ) | ||
250 | d->setText( url.mid( 5, url.length()-5 )); | ||
251 | else | ||
252 | d->setText( url ); | ||
253 | } | ||
254 | |||
255 | void KURLRequester::setCaption( const QString& caption ) | ||
256 | { | ||
257 | //USfileDialog()->setCaption( caption ); | ||
258 | //USQWidget::setCaption( caption ); | ||
259 | } | ||
260 | |||
261 | QString KURLRequester::url() const | ||
262 | { | ||
263 | return d->url(); | ||
264 | } | ||
265 | |||
266 | |||
267 | void KURLRequester::slotOpenDialog() | ||
268 | { | ||
269 | emit openFileDialog( this ); | ||
270 | |||
271 | //US use our special KFIleDialog instead | ||
272 | KURL u( url() ); | ||
273 | //QString fn = u.url(); | ||
274 | QString fn = d->edit->text(); | ||
275 | fn = KFileDialog::getSaveFileName( fn, "Save backup filename", this ); | ||
276 | |||
277 | if ( fn == "" ) | ||
278 | return; | ||
279 | |||
280 | setURL( fn ); | ||
281 | emit urlSelected( d->url() ); | ||
282 | /*US | ||
283 | KFileDialog *dlg = fileDialog(); | ||
284 | if ( !d->url().isEmpty() ) { | ||
285 | KURL u( url() ); | ||
286 | // If we won't be able to list it (e.g. http), then don't try :) | ||
287 | if ( KProtocolInfo::supportsListing( u.protocol() ) ) | ||
288 | dlg->setSelection( u.url() ); | ||
289 | } | ||
290 | |||
291 | if ( dlg->exec() == QDialog::Accepted ) | ||
292 | { | ||
293 | setURL( dlg->selectedURL().prettyURL() ); | ||
294 | emit urlSelected( d->url() ); | ||
295 | } | ||
296 | */ | ||
297 | |||
298 | } | ||
299 | |||
300 | void KURLRequester::setMode(unsigned int mode) | ||
301 | { | ||
302 | /*US | ||
303 | Q_ASSERT( (mode & KFile::Files) == 0 ); | ||
304 | d->fileDialogMode = mode; | ||
305 | if ( (mode & KFile::Directory) && !(mode & KFile::File) ) | ||
306 | myCompletion->setMode( KURLCompletion::DirCompletion ); | ||
307 | |||
308 | if (myFileDialog) | ||
309 | myFileDialog->setMode( d->fileDialogMode ); | ||
310 | */ | ||
311 | } | ||
312 | |||
313 | void KURLRequester::setFilter(const QString &filter) | ||
314 | { | ||
315 | /*US | ||
316 | d->fileDialogFilter = filter; | ||
317 | if (myFileDialog) | ||
318 | myFileDialog->setFilter( d->fileDialogFilter ); | ||
319 | */ | ||
320 | } | ||
321 | |||
322 | KFileDialog * KURLRequester::fileDialog() const | ||
323 | { | ||
324 | /*US | ||
325 | if ( !myFileDialog ) { | ||
326 | QWidget *p = parentWidget(); | ||
327 | myFileDialog = new KFileDialog( QString::null, QString::null, p, | ||
328 | "file dialog", true ); | ||
329 | |||
330 | myFileDialog->setMode( d->fileDialogMode ); | ||
331 | myFileDialog->setFilter( d->fileDialogFilter ); | ||
332 | } | ||
333 | |||
334 | return myFileDialog; | ||
335 | */ | ||
336 | return 0; | ||
337 | } | ||
338 | |||
339 | |||
340 | void KURLRequester::setShowLocalProtocol( bool b ) | ||
341 | { | ||
342 | if ( myShowLocalProt == b ) | ||
343 | return; | ||
344 | |||
345 | myShowLocalProt = b; | ||
346 | setURL( url() ); | ||
347 | } | ||
348 | |||
349 | void KURLRequester::clear() | ||
350 | { | ||
351 | d->setText( QString::null ); | ||
352 | } | ||
353 | |||
354 | KLineEdit * KURLRequester::lineEdit() const | ||
355 | { | ||
356 | return d->edit; | ||
357 | } | ||
358 | /*US | ||
359 | KComboBox * KURLRequester::comboBox() const | ||
360 | { | ||
361 | return d->combo; | ||
362 | } | ||
363 | */ | ||
364 | void KURLRequester::slotUpdateURL() | ||
365 | { | ||
366 | // bin compat, myButton is declared as QPushButton | ||
367 | //US KURL u( QDir::currentDirPath() + '/', url() ); | ||
368 | KURL u( url() ); | ||
369 | (static_cast<KURLDragPushButton *>( myButton))->setURL( u ); | ||
370 | } | ||
371 | |||
372 | QPushButton * KURLRequester::button() const | ||
373 | { | ||
374 | return myButton; | ||
375 | } | ||
376 | /*US | ||
377 | KEditListBox::CustomEditor KURLRequester::customEditor() | ||
378 | { | ||
379 | setSizePolicy(QSizePolicy( QSizePolicy::Preferred, | ||
380 | QSizePolicy::Fixed)); | ||
381 | |||
382 | KLineEdit *edit = d->edit; | ||
383 | if ( !edit && d->combo ) | ||
384 | edit = dynamic_cast<KLineEdit*>( d->combo->lineEdit() ); | ||
385 | |||
386 | #ifndef NDEBUG | ||
387 | if ( !edit ) | ||
388 | kdWarning() << "KURLRequester's lineedit is not a KLineEdit!??\n"; | ||
389 | #endif | ||
390 | |||
391 | KEditListBox::CustomEditor editor( this, edit ); | ||
392 | return editor; | ||
393 | } | ||
394 | */ | ||
395 | void KURLRequester::virtual_hook( int, void* ) | ||
396 | { /*BASE::virtual_hook( id, data );*/ } | ||
397 | |||
398 | /*US | ||
399 | KURLComboRequester::KURLComboRequester( QWidget *parent, | ||
400 | const char *name ) | ||
401 | : KURLRequester( new KComboBox(false), parent, name) | ||
402 | { | ||
403 | } | ||
404 | */ | ||
405 | |||
406 | //US #include "kurlrequester.moc" | ||
diff --git a/microkde/kio/kfile/kurlrequester.h b/microkde/kio/kfile/kurlrequester.h new file mode 100644 index 0000000..3253dd5 --- a/dev/null +++ b/microkde/kio/kfile/kurlrequester.h | |||
@@ -0,0 +1,269 @@ | |||
1 | /* This file is part of the KDE libraries | ||
2 | Copyright (C) 1999,2000,2001 Carsten Pfeiffer <pfeiffer@kde.org> | ||
3 | |||
4 | library is free software; you can redistribute it and/or | ||
5 | modify it under the terms of the GNU Library General Public | ||
6 | License version 2, as published by the Free Software Foundation. | ||
7 | |||
8 | This library is distributed in the hope that it will be useful, | ||
9 | but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
10 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
11 | Library General Public License for more details. | ||
12 | |||
13 | You should have received a copy of the GNU Library General Public License | ||
14 | along with this library; see the file COPYING.LIB. If not, write to | ||
15 | the Free Software Foundation, Inc., 59 Temple Place - Suite 330, | ||
16 | Boston, MA 02111-1307, USA. | ||
17 | */ | ||
18 | |||
19 | |||
20 | #ifndef KURLREQUESTER_H | ||
21 | #define KURLREQUESTER_H | ||
22 | |||
23 | #include <qhbox.h> | ||
24 | |||
25 | #include <keditlistbox.h> | ||
26 | //US #include <kfile.h> | ||
27 | //US #include <kpushbutton.h> | ||
28 | #include <kurl.h> | ||
29 | |||
30 | //US class KComboBox; | ||
31 | |||
32 | class KFileDialog; | ||
33 | class KLineEdit; | ||
34 | //US class KURLCompletion; | ||
35 | class KURLDragPushButton; | ||
36 | |||
37 | class QPushButton; | ||
38 | class QString; | ||
39 | class QTimer; | ||
40 | |||
41 | /** | ||
42 | * This class is a widget showing a lineedit and a button, which invokes a | ||
43 | * filedialog. File name completion is available in the lineedit. | ||
44 | * | ||
45 | * The defaults for the filedialog are to ask for one existing local file, i.e. | ||
46 | * KFileDialog::setMode( KFile::File | KFile::ExistingOnly | KFile::LocalOnly ) | ||
47 | * The default filter is "*", i.e. show all files, and the start directory is | ||
48 | * the current working directory, or the last directory where a file has been | ||
49 | * selected. | ||
50 | * | ||
51 | * You can change this behavior by using @ref setMode() or @ref setFilter(). | ||
52 | * | ||
53 | * @short A widget to request a filename/url from the user | ||
54 | * @author Carsten Pfeiffer <pfeiffer@kde.org> | ||
55 | */ | ||
56 | class KURLRequester : public QHBox | ||
57 | { | ||
58 | Q_OBJECT | ||
59 | Q_PROPERTY( QString url READ url WRITE setURL ) | ||
60 | |||
61 | public: | ||
62 | /** | ||
63 | * Constructs a KURLRequester widget. | ||
64 | */ | ||
65 | KURLRequester( QWidget *parent=0, const char *name=0 ); | ||
66 | |||
67 | /** | ||
68 | * Constructs a KURLRequester widget with the initial URL @p url. | ||
69 | */ | ||
70 | KURLRequester( const QString& url, QWidget *parent=0, const char *name=0 ); | ||
71 | |||
72 | /** | ||
73 | * Special constructor, which creates a KURLRequester widget with a custom | ||
74 | * edit-widget. The edit-widget can be either a KComboBox or a KLineEdit | ||
75 | * (or inherited thereof). Note: for geometry management reasons, the | ||
76 | * edit-widget is reparented to have the KURLRequester as parent. | ||
77 | * @param modal specifies whether the filedialog should be opened as modal | ||
78 | * or not. | ||
79 | */ | ||
80 | //US KURLRequester( QWidget *editWidget, QWidget *parent, const char *name=0 ); | ||
81 | /** | ||
82 | * Destructs the KURLRequester. | ||
83 | */ | ||
84 | ~KURLRequester(); | ||
85 | |||
86 | /** | ||
87 | * @returns the current url in the lineedit. May be malformed, if the user | ||
88 | * entered something weird. ~user or environment variables are substituted | ||
89 | * for local files. | ||
90 | */ | ||
91 | QString url() const; | ||
92 | |||
93 | /** | ||
94 | * Enables/disables showing file:/ in the lineedit, when a local file has | ||
95 | * been selected in the filedialog or was set via @ref setURL(). | ||
96 | * Default is false, not showing file:/ | ||
97 | * @see #showLocalProtocol | ||
98 | */ | ||
99 | void setShowLocalProtocol( bool b ); | ||
100 | |||
101 | /** | ||
102 | * Sets the mode of the file dialog. | ||
103 | * Note: you can only select one file with the filedialog, | ||
104 | * so KFile::Files doesn't make much sense. | ||
105 | * @see KFileDialog::setMode() | ||
106 | */ | ||
107 | void setMode( unsigned int m ); | ||
108 | |||
109 | /** | ||
110 | * Sets the filter for the file dialog. | ||
111 | * @see KFileDialog::setFilter() | ||
112 | */ | ||
113 | void setFilter( const QString& filter ); | ||
114 | |||
115 | /** | ||
116 | * @returns whether local files will be prefixed with file:/ in the | ||
117 | * lineedit | ||
118 | * @see #setShowLocalProtocol | ||
119 | */ | ||
120 | bool showLocalProtocol() const { return myShowLocalProt; } | ||
121 | |||
122 | /** | ||
123 | * @returns a pointer to the filedialog | ||
124 | * You can use this to customize the dialog, e.g. to specify a filter. | ||
125 | * Never returns 0L. | ||
126 | */ | ||
127 | virtual KFileDialog * fileDialog() const; | ||
128 | |||
129 | /** | ||
130 | * @returns a pointer to the lineedit, either the default one, or the | ||
131 | * special one, if you used the special constructor. | ||
132 | * | ||
133 | * It is provided so that you can e.g. set an own completion object | ||
134 | * (e.g. @ref KShellCompletion) into it. | ||
135 | */ | ||
136 | KLineEdit * lineEdit() const; | ||
137 | |||
138 | /** | ||
139 | * @returns a pointer to the combobox, in case you have set one using the | ||
140 | * special constructor. Returns 0L otherwise. | ||
141 | */ | ||
142 | //US KComboBox * comboBox() const; | ||
143 | |||
144 | /** | ||
145 | * @returns a pointer to the pushbutton. It is provided so that you can | ||
146 | * specify an own pixmap or a text, if you really need to. | ||
147 | */ | ||
148 | QPushButton * button() const; | ||
149 | |||
150 | /** | ||
151 | * @returns the KURLCompletion object used in the lineedit/combobox. | ||
152 | */ | ||
153 | //US KURLCompletion *completionObject() const { return myCompletion; } | ||
154 | |||
155 | /** | ||
156 | * @returns an object, suitable for use with KEditListBox. It allows you | ||
157 | * to put this KURLRequester into a KEditListBox. | ||
158 | * Basically, do it like this: | ||
159 | * <pre> | ||
160 | * KURLRequester *req = new KURLRequester( someWidget ); | ||
161 | * [...] | ||
162 | * KEditListBox *editListBox = new KEditListBox( i18n("Some Title"), req->customEditor(), someWidget ); | ||
163 | * </pre> | ||
164 | * @since 3.1 | ||
165 | */ | ||
166 | //US KEditListBox::CustomEditor customEditor(); | ||
167 | |||
168 | public slots: | ||
169 | /** | ||
170 | * Sets the url in the lineedit to @p url. Depending on the state of | ||
171 | * @ref showLocalProtocol(), file:/ on local files will be shown or not. | ||
172 | * @since 3.1 | ||
173 | */ | ||
174 | void setURL( const QString& url ); | ||
175 | |||
176 | /** | ||
177 | * @reimp | ||
178 | * Sets the caption of the file dialog. | ||
179 | * @since 3.1 | ||
180 | */ | ||
181 | virtual void setCaption( const QString& caption ); | ||
182 | |||
183 | /** | ||
184 | * Clears the lineedit/combobox. | ||
185 | */ | ||
186 | void clear(); | ||
187 | |||
188 | signals: | ||
189 | // forwards from LineEdit | ||
190 | /** | ||
191 | * Emitted when the text in the lineedit changes. | ||
192 | * The parameter contains the contents of the lineedit. | ||
193 | * @since 3.1 | ||
194 | */ | ||
195 | void textChanged( const QString& ); | ||
196 | |||
197 | /** | ||
198 | * Emitted when return or enter was pressed in the lineedit. | ||
199 | */ | ||
200 | void returnPressed(); | ||
201 | |||
202 | /** | ||
203 | * Emitted when return or enter was pressed in the lineedit. | ||
204 | * The parameter contains the contents of the lineedit. | ||
205 | */ | ||
206 | void returnPressed( const QString& ); | ||
207 | |||
208 | /** | ||
209 | * Emitted before the filedialog is going to open. Connect | ||
210 | * to this signal to "configure" the filedialog, e.g. set the | ||
211 | * filefilter, the mode, a preview-widget, etc. It's usually | ||
212 | * not necessary to set a URL for the filedialog, as it will | ||
213 | * get set properly from the editfield contents. | ||
214 | * | ||
215 | * If you use multiple KURLRequesters, you can connect all of them | ||
216 | * to the same slot and use the given KURLRequester pointer to know | ||
217 | * which one is going to open. | ||
218 | */ | ||
219 | void openFileDialog( KURLRequester * ); | ||
220 | |||
221 | /** | ||
222 | * Emitted when the user changed the URL via the file dialog. | ||
223 | * The parameter contains the contents of the lineedit. | ||
224 | */ | ||
225 | void urlSelected( const QString& ); | ||
226 | |||
227 | protected: | ||
228 | void init(); | ||
229 | |||
230 | //US KURLCompletion * myCompletion; | ||
231 | |||
232 | |||
233 | private: | ||
234 | KURLDragPushButton * myButton; | ||
235 | bool myShowLocalProt; | ||
236 | mutable KFileDialog * myFileDialog; | ||
237 | |||
238 | |||
239 | protected slots: | ||
240 | /** | ||
241 | * Called when the button is pressed to open the filedialog. | ||
242 | * Also called when @ref KStdAccel::Open (default is Ctrl-O) is pressed. | ||
243 | */ | ||
244 | void slotOpenDialog(); | ||
245 | |||
246 | private slots: | ||
247 | void slotUpdateURL(); | ||
248 | |||
249 | protected: | ||
250 | virtual void virtual_hook( int id, void* data ); | ||
251 | private: | ||
252 | class KURLRequesterPrivate; | ||
253 | KURLRequesterPrivate *d; | ||
254 | }; | ||
255 | /*US | ||
256 | class KURLComboRequester : public KURLRequester // For use in Qt Designer | ||
257 | { | ||
258 | Q_OBJECT | ||
259 | public: | ||
260 | */ | ||
261 | /** | ||
262 | * Constructs a KURLRequester widget with a combobox. | ||
263 | */ | ||
264 | /*US | ||
265 | KURLComboRequester( QWidget *parent=0, const char *name=0 ); | ||
266 | }; | ||
267 | */ | ||
268 | |||
269 | #endif // KURLREQUESTER_H | ||