Page Menu
Home
Phorge
Search
Configure Global Search
Log In
Files
F16571178
No One
Temporary
Actions
View File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Flag For Later
Award Token
Size
49 KB
Referenced Files
None
Subscribers
None
View Options
diff --git a/blogilo/src/mainwindow.cpp b/blogilo/src/mainwindow.cpp
index 732dc6db41..6abb8e91c4 100644
--- a/blogilo/src/mainwindow.cpp
+++ b/blogilo/src/mainwindow.cpp
@@ -1,672 +1,674 @@
/*
This file is part of Blogilo, A KDE Blogging Client
Copyright (C) 2008-2010 Mehrdad Momeny <mehrdad.momeny@gmail.com>
Copyright (C) 2008-2010 Golnaz Nilieh <g382nilieh@gmail.com>
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of
the License or (at your option) version 3 or any later version
accepted by the membership of KDE e.V. (or its successor approved
by the membership of KDE e.V.), which shall act as a proxy
defined in Section 14 of version 3 of the license.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, see http://www.gnu.org/licenses/
*/
#include "mainwindow.h"
#include "global.h"
#include "dbman.h"
#include "toolbox.h"
#include "postentry.h"
#include "addeditblog.h"
#include "backend.h"
#include "bilbomedia.h"
#include "settings.h"
#include "bilboblog.h"
// #include "composer/multilinetextedit.h"
#include "blogsettings.h"
// #include "htmleditor.h"
#include "ui_advancedsettingsbase.h"
#include "ui_settingsbase.h"
#include "ui_editorsettingsbase.h"
#include <kdeversion.h>
#include <ktabwidget.h>
#include <KStatusNotifierItem>
#include <kstatusbar.h>
#include <KToggleAction>
#include <kactioncollection.h>
#include <kconfigdialog.h>
#include <kdebug.h>
#include <kmessagebox.h>
#include <KDE/KLocale>
#include <QDir>
#include <QDockWidget>
#include <QProgressBar>
#include <KSelectAction>
#include <kimagefilepreview.h>
#include "uploadmediadialog.h"
#include <QTimer>
#include <KToolInvocation>
#include <KMenu>
#define TIMEOUT 5000
MainWindow::MainWindow()
: KXmlGuiWindow(), activePost(0), systemTray(0), previousActivePostIndex(-1),
busyNumber(0), progress(0), mCurrentBlogId(__currentBlogId)
{
kDebug();
setWindowTitle( i18n("Blogilo") );
tabPosts = new KTabWidget( this );
tabPosts->setElideMode( Qt::ElideRight );
tabPosts->setTabsClosable( true );
// #if KDE_IS_VERSION( 4, 5, 80 )
/// does not build with KDE 4.5.80: Compile Error: ‘QTabBar* QTabWidget::tabBar() const’ is protected
// tabPosts->tabBar()->setSelectionBehaviorOnRemove( QTabBar::SelectPreviousTab );
// #else
tabPosts->setTabCloseActivatePrevious( true );
// #endif
tabPosts->setDocumentMode(true);
connect( tabPosts, SIGNAL( tabCloseRequested( int ) ), this, SLOT( slotRemovePostEntry( int ) ) );
setCentralWidget( tabPosts );
// this->setDockOptions( QMainWindow::ForceTabbedDocks);
toolbox = new Toolbox( this );
toolboxDock = new QDockWidget( i18n( "Toolbox" ), this );
toolboxDock->setAllowedAreas( Qt::RightDockWidgetArea | Qt::LeftDockWidgetArea );
toolboxDock->setFeatures( QDockWidget::AllDockWidgetFeatures );
toolboxDock->setObjectName( "dock_toolbox" );
toolbox->setObjectName( "toolbox" );
toolboxDock->setWidget( toolbox );
this->addDockWidget( Qt::RightDockWidgetArea, toolboxDock );
//btnRemovePost = new QToolButton( tabPosts );
//btnRemovePost->setIcon( KIcon( "tab-close" ) );
//btnRemovePost->setToolTip( i18n( "Close tab" ) );
//tabPosts->setCornerWidget( btnRemovePost, Qt::TopRightCorner );
//connect( btnRemovePost, SIGNAL( clicked( bool ) ), this, SLOT( slotRemovePostEntry() ) );
// then, setup our actions
setupActions();
// add a status bar
statusBar()->show();
// toolbox->show();
// a call to KXmlGuiWindow::setupGUI() populates the GUI
// with actions, using KXMLGUI.
// It also applies the saved mainwindow settings, if any, and ask the
// mainwindow to automatically save settings if changed: window size,
// toolbar position, icon size, etc.
setupGUI();
toolbox->setVisible( Settings::showToolboxOnStart() );
actionCollection()->action("toggle_toolbox")->setChecked( Settings::showToolboxOnStart() );
setupSystemTray();
connect( tabPosts, SIGNAL( currentChanged( int ) ), this, SLOT( slotActivePostChanged( int ) ) );
connect( toolbox, SIGNAL( sigEntrySelected( BilboPost &, int ) ), this, SLOT( slotNewPostOpened( BilboPost&, int ) ) );
// connect( toolbox, SIGNAL( sigCurrentBlogChanged( int ) ), this, SLOT( slotCurrentBlogChanged( int ) ) );
connect( toolbox, SIGNAL( sigError( const QString& ) ), this, SLOT( slotError( const QString& ) ) );
connect( toolbox, SIGNAL( sigBusy(bool) ), this, SLOT( slotBusy(bool) ));
QList<BilboBlog*> blogList = DBMan::self()->blogList().values();
int count = blogList.count();
for(int i=0; i < count; ++i) {
QAction *act = new QAction( blogList[i]->title(), blogs );
act->setCheckable( true );
act->setData( blogList[i]->id() );
blogs->addAction( act );
}
connect( blogs, SIGNAL(triggered( QAction* )), this, SLOT(currentBlogChanged(QAction*)) );
QTimer::singleShot( 0, this, SLOT( loadTempPosts() ) );
}
MainWindow::~MainWindow()
{
kDebug();
}
bool MainWindow::queryExit()
{
kDebug();
writeConfigs();
if( !DBMan::self()->clearTempEntries() )
kDebug()<<"Could not erase temp_post table: "<< DBMan::self()->lastErrorText();
int count = tabPosts->count();
if(count > 0) {
toolbox->getFieldsValue(activePost->currentPost());
for(int i =0; i<count; ++i) {
PostEntry* pst = qobject_cast<PostEntry*>(tabPosts->widget(i));
DBMan::self()->saveTempEntry(*pst->currentPost(), pst->currentPostBlogId());
}
}
return true;
}
void MainWindow::setupActions()
{
KStandardAction::quit( qApp, SLOT( quit() ), actionCollection() );
KStandardAction::preferences( this, SLOT( optionsPreferences() ), actionCollection() );
// custom menu and menu item
KAction *actNewPost = new KAction( KIcon( "document-new" ), i18n( "New Post" ), this );
actionCollection()->addAction( QLatin1String( "new_post" ), actNewPost );
actNewPost->setShortcut( Qt::CTRL + Qt::Key_N );
connect( actNewPost, SIGNAL( triggered( bool ) ), this, SLOT( slotCreateNewPost() ) );
KAction *actAddBlog = new KAction( KIcon( "list-add" ), i18n( "Add Blog..." ), this );
actionCollection()->addAction( QLatin1String( "add_blog" ), actAddBlog );
connect( actAddBlog, SIGNAL( triggered( bool ) ), this, SLOT( addBlog() ) );
KAction *actPublish = new KAction( KIcon( "arrow-up" ), i18n( "Submit..." ), this );
actionCollection()->addAction( QLatin1String( "publish_post" ), actPublish );
connect( actPublish, SIGNAL( triggered( bool ) ), this, SLOT( slotPublishPost() ) );
KAction *actUpload = new KAction( KIcon( "upload-media" ), i18n( "Upload Media..." ), this );
actionCollection()->addAction( QLatin1String( "upload_media" ), actUpload );
connect( actUpload, SIGNAL( triggered( bool ) ), this, SLOT( uploadMediaObject() ) );
KAction *actSaveLocally = new KAction( KIcon( "document-save" ), i18n( "Save Locally" ), this );
actionCollection()->addAction( QLatin1String( "save_locally" ), actSaveLocally );
actSaveLocally->setShortcut( Qt::CTRL + Qt::Key_S );
connect( actSaveLocally, SIGNAL( triggered( bool ) ), this, SLOT( slotSavePostLocally() ) );
KToggleAction *actToggleToolboxVisible = new KToggleAction( i18n( "Show Toolbox" ), this );
actionCollection()->addAction( QLatin1String( "toggle_toolbox" ), actToggleToolboxVisible );
actToggleToolboxVisible->setShortcut( Qt::CTRL + Qt::Key_T );
connect( actToggleToolboxVisible, SIGNAL( toggled( bool ) ),
this, SLOT( slotToggleToolboxVisible( bool ) ) );
connect( toolboxDock, SIGNAL(visibilityChanged(bool)),
this, SLOT( slotToolboxVisibilityChanged(bool) ) );
blogs = new KSelectAction( this );
actionCollection()->addAction( QLatin1String( "blogs_list" ), blogs );
KAction *actOpenBlog = new KAction(KIcon("applications-internet"), i18n("Open in browser"), this);
actionCollection()->addAction( QLatin1String("open_blog_in_browser"), actOpenBlog);
actOpenBlog->setToolTip(i18n("Open current blog in browser"));
connect( actOpenBlog, SIGNAL(triggered(bool)), this, SLOT(slotOpenCurrentBlogInBrowser()) );
}
void MainWindow::loadTempPosts()
{
kDebug();
QMap<BilboPost*, int> tempList = DBMan::self()->listTempPosts();
int count = tempList.count();
if( count > 0 ){
QMap<BilboPost*, int>::ConstIterator it = tempList.constBegin();
QMap<BilboPost*, int>::ConstIterator endIt = tempList.constEnd();
for( ; it != endIt; ++it ) {
createPostEntry(it.value(), (*it.key()));
}
} else {
slotCreateNewPost();
}
// activePost = qobject_cast<PostEntry*>( tabPosts->currentWidget() );
previousActivePostIndex = 0;
if( activePost )
setCurrentBlog( activePost->currentPostBlogId() );
}
void MainWindow::setCurrentBlog( int blog_id )
{
kDebug()<<blog_id;
if(blog_id == -1) {
blogs->setCurrentItem( -1 );
toolbox->setCurrentBlogId( blog_id );
// actionCollection()->action("publish_post")->setEnabled( false );
return;
}
int count = blogs->items().count();
for (int i=0; i<count; ++i) {
if( blogs->action(i)->data().toInt() == blog_id ) {
blogs->setCurrentItem( i );
currentBlogChanged( blogs->action( i ) );
break;
}
}
}
void MainWindow::currentBlogChanged( QAction *act )
{
if( act ) {
if( mCurrentBlogId == act->data().toInt() )
return;
mCurrentBlogId = act->data().toInt();
// __currentBlogId = mCurrentBlogId;
if( activePost ) {
// actionCollection()->action("publish_post")->setEnabled( true );
activePost->setCurrentPostBlogId( mCurrentBlogId );
} else {
// actionCollection()->action("publish_post")->setEnabled( false );
}
blogs->setToolTip( DBMan::self()->blogList().value( mCurrentBlogId )->blogUrl() );
} else {
mCurrentBlogId = -1;
if( activePost )
activePost->setCurrentPostBlogId( mCurrentBlogId );
}
toolbox->setCurrentBlogId( mCurrentBlogId );
}
void MainWindow::slotCreateNewPost()
{
kDebug();
tabPosts->setCurrentWidget( createPostEntry( mCurrentBlogId, BilboPost()) );
if( mCurrentBlogId == -1 ) {
if( blogs->items().count() > 0 ) {
blogs->setCurrentItem( 0 );
currentBlogChanged( blogs->action( 0 ) );
}
}
if ( this->isVisible() == false ) {
this->show();
}
}
void MainWindow::optionsPreferences()
{
// The preference dialog is derived from prefs_base.ui
//
// compare the names of the widgets in the .ui file
// to the names of the variables in the .kcfg file
//avoid having 2 dialogs shown
if ( KConfigDialog::showDialog( "settings" ) ) {
return;
}
KConfigDialog *dialog = new KConfigDialog( this, "settings", Settings::self() );
QWidget *generalSettingsDlg = new QWidget;
generalSettingsDlg->setAttribute( Qt::WA_DeleteOnClose );
Ui::SettingsBase ui_prefs_base;
Ui::EditorSettingsBase ui_editorsettings_base;
ui_prefs_base.setupUi( generalSettingsDlg );
BlogSettings *blogSettingsDlg = new BlogSettings;
blogSettingsDlg->setAttribute( Qt::WA_DeleteOnClose );
connect( blogSettingsDlg, SIGNAL(blogAdded(const BilboBlog &)),
this, SLOT(slotBlogAdded(const BilboBlog &)) );
connect( blogSettingsDlg, SIGNAL(blogEdited(const BilboBlog &)),
this, SLOT(slotBlogEdited(const BilboBlog &)) );
connect( blogSettingsDlg, SIGNAL(blogRemoved(int)), this, SLOT(slotBlogRemoved(int)) );
QWidget *editorSettingsDlg = new QWidget;
editorSettingsDlg->setAttribute( Qt::WA_DeleteOnClose );
ui_editorsettings_base.setupUi( editorSettingsDlg );
QWidget *advancedSettingsDlg = new QWidget;
advancedSettingsDlg->setAttribute( Qt::WA_DeleteOnClose );
Ui::AdvancedSettingsBase ui_advancedsettings_base;
ui_advancedsettings_base.setupUi( advancedSettingsDlg );
// QWidget *htmlEditorSettings = HtmlEditor::self()->configPage( 0, dialog );
// dialog->addPage( htmlEditorSettings, i18n( "HTML Editor" ), "configure" );
dialog->addPage( generalSettingsDlg, i18nc( "Configure Page", "General" ), "configure" );
dialog->addPage( blogSettingsDlg, i18nc( "Configure Page", "Blogs" ), "document-properties");
dialog->addPage( editorSettingsDlg, i18nc( "Configure Page", "Editor" ), "accessories-text-editor" );
dialog->addPage( advancedSettingsDlg, i18nc( "Configure Page", "Advanced" ), "applications-utilities");
connect( dialog, SIGNAL( settingsChanged( const QString& ) ), this, SIGNAL( settingsChanged() ) );
connect( dialog, SIGNAL(settingsChanged(const QString& )), this, SLOT(slotSettingsChanged()) );
connect( dialog, SIGNAL(destroyed(QObject*)), this, SLOT(slotDialogDestroyed(QObject*)));
dialog->setAttribute( Qt::WA_DeleteOnClose );
dialog->resize( Settings::configWindowSize() );
dialog->show();
}
void MainWindow::slotSettingsChanged()
{
setupSystemTray();
}
void MainWindow::slotDialogDestroyed( QObject *win )
{
QSize size = qobject_cast<QWidget *>(win)->size();
QString name = win->objectName();
if(name == "settings") {
Settings::setConfigWindowSize( size );
}
}
void MainWindow::addBlog()
{
AddEditBlog *addEditBlogWindow = new AddEditBlog( -1, this );
addEditBlogWindow->setWindowModality( Qt::ApplicationModal );
addEditBlogWindow->setAttribute( Qt::WA_DeleteOnClose );
connect( addEditBlogWindow, SIGNAL( sigBlogAdded( const BilboBlog& ) ),
this, SLOT( slotBlogAdded( const BilboBlog& ) ) );
addEditBlogWindow->show();
}
void MainWindow::slotBlogAdded( const BilboBlog &blog )
{
QAction *act = new QAction( blog.title(), blogs );
act->setCheckable( true );
act->setData( blog.id() );
blogs->addAction( act );
blogs->setCurrentAction( act );
currentBlogChanged( act );
toolbox->slotReloadCategoryList();
toolbox->slotUpdateEntries( 20 );
}
void MainWindow::slotBlogEdited( const BilboBlog &blog )
{
int count = blogs->actions().count();
for(int i=0; i< count; ++i){
if( blogs->action( i )->data().toInt() == blog.id() ) {
blogs->action( i )->setText( blog.title() );
break;
}
}
}
void MainWindow::slotBlogRemoved( int blog_id )
{
int count = blogs->actions().count();
for(int i=0; i< count; ++i){
if( blogs->action( i )->data().toInt() == blog_id ) {
if( blogs->currentItem() == i ) {
blogs->setCurrentItem( i-1 );
currentBlogChanged( blogs->action( i-1 ) );
}
blogs->removeAction( blogs->action( i ) );
if(blogs->currentItem() == -1)
toolbox->clearFields();
break;
}
}
}
void MainWindow::setupSystemTray()
{
if( Settings::enableSysTrayIcon()) {
if ( !systemTray ) {
systemTray = new KStatusNotifierItem( this );
systemTray->setIconByName("blogilo");
systemTray->setToolTip( "blogilo", i18n("Blogilo"), i18n("A KDE Blogging Client") );
systemTray->contextMenu()->addAction( actionCollection()->action("new_post") );
systemTray->setCategory(KStatusNotifierItem::ApplicationStatus);
systemTray->setStatus(KStatusNotifierItem::Active);
}
} else if( systemTray ) {
systemTray->deleteLater();
systemTray = 0;
}
}
void MainWindow::slotUploadAllChanges()
{
kDebug();
}
void MainWindow::slotPostTitleChanged( const QString& title )
{
// kDebug();
tabPosts->setTabText( tabPosts->currentIndex(), title );
}
void MainWindow::slotToggleToolboxVisible( bool isVisible )
{
toolboxDock->setVisible( isVisible );
}
void MainWindow::slotToolboxVisibilityChanged(bool)
{
actionCollection()->action(QLatin1String("toggle_toolbox"))->setChecked( toolboxDock->isVisibleTo(this) );
}
void MainWindow::slotActivePostChanged( int index )
{
kDebug() << "new post index: " << index << "\tPrev Index: " << previousActivePostIndex;
activePost = qobject_cast<PostEntry*>( tabPosts->widget( index ) );
PostEntry *prevActivePost = qobject_cast<PostEntry*>( tabPosts->widget( previousActivePostIndex ) );
int activePostBlogId = -1;
int prevPostBlogId = -1;
if (( prevActivePost != 0 ) && ( index != previousActivePostIndex ) ) {
prevPostBlogId = prevActivePost->currentPostBlogId();
toolbox->getFieldsValue( prevActivePost->currentPost() );
prevActivePost->setCurrentPostBlogId( mCurrentBlogId );
}
if ( index >= 0 ) {
activePostBlogId = activePost->currentPostBlogId();
if ( activePostBlogId != -1 && activePostBlogId != prevPostBlogId ) {
setCurrentBlog( activePostBlogId );
}
toolbox->setFieldsValue( activePost->currentPost() );
} else {
kError() << "ActivePost is NULL! tabPosts Current index is: " << tabPosts->currentIndex() ;
}
previousActivePostIndex = index;
}
void MainWindow::slotPublishPost()
{
kDebug();
if ( mCurrentBlogId == -1 ) {
KMessageBox::sorry( this, i18n( "You have to select a blog to publish this post to." ) );
kDebug() << "Blog id not sets correctly.";
return;
}
if( !activePost || tabPosts->currentIndex() == -1) {
KMessageBox::sorry( this, i18n( "There is no open post to submit." ) );
kDebug() << "There isn't any post";
return;
}
toolbox->getFieldsValue( activePost->currentPost() );
// post.setPrivate( false );
activePost->submitPost( mCurrentBlogId, *activePost->currentPost() );
}
void MainWindow::slotRemovePostEntry( int pos )
{
kDebug();
PostEntry *widget = qobject_cast<PostEntry*>( tabPosts->widget( pos ) );
if( !widget ) {
if( activePost )
widget = activePost;
else
return;
}
DBMan::self()->removeTempEntry( *widget->currentPost() );
tabPosts->removePage(widget);
widget->close();
// if(tabPosts->count() == 1)
// tabPosts->setTabBarHidden(true);
// else
// tabPosts->setTabBarHidden(false);
// if( tabPosts->count() == 0 ){
// slotCreateNewPost();
// previousActivePostIndex = 0;
// }
if( tabPosts->count() < 1 ) {
activePost = 0;
toolbox->resetFields();
// actionCollection()->action("publish_post")->setEnabled( false );
}
}
void MainWindow::slotNewPostOpened( BilboPost &newPost, int blog_id )
{
kDebug();
QWidget * w = createPostEntry( blog_id, newPost );
tabPosts->setCurrentWidget( w );
}
void MainWindow::slotSavePostLocally()
{
kDebug();
if(activePost && tabPosts->count() > 0) {
toolbox->getFieldsValue(activePost->currentPost());
activePost->saveLocally();
toolbox->reloadLocalPosts();
}
}
void MainWindow::slotError( const QString & errorMessage )
{
kDebug() << "Error message: " << errorMessage;
KMessageBox::detailedError( this, i18n( "An error occurred in the last transaction." ), errorMessage );
statusBar()->clearMessage();
slotBusy(false);
}
void MainWindow::writeConfigs()
{
kDebug();
if ( toolboxDock->isVisible() )
Settings::setShowToolboxOnStart( true );
else
Settings::setShowToolboxOnStart( false );
}
void MainWindow::keyPressEvent( QKeyEvent * event )
{
if ( event->modifiers() == Qt::CTRL ) {
switch ( event->key() ) {
case Qt::Key_1:
toolbox->setCurrentPage( 0 );
break;
case Qt::Key_2:
toolbox->setCurrentPage( 1 );
break;
case Qt::Key_3:
toolbox->setCurrentPage( 2 );
break;
case Qt::Key_4:
toolbox->setCurrentPage( 3 );
break;
case Qt::Key_5:
toolbox->setCurrentPage( 4 );
break;
case Qt::Key_W:
slotRemovePostEntry( tabPosts->currentIndex() );
break;
default:
KXmlGuiWindow::keyPressEvent( event );
break;
}
}
}
void MainWindow::postManipulationDone( bool isError, const QString &customMessage )
{
kDebug();
if(isError){
KMessageBox::detailedError(this, i18n("Submitting post failed"), customMessage);
} else {
PostEntry *entry = qobject_cast<PostEntry*>(sender());
- if(entry && KMessageBox::questionYesNo(this, i18n("%1\nDo you want to keep the post open?", customMessage),
+ if(entry){
+ if (KMessageBox::questionYesNo(this, i18n("%1\nDo you want to keep the post open?", customMessage),
QString(), KStandardGuiItem::yes(), KStandardGuiItem::no(), "KeepPostOpen") == KMessageBox::No ) {
slotRemovePostEntry( tabPosts->indexOf( entry ) );
- } else {
+ } else {
toolbox->setFieldsValue(entry->currentPost());
+ }
}
toolbox->slotLoadEntriesFromDB( mCurrentBlogId );
}
this->unsetCursor();
toolbox->unsetCursor();
}
void MainWindow::slotBusy(bool isBusy)
{
kDebug()<<"isBusy="<<isBusy<<"\tbusyNumber="<<busyNumber;
if(isBusy){
this->setCursor(Qt::BusyCursor);
toolbox->setCursor( Qt::BusyCursor );
++busyNumber;
if(!progress){
progress = new QProgressBar(statusBar());
progress->setMinimum( 0 );
progress->setMaximum( 0 );
progress->setFixedSize(250, 17);
statusBar()->addPermanentWidget(progress);
}
} else {
--busyNumber;
if( busyNumber < 1 ){
this->unsetCursor();
toolbox->unsetCursor();
if(progress){
statusBar()->removeWidget(progress);
progress->deleteLater();
progress = 0;
}
// busyNumber = 0;
}
}
}
QWidget* MainWindow::createPostEntry(int blog_id, const BilboPost& post)
{
kDebug();
PostEntry *temp = new PostEntry( this );
temp->setAttribute( Qt::WA_DeleteOnClose );
temp->setCurrentPost(post);
temp->setCurrentPostBlogId( blog_id );
connect( temp, SIGNAL( postTitleChanged( const QString& ) ),
this, SLOT( slotPostTitleChanged( const QString& ) ) );
connect( temp, SIGNAL( postPublishingDone( bool, const QString& ) ),
this, SLOT( postManipulationDone( bool, const QString& ) ) );
connect( this, SIGNAL( settingsChanged() ), temp, SLOT( settingsChanged() ));
connect( temp, SIGNAL( showStatusMessage(QString,bool)),
this, SLOT(slotShowStatusMessage(QString,bool)));
connect( temp, SIGNAL( sigBusy( bool ) ), this, SLOT( slotBusy( bool ) ) );
tabPosts->addTab( temp, post.title() );
// if(tabPosts->count() == 1)
// tabPosts->setTabBarHidden(true);
// else
// tabPosts->setTabBarHidden(false);
return temp;
}
void MainWindow::slotShowStatusMessage(const QString &message, bool isPermanent)
{
statusBar()->showMessage(message, (isPermanent ? 0 : TIMEOUT));
}
void MainWindow::uploadMediaObject()
{
UploadMediaDialog *uploadDlg = new UploadMediaDialog(this);
connect(uploadDlg, SIGNAL(sigBusy(bool)), SLOT(slotBusy(bool)));
if(mCurrentBlogId == -1)
uploadDlg->init( 0 );
else
uploadDlg->init( DBMan::self()->blog(mCurrentBlogId) );
}
void MainWindow::slotOpenCurrentBlogInBrowser()
{
if (mCurrentBlogId > -1) {
KUrl url( DBMan::self()->blog( mCurrentBlogId )->blogUrl() );
if(url.isValid())
KToolInvocation::invokeBrowser(url.url());
else
KMessageBox::sorry(this, i18n("Cannot find current blog URL."));
}
///TODO
///else show a massege to the user saying that a blog should be selected before.
}
#include "mainwindow.moc"
diff --git a/knode/foldertreewidget.cpp b/knode/foldertreewidget.cpp
index d866c1937e..85f0c7f53e 100644
--- a/knode/foldertreewidget.cpp
+++ b/knode/foldertreewidget.cpp
@@ -1,618 +1,621 @@
/******************************************************************************
*
* This file is part of libkdepim.
*
* Copyright (C) 2008 Szymon Tomasz Stefanek <pragma@kvirc.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*****************************************************************************/
#include "foldertreewidget.h"
#include <kio/global.h> // for KIO::filesize_t and related functions
#include <klineedit.h>
#include <klocale.h>
#include <QHeaderView>
#include <QDropEvent>
#include <QMimeData>
#include <QStyledItemDelegate>
#include <QStyle>
#include <QPainter>
#include <QFontMetrics>
#include <QApplication>
#define FOLDERTREEWIDGETITEM_TYPE ( QTreeWidgetItem::UserType + 0xcafe )
namespace KPIM {
#define ITEM_LABEL_RIGHT_MARGIN 2
#define ITEM_LABEL_TO_UNREADCOUNT_SPACING 2
class FolderTreeWidgetItemLabelColumnDelegate : public QStyledItemDelegate
{
protected:
FolderTreeWidget *mFolderTreeWidget;
public:
FolderTreeWidgetItemLabelColumnDelegate( FolderTreeWidget *parent )
: QStyledItemDelegate( parent ), mFolderTreeWidget( parent ) {};
~FolderTreeWidgetItemLabelColumnDelegate()
{};
virtual QSize sizeHint( const QStyleOptionViewItem &option, const QModelIndex &index ) const
{
QStyleOptionViewItemV4 opt = option;
initStyleOption( &opt, index );
opt.text = "X"; // fake a text (so the height is computed correctly)
opt.features |= QStyleOptionViewItemV2::HasDisplay;
return mFolderTreeWidget->style()->sizeFromContents( QStyle::CT_ItemViewItem, &opt, QSize(), mFolderTreeWidget );
}
virtual void paint( QPainter *painter, const QStyleOptionViewItem &option, const QModelIndex &index ) const
{
//
// The equilibrism in this function attempts to rely on QStyle for most of the job.
//
QStyleOptionViewItemV4 opt = option;
initStyleOption( &opt, index );
opt.text = ""; // draw no text for me, please.. I'll do it in a while
QStyle * style = mFolderTreeWidget->style();
style->drawControl( QStyle::CE_ItemViewItem, &opt, painter, mFolderTreeWidget );
// FIXME: this is plain ugly :D
// OTOH seaching the item by model index is extremely expensive when compared to a cast.
// We're also using static_cast<> instead of dynamic_cast<> to avoid performance loss:
// we actually trust the developer to add only real FolderTreeWidgetItems to this widget.
FolderTreeWidgetItem * item = static_cast<FolderTreeWidgetItem *>( index.internalPointer() );
if ( !item )
return; // ugh :/
// draw the labelText().
QRect textRect = style->subElementRect( QStyle::SE_ItemViewItemText, &opt, mFolderTreeWidget );
textRect.setWidth( textRect.width() - ITEM_LABEL_RIGHT_MARGIN );
// keeping indipendent state variables is faster than saving and restoring the whole painter state
QPen oldPen = painter->pen();
QFont oldFont = painter->font();
if ( item->isCloseToQuota() && ( !( opt.state & QStyle::State_Selected ) ) )
{
painter->setPen( QPen( mFolderTreeWidget->closeToQuotaWarningColor(), 0 ) );
} else {
QPalette::ColorGroup cg = opt.state & QStyle::State_Enabled ? QPalette::Normal : QPalette::Disabled;
if (cg == QPalette::Normal && !(opt.state & QStyle::State_Active))
cg = QPalette::Inactive;
QPalette::ColorRole cr = ( opt.state & QStyle::State_Selected ) ? QPalette::HighlightedText : QPalette::Text;
painter->setPen( QPen( opt.palette.brush( cg, cr ), 0 ) );
}
int unread = item->unreadCount();
int childUnread = item->childrenUnreadCount();
bool displayChildUnread = ( childUnread > 0 ) && ( !item->isExpanded() );
if ( ( unread > 0 ) || displayChildUnread )
{
// font is bold for sure (unread stuff in folder)
QFont f = opt.font;
f.setBold( true );
painter->setFont( f );
QFontMetrics fm( painter->font() ); // use the bold font metrics
if (
( mFolderTreeWidget->unreadColumnIndex() == -1 ) ||
mFolderTreeWidget->isColumnHidden( mFolderTreeWidget->unreadColumnIndex() )
)
{
// we need to paint the unread count too
QString unreadText;
if ( unread > 0 )
{
if ( displayChildUnread )
unreadText = QString("(%1 + %2)").arg( unread ).arg( childUnread );
else
unreadText = QString("(%1)").arg( unread );
} else
unreadText = QString("(0 + %1)").arg( childUnread );
// compute the potential width so we know if elision has to be performed
int unreadWidth = fm.width( unreadText );
int labelWidth = fm.width( item->labelText() );
int maxWidth = labelWidth + ITEM_LABEL_TO_UNREADCOUNT_SPACING + unreadWidth;
QString label;
if ( maxWidth > textRect.width() )
{
// must elide
label = item->elidedLabelText( fm, textRect.width() - ( ITEM_LABEL_TO_UNREADCOUNT_SPACING + unreadWidth ) );
labelWidth = fm.width( label );
// the condition inside this call is an optimization (it's faster than simply label != item->labelText())
item->setLabelTextElided( ( label.length() != item->labelText().length() ) || ( label != item->labelText() ) );
} else {
label = item->labelText();
// no elision needed
item->setLabelTextElided( false );
}
painter->drawText( textRect, Qt::AlignLeft | Qt::TextSingleLine | Qt::AlignVCenter, label );
if ( QApplication::isLeftToRight() )
textRect.setLeft( textRect.left() + labelWidth + ITEM_LABEL_TO_UNREADCOUNT_SPACING );
else
textRect.setRight( textRect.right() - labelWidth - ITEM_LABEL_TO_UNREADCOUNT_SPACING );
if ( !( opt.state & QStyle::State_Selected ) ) {
painter->setPen( QPen( mFolderTreeWidget->unreadCountColor(), 0 ) );
}
painter->drawText( textRect, Qt::AlignLeft | Qt::TextSingleLine | Qt::AlignVCenter, unreadText );
} else {
// got unread messages: bold font but no special text tricks
QString label = item->elidedLabelText( fm, textRect.width() );
// the condition inside this call is an optimization (it's faster than simply label != item->labelText())
item->setLabelTextElided( ( label.length() != item->labelText().length() ) || ( label != item->labelText() ) );
painter->drawText( textRect, Qt::AlignLeft | Qt::TextSingleLine | Qt::AlignVCenter, label );
}
} else {
// no unread messages: normal font, no text tricks
QString label = item->elidedLabelText( opt.fontMetrics, textRect.width() );
// the condition inside this call is an optimization (it's faster than simply label != item->labelText())
item->setLabelTextElided( ( label.length() != item->labelText().length() ) || ( label != item->labelText() ) );
painter->setFont( opt.font );
painter->drawText( textRect, Qt::AlignLeft | Qt::TextSingleLine | Qt::AlignVCenter, label );
}
painter->setPen( oldPen );
painter->setFont( oldFont );
}
virtual void setModelData( QWidget *editor, QAbstractItemModel *model, const QModelIndex &index ) const
{
QStyledItemDelegate::setModelData( editor, model, index );
FolderTreeWidgetItem *item = static_cast<FolderTreeWidgetItem *>( index.internalPointer() );
if ( item ) {
// test if old text != new text
if( item->labelText() != item->text( mFolderTreeWidget->labelColumnIndex() ) ) {
item->setLabelText( item->text( mFolderTreeWidget->labelColumnIndex() ) );
mFolderTreeWidget->emitRenamed( item );
}
}
}
};
FolderTreeWidget::FolderTreeWidget( QWidget *parent , const char *name )
: KPIM::TreeWidget( parent , name ),
mUnreadCountColor( Qt::blue ), mCloseToQuotaWarningColor( Qt::red )
{
mLabelColumnIndex = -1;
mUnreadColumnIndex = -1;
mTotalColumnIndex = -1;
mDataSizeColumnIndex = -1;
setAlternatingRowColors( true );
setAcceptDrops( true );
setAllColumnsShowFocus( true );
setRootIsDecorated( true );
setSortingEnabled( true );
setUniformRowHeights( true ); // optimize please
//setAnimated( true ); // this slows down everything a lot
header()->setSortIndicatorShown( true );
header()->setClickable( true );
//setSelectionMode( Extended );
connect( this, SIGNAL( itemExpanded( QTreeWidgetItem * ) ),
SLOT( updateExpandedState( QTreeWidgetItem * ) ) );
connect( this, SIGNAL( itemCollapsed( QTreeWidgetItem * ) ),
SLOT( updateExpandedState( QTreeWidgetItem * ) ) );
}
int FolderTreeWidget::addLabelColumn( const QString &headerLabel )
{
if ( mLabelColumnIndex == -1 )
{
mLabelColumnIndex = addColumn( headerLabel );
setItemDelegateForColumn( mLabelColumnIndex, new FolderTreeWidgetItemLabelColumnDelegate( this ) );
}
return mLabelColumnIndex;
}
bool FolderTreeWidget::labelColumnVisible() const
{
if ( mLabelColumnIndex == -1 )
return false;
return !isColumnHidden( mLabelColumnIndex );
}
int FolderTreeWidget::addTotalColumn( const QString &headerLabel )
{
if ( mTotalColumnIndex == -1 )
mTotalColumnIndex = addColumn( headerLabel , Qt::AlignRight );
return mTotalColumnIndex;
}
bool FolderTreeWidget::totalColumnVisible() const
{
if ( mTotalColumnIndex == -1 )
return false;
return !isColumnHidden( mTotalColumnIndex );
}
int FolderTreeWidget::addUnreadColumn( const QString &headerLabel )
{
if ( mUnreadColumnIndex == -1 )
mUnreadColumnIndex = addColumn( headerLabel , Qt::AlignRight );
return mUnreadColumnIndex;
}
bool FolderTreeWidget::unreadColumnVisible() const
{
if ( mUnreadColumnIndex == -1 )
return false;
return !isColumnHidden( mUnreadColumnIndex );
}
int FolderTreeWidget::addDataSizeColumn( const QString &headerLabel )
{
if ( mDataSizeColumnIndex == -1 )
mDataSizeColumnIndex = addColumn( headerLabel , Qt::AlignRight );
return mDataSizeColumnIndex;
}
bool FolderTreeWidget::dataSizeColumnVisible() const
{
if ( mDataSizeColumnIndex == -1 )
return false;
return !isColumnHidden( mDataSizeColumnIndex );
}
void FolderTreeWidget::updateColumnForItem( FolderTreeWidgetItem * item, int columnIndex )
{
update( indexFromItem( item, columnIndex ) );
}
void FolderTreeWidget::updateExpandedState( QTreeWidgetItem *item )
{
FolderTreeWidgetItem *folderItem = dynamic_cast<FolderTreeWidgetItem*>( item );
Q_ASSERT( folderItem );
if ( folderItem )
folderItem->updateExpandedState();
}
void FolderTreeWidget::setCloseToQuotaWarningColor( const QColor &clr )
{
mCloseToQuotaWarningColor = clr;
update();
}
void FolderTreeWidget::setUnreadCountColor( const QColor &clr )
{
mUnreadCountColor = clr;
update();
}
void FolderTreeWidget::emitRenamed( QTreeWidgetItem *item )
{
emit renamed( item );
}
FolderTreeWidgetItem::FolderTreeWidgetItem(
FolderTreeWidget *parent,
const QString &label,
Protocol protocol,
FolderType folderType
) : QTreeWidgetItem( parent, FOLDERTREEWIDGETITEM_TYPE ),
mProtocol( protocol ), mFolderType( folderType ), mLabelText( label ),
mTotalCount( 0 ), mUnreadCount( 0 ), mDataSize( -1 ), mIsCloseToQuota( 0 ),
mLabelTextElided( 0 ), mChildrenTotalCount( 0 ), mChildrenUnreadCount( 0 ),
mChildrenDataSize( -1 ), mAlwaysDisplayCounts( false )
{
setText( parent->labelColumnIndex(), label );
}
FolderTreeWidgetItem::FolderTreeWidgetItem(
FolderTreeWidgetItem *parent,
const QString &label,
Protocol protocol,
FolderType folderType
) : QTreeWidgetItem( parent, FOLDERTREEWIDGETITEM_TYPE ),
mProtocol( protocol ), mFolderType( folderType ), mLabelText( label ),
mTotalCount( 0 ), mUnreadCount( 0 ), mDataSize( -1 ), mIsCloseToQuota( 0 ),
mLabelTextElided( 0 ), mChildrenTotalCount( 0 ), mChildrenUnreadCount( 0 ),
mChildrenDataSize( -1 ), mAlwaysDisplayCounts( false )
{
FolderTreeWidget * tree = dynamic_cast< FolderTreeWidget * >( treeWidget() );
if ( tree )
setText( tree->labelColumnIndex(), label );
}
QString FolderTreeWidgetItem::protocolDescription() const
{
switch( mProtocol )
{
case Local:
return i18n( "Local" );
break;
case Imap:
return i18n( "IMAP" );
break;
case CachedImap:
return i18n( "Cached IMAP" );
break;
case News:
return i18n( "News" );
break;
case Search:
return i18n( "Search" );
break;
case NONE:
return i18n( "None" );
break;
default:
break;
}
return i18n( "Unknown" );
}
bool FolderTreeWidgetItem::updateChildrenCounts()
{
int cc = childCount();
if ( cc < 1 )
return false;
int idx = 0;
int oldTotal = mChildrenTotalCount;
int oldUnread = mChildrenUnreadCount;
qint64 oldSize = mChildrenDataSize;
mChildrenTotalCount = 0;
mChildrenUnreadCount = 0;
mChildrenDataSize = 0;
bool gotValidDataSize = false;
while ( idx < cc )
{
FolderTreeWidgetItem *it = static_cast< FolderTreeWidgetItem * >( QTreeWidgetItem::child( idx ) );
mChildrenTotalCount += it->totalCount() + it->childrenTotalCount();
mChildrenUnreadCount += it->unreadCount() + it->childrenUnreadCount();
if ( it->dataSize() >= 0)
{
gotValidDataSize = true;
mChildrenDataSize += it->dataSize();
}
if ( it->childrenDataSize() >= 0 )
{
gotValidDataSize = true;
mChildrenDataSize += it->childrenDataSize();
}
idx++;
}
if ( !gotValidDataSize )
mChildrenDataSize = -1; // keep it invald
return ( oldTotal != mChildrenTotalCount ) ||
( oldUnread != mChildrenUnreadCount ) ||
( oldSize != mChildrenDataSize );
}
void FolderTreeWidgetItem::setLabelText( const QString &label )
{
mLabelText = label;
// We set the text of the item so QStyle will compute the height correctly
FolderTreeWidget * tree = dynamic_cast< FolderTreeWidget * >( treeWidget() );
int idx = tree->labelColumnIndex();
if ( tree && idx >= 0 )
{
setText( idx, label );
setTextAlignment( idx, Qt::AlignRight );
}
}
void FolderTreeWidgetItem::setUnreadCount( int unreadCount )
{
mUnreadCount = unreadCount;
int unreadCountToDisplay = unreadCount;
if ( mChildrenUnreadCount > 0 && !isExpanded() )
unreadCountToDisplay += mChildrenUnreadCount;
FolderTreeWidget * tree = dynamic_cast< FolderTreeWidget * >( treeWidget() );
- int idx = tree->unreadColumnIndex();
- if ( tree && idx >= 0 )
+ if ( tree )
{
- if ( ( parent() || mAlwaysDisplayCounts || !isExpanded() ) && unreadCountToDisplay > 0 )
- setText( idx, QString::number( unreadCountToDisplay ) );
- else
- setText( idx, QString() );
+ int idx = tree->unreadColumnIndex();
+ if ( idx >= 0 )
+ {
+ if ( ( parent() || mAlwaysDisplayCounts || !isExpanded() ) && unreadCountToDisplay > 0 )
+ setText( idx, QString::number( unreadCountToDisplay ) );
+ else
+ setText( idx, QString() );
+ }
setTextAlignment( idx, Qt::AlignRight );
}
}
void FolderTreeWidgetItem::setTotalCount( int totalCount )
{
mTotalCount = totalCount;
int totalCountToDisplay = totalCount;
if ( mChildrenTotalCount > 0 && !isExpanded() )
totalCountToDisplay += mChildrenTotalCount;
FolderTreeWidget * tree = dynamic_cast< FolderTreeWidget * >( treeWidget() );
int idx = tree->totalColumnIndex();
if ( tree && idx >= 0 )
{
// FIXME: Why the "parent()" logic is hardwired here ?
if ( parent() || mAlwaysDisplayCounts || !isExpanded() )
setText( idx, QString::number( totalCountToDisplay ) );
else
setText( idx, QString() );
setTextAlignment( idx, Qt::AlignRight );
}
}
void FolderTreeWidgetItem::setDataSize( qint64 dataSize )
{
mDataSize = dataSize;
QString txt;
QString sizeText = KIO::convertSize( mDataSize >= 0 ? (KIO::filesize_t)mDataSize : (KIO::filesize_t)0 );
QString childSizeText = KIO::convertSize( (KIO::filesize_t)mChildrenDataSize );
// A top level item, they all have size 0
// FIXME: Why this logic is hardwired here ?
if ( !parent() && !mAlwaysDisplayCounts ) {
if ( mChildrenDataSize >= 0 && !isExpanded() )
txt = childSizeText;
else
txt = QString();
}
// Not a top level item (or always displays counts)
else if ( ( mDataSize >= 0 ) || ( mChildrenDataSize >= 0 ) ) {
txt = sizeText;
if ( !isExpanded() ) {
if ( mChildrenDataSize >= 0 )
txt += " + " + childSizeText;
}
}
else
txt = "-";
FolderTreeWidget * tree = dynamic_cast< FolderTreeWidget * >( treeWidget() );
int idx = tree->dataSizeColumnIndex();
if ( tree && idx >= 0 )
{
setText( idx, txt );
setTextAlignment( idx, Qt::AlignRight );
}
}
void FolderTreeWidgetItem::updateExpandedState()
{
// Just trigger an update of the column text, it will all be handled thaere.
setDataSize( mDataSize );
setTotalCount( mTotalCount );
setUnreadCount( mUnreadCount );
}
void FolderTreeWidgetItem::updateColumn( int columnIndex )
{
FolderTreeWidget * tree = dynamic_cast< FolderTreeWidget * >( treeWidget() );
if ( tree ) {
tree->updateColumnForItem( this, columnIndex );
if ( columnIndex!=tree->labelColumnIndex() && !tree->unreadColumnVisible() && tree->labelColumnVisible() ) {
updateColumn( tree->labelColumnIndex() );
}
}
}
void FolderTreeWidgetItem::setIsCloseToQuota( bool closeToQuota )
{
if ( ( mIsCloseToQuota == 1 ) == closeToQuota )
return;
mIsCloseToQuota = closeToQuota ? 1 : 0;
FolderTreeWidget * tree = dynamic_cast< FolderTreeWidget * >( treeWidget() );
if ( tree && tree->labelColumnVisible() )
updateColumn( tree->labelColumnIndex() );
}
bool FolderTreeWidgetItem::operator < ( const QTreeWidgetItem &other ) const
{
// FIXME: Sort by children counts too ?
int sortCol = treeWidget()->sortColumn();
if ( sortCol < 0 )
return true; // just "yes" :D
FolderTreeWidget * w = dynamic_cast< FolderTreeWidget * >( treeWidget() );
if ( w )
{
// sanity check
if ( dynamic_cast<const FolderTreeWidgetItem*>( &other ) )
{
const FolderTreeWidgetItem * oitem = dynamic_cast< const FolderTreeWidgetItem * >( &other );
if ( oitem )
{
if ( sortCol == w->unreadColumnIndex() )
return mUnreadCount < oitem->unreadCount();
if ( sortCol == w->totalColumnIndex() )
return mTotalCount < oitem->totalCount();
if ( sortCol == w->dataSizeColumnIndex() )
return mDataSize < oitem->dataSize();
if ( sortCol == w->labelColumnIndex() )
{
// Special sorting based on the item type
int thisProto = ( int ) mProtocol;
int thatProto = ( int ) oitem->protocol();
if ( thisProto < thatProto )
return true;
if ( thisProto > thatProto )
return false;
int thisType = ( int ) mFolderType;
int thatType = ( int ) oitem->folderType();
if ( thisType < thatType )
return true;
if ( thisType > thatType )
return false;
// and finally compare by name
return mLabelText.toLower() < oitem->labelText().toLower();
}
}
}
}
return text(sortCol) < other.text(sortCol);
}
QString FolderTreeWidgetItem::elidedLabelText( const QFontMetrics &metrics, unsigned int width ) const
{
return metrics.elidedText( labelText(), Qt::ElideRight, width );
}
}
#include "foldertreewidget.moc"
diff --git a/knode/knjobdata.cpp b/knode/knjobdata.cpp
index ac5971b4ae..a521fd99cb 100644
--- a/knode/knjobdata.cpp
+++ b/knode/knjobdata.cpp
@@ -1,207 +1,207 @@
/*
KNode, the KDE newsreader
Copyright (c) 1999-2005 the KNode authors.
See file AUTHORS for details
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation,
Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, US
*/
#include <kdebug.h>
#include <klocale.h>
#include <kio/job.h>
#include <libkdepim/progressmanager.h>
#include "knarticle.h"
#include "knglobals.h"
#include "knnntpaccount.h"
#include "scheduler.h"
//Added by qt3to4:
#include <QTimer>
KNJobConsumer::KNJobConsumer()
{
}
KNJobConsumer::~KNJobConsumer()
{
for ( QList<KNJobData*>::Iterator it = mJobs.begin(); it != mJobs.end(); ++it )
(*it)->c_onsumer = 0;
}
void KNJobConsumer::emitJob( KNJobData *j )
{
if ( j ) {
mJobs.append( j );
knGlobals.scheduler()->addJob( j );
}
}
void KNJobConsumer::jobDone( KNJobData *j )
{
if ( j && mJobs.removeAll( j ) )
processJob( j );
}
void KNJobConsumer::cancelJobs( KNJobItem::Ptr item )
{
Q_FOREACH( KNJobData *job, mJobs ) {
if ( job->data() == item ) {
job->d_ata.reset();
job->cancel();
}
}
}
void KNJobConsumer::processJob( KNJobData *j )
{
delete j;
}
// the assingment of a_ccount may cause race conditions, check again.... (CG)
KNJobData::KNJobData( jobType t, KNJobConsumer *c, KNServerInfo::Ptr a, KNJobItem::Ptr i ) :
t_ype(t), d_ata(i), a_ccount(a),
mError( 0 ),
mCanceled( false ),
c_onsumer( c ),
mJob( 0 ),
mProgressItem( 0 )
{
d_ata->setLocked(true);
}
KNJobData::~KNJobData()
{
if ( d_ata ) {
d_ata->setLocked( false );
}
}
void KNJobData::notifyConsumer()
{
if(c_onsumer)
c_onsumer->jobDone(this);
else
delete this;
}
void KNJobData::cancel()
{
mCanceled = true;
if ( mJob ) {
mJob->kill();
}
if ( mProgressItem ) {
mProgressItem->setStatus( "Canceled" );
mProgressItem->setComplete();
mProgressItem = 0;
}
emitFinished();
}
void KNJobData::emitFinished()
{
QTimer::singleShot( 0, this, SLOT(slotEmitFinished()) );
}
void KNJobData::setupKJob(KJob * job)
{
mJob = job;
if ( job ) {
connect( job, SIGNAL( percent(KJob*, unsigned long) ),
SLOT( slotJobPercent(KJob*, unsigned long) ) );
connect( job, SIGNAL( infoMessage(KJob*, const QString&) ),
SLOT( slotJobInfoMessage(KJob*, const QString&) ) );
}
}
void KNJobData::setupKIOJob( KIO::Job *job )
{
if ( job ) {
if ( account() ) {
if ( account()->encryption() == KNServerInfo::TLS )
job->addMetaData( "tls", "on" );
else
job->addMetaData( "tls", "off" );
}
- }
job->setUiDelegate(0);
setupKJob( job );
+ }
}
void KNJobData::createProgressItem()
{
if ( mProgressItem )
return;
KNNntpAccount::Ptr acc = boost::static_pointer_cast<KNNntpAccount>( account() );
QString msg = i18n( "KNode" );
if ( type() == JTmail )
msg = i18n( "Sending message" );
else {
if ( acc )
msg = acc->name();
}
bool encr = false;
if ( acc && acc->encryption() != KNServerInfo::None )
encr = true;
mProgressItem = KPIM::ProgressManager::createProgressItem( 0,
KPIM::ProgressManager::getUniqueID(), msg, i18n( "Waiting..." ), true, encr );
}
void KNJobData::slotJobPercent( KJob*, unsigned long percent )
{
kDebug(5003) <<"Progress:" << percent;
setProgress( percent );
}
void KNJobData::slotJobInfoMessage( KJob*, const QString &msg )
{
kDebug(5003) <<"Status:" << msg;
setStatus( msg );
}
void KNJobData::slotEmitFinished( )
{
emit finished( this );
}
KUrl KNJobData::baseUrl() const
{
KUrl url;
if ( account()->encryption() == KNServerInfo::SSL )
url.setProtocol( "nntps" );
else
url.setProtocol( "nntp" );
url.setHost( account()->server() );
url.setPort( account()->port() );
if ( account()->needsLogon() ) {
url.setUser( account()->user() );
url.setPass( account()->pass() );
}
return url;
}
void KNJobData::setError( int err, const QString & errMsg )
{
mError = err;
mErrorString = errMsg;
}
#include "knjobdata.moc"
File Metadata
Details
Attached
Mime Type
text/x-diff
Expires
Fri, Nov 1, 10:01 AM (1 d, 21 h)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
10076280
Default Alt Text
(49 KB)
Attached To
Mode
rKP kdepim
Attached
Detach File
Event Timeline
Log In to Comment