extensionmanager.cpp

/*
    This file is part of KAddressbook.
    Copyright (c) 2003 Tobias Koenig <tokoe@kde.org>
 
    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.
 
    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, write to the Free Software
    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
    As a special exception, permission is given to link this program
    with any edition of TQt, and distribute the resulting executable,
    without including the source code for TQt in the source distribution.
*/
 
#include <tdeactionclasses.h>
#include <tdeconfig.h>
#include <kdebug.h>
#include <tdelocale.h>
#include <ktrader.h>
 
#include <tqlayout.h>
#include <tqobjectlist.h>
#include <tqsignalmapper.h>
#include <tqsplitter.h>
#include <tqtimer.h>
#include <tqwidgetstack.h>
 
#include "addresseeeditorextension.h"
#include "core.h"
#include "kabprefs.h"
 
#include "extensionmanager.h"
 
ExtensionData::ExtensionData() : action( 0 ), widget( 0 ), weight( 0 ), isDetailsExtension( false )
{
}
 
ExtensionManager::ExtensionManager( TQWidget* extensionBar, TQWidgetStack* detailsStack, KAB::Core *core, TQObject *parent,
                                    const char *name )
    : TQObject( parent, name ), mExtensionBar( extensionBar ), mCore( core ),
      mMapper( 0 ), mDetailsStack( detailsStack ), mActiveDetailsWidget( 0 )
{
  Q_ASSERT( mExtensionBar );
  TQVBoxLayout* layout = new TQVBoxLayout( mExtensionBar );
  mSplitter = new TQSplitter( mExtensionBar );
  mSplitter->setOrientation( TQt::Vertical );
  layout->addWidget( mSplitter );
 
  createExtensionWidgets();
 
  mActionCollection = new TDEActionCollection( this, "ActionCollection" );
 
  extensionBar->setShown( false );
  TQTimer::singleShot( 0, this, TQ_SLOT( createActions() ) );
}
 
ExtensionManager::~ExtensionManager()
{
}
 
 
void ExtensionManager::restoreSettings()
{
  const TQStringList activeExtensions = KABPrefs::instance()->activeExtensions();
 
  typedef TQMap<TQString, ExtensionData>::ConstIterator ConstIterator;
  for ( ConstIterator it = mExtensionMap.begin(), end = mExtensionMap.end(); it != end; ++it ) {
    if ( activeExtensions.contains( it.data().identifier ) ) {
      TDEToggleAction *action = static_cast<TDEToggleAction*>( it.data().action );
      if ( action )
        action->setChecked( true );
      setExtensionActive( it.data().identifier, true );
    }
  }
  const TQValueList<int> sizes = KABPrefs::instance()->extensionsSplitterSizes();
  mSplitter->setSizes( sizes );
}
 
void ExtensionManager::saveSettings()
{
  KABPrefs::instance()->setActiveExtensions( mActiveExtensions );
  KABPrefs::instance()->setExtensionsSplitterSizes( mSplitter->sizes() );
}
 
void ExtensionManager::reconfigure()
{
  saveSettings();
  createExtensionWidgets();
  createActions();
  restoreSettings();
  mExtensionBar->setShown( !mActiveExtensions.isEmpty() );
}
 
bool ExtensionManager::isQuickEditVisible() const
{
  return mActiveExtensions.contains( "contact_editor" );
}
 
void ExtensionManager::setSelectionChanged()
{
  for ( TQStringList::ConstIterator it = mActiveExtensions.begin(), end = mActiveExtensions.end(); it != end; ++it ) {
    if ( mExtensionMap.contains( *it ) && mExtensionMap[*it].widget )
      mExtensionMap[*it].widget->contactsSelectionChanged();
  }
}
 
void ExtensionManager::activationToggled( const TQString &extid )
{
  if ( !mExtensionMap.contains( extid ) )
    return;
  const ExtensionData data = mExtensionMap[ extid ];
  const bool activated = data.action->isChecked();
  setExtensionActive( extid, activated );
}
 
void ExtensionManager::setExtensionActive( const TQString& extid, bool active )
{
  if ( !mExtensionMap.contains( extid ) )
    return;
  if ( mActiveExtensions.contains( extid ) == active )
    return;
  const ExtensionData data = mExtensionMap[ extid ];
  if ( active ) {
    mActiveExtensions.append( extid );
    if ( data.widget ) {
      if ( data.isDetailsExtension ) {
        mActiveDetailsWidget = data.widget;
        emit detailsWidgetActivated( data.widget );
      } else {
          data.widget->show();
      }
      data.widget->contactsSelectionChanged();
    }
  } else {
    mActiveExtensions.remove( extid );
    if ( data.widget && !data.isDetailsExtension ) {
      data.widget->hide();
    }
    if ( data.isDetailsExtension ) {
      mActiveDetailsWidget = 0;
      emit detailsWidgetDeactivated( data.widget );
    }
  }
  mExtensionBar->setShown( !mActiveExtensions.isEmpty() );
}
 
void ExtensionManager::createActions()
{
  mCore->guiClient()->unplugActionList( "extensions_list" );
  mActionList.setAutoDelete( true );
  mActionList.clear();
  mActionList.setAutoDelete( false );
 
  delete mMapper;
  mMapper = new TQSignalMapper( this, "SignalMapper" );
  connect( mMapper, TQ_SIGNAL( mapped( const TQString& ) ),
           this, TQ_SLOT( activationToggled( const TQString& ) ) );
 
  ExtensionData::List::ConstIterator it;
  for ( TQMap<TQString, ExtensionData>::Iterator it = mExtensionMap.begin(), end = mExtensionMap.end(); it != end; ++it ) {
    ExtensionData& data = it.data();
    data.action = new TDEToggleAction( data.title, 0, mMapper, TQ_SLOT( map() ),
                                               mActionCollection,
                                               TQString( data.identifier + "_extension" ).latin1() );
    mMapper->setMapping( data.action, data.identifier );
    mActionList.append( data.action );
 
    if ( mActiveExtensions.contains( data.identifier ) )
      data.action->setChecked( true );
  }
 
  mActionList.append( new TDEActionSeparator( mActionCollection ) );
  mCore->guiClient()->plugActionList( "extensions_list", mActionList );
}
 
TQWidget* ExtensionManager::activeDetailsWidget() const
{
    return mActiveDetailsWidget;
}
 
void ExtensionManager::createExtensionWidgets()
{
  // clean up
  for ( TQMap<TQString, ExtensionData>::ConstIterator it = mExtensionMap.begin(), end = mExtensionMap.end(); it != end; ++it ) {
    delete it.data().widget;
  }
  mExtensionMap.clear();
 
  KAB::ExtensionWidget *wdg = 0;
 
  {
    // add addressee editor as default
    wdg = new AddresseeEditorExtension( mCore, mDetailsStack );
    wdg->hide();
 
    connect( wdg, TQ_SIGNAL( modified( const TDEABC::Addressee::List& ) ),
             TQ_SIGNAL( modified( const TDEABC::Addressee::List& ) ) );
    connect( wdg, TQ_SIGNAL( deleted( const TQStringList& ) ),
             TQ_SIGNAL( deleted( const TQStringList& ) ) );
 
    ExtensionData data;
    data.identifier = wdg->identifier();
    data.title = wdg->title();
    data.widget = wdg;
    data.isDetailsExtension = true;
    mExtensionMap.insert( data.identifier, data );
  }
 
  // load the other extensions
  const TDETrader::OfferList plugins = TDETrader::self()->query( "KAddressBook/Extension",
    TQString( "[X-TDE-KAddressBook-ExtensionPluginVersion] == %1" ).arg( KAB_EXTENSIONWIDGET_PLUGIN_VERSION ) );
 
  TDETrader::OfferList::ConstIterator it;
  for ( it = plugins.begin(); it != plugins.end(); ++it ) {
    KLibFactory *factory = KLibLoader::self()->factory( (*it)->library().latin1() );
    if ( !factory ) {
      kdDebug(5720) << "ExtensionManager::loadExtensions(): Factory creation failed" << endl;
      continue;
    }
 
    KAB::ExtensionFactory *extensionFactory = static_cast<KAB::ExtensionFactory*>( factory );
 
    if ( !extensionFactory ) {
      kdDebug(5720) << "ExtensionManager::loadExtensions(): Cast failed" << endl;
      continue;
    }
 
    wdg = extensionFactory->extension( mCore, mSplitter );
    if ( wdg ) {
      if ( wdg->identifier() == "distribution_list_editor_ng" )
          mSplitter->moveToFirst( wdg );
      wdg->hide();
      connect( wdg, TQ_SIGNAL( modified( const TDEABC::Addressee::List& ) ),
               TQ_SIGNAL( modified( const TDEABC::Addressee::List& ) ) );
      connect( wdg, TQ_SIGNAL( deleted( const TQStringList& ) ),
               TQ_SIGNAL( deleted( const TQStringList& ) ) );
 
      ExtensionData data;
      data.identifier = wdg->identifier();
      data.title = wdg->title();
      data.widget = wdg;
      mExtensionMap.insert( data.identifier, data );
    }
  }
}
 
#include "extensionmanager.moc"