Source Code (Use browser search to find items of interest.)

kdelibs'PartManager (./kdelibs/kparts/partmanager.h:45)

class PartManager : public QObject
{
  Q_OBJECT
public:
  // the default policy of a PartManager is Direct!
  enum SelectionPolicy { Direct, TriState };

  /**
   * Create a part manager.
   *
   * @param parent The toplevel widget (window / dialog).
   */
  PartManager( QWidget * parent, const char * name = 0L );
  virtual ~PartManager();

  /**
   * Set the selection policy of the partmanager.
   */
  void setSelectionPolicy( SelectionPolicy policy );
  /**
   * Retrieve the current selection policy.
   */
  SelectionPolicy selectionPolicy() const;

  /**
   * Specify whether the partmanager should handle/allow nested parts or not.
   * This is a property the shell has to set/specify. Per default we assume that the
   * shell cannot handle nested parts. However in case of a KOffice shell for example
   * we allow nested parts.
   * A Part is nested (a child part) if its parent object inherits KParts::Part.
   * If a child part is activated and nested parts are not allowed/handled, then the top parent
   * part in the tree is activated.
   */
  void setAllowNestedParts( bool allow );
  bool allowNestedParts() const;

  /**
   * @internal
   */
  virtual bool eventFilter( QObject *obj, QEvent *ev );

  /**
   * Add a Part to the manager.
   *
   * Sets it to the active part automatically if @p setActive is true (default ).
   */
  virtual void addPart( Part *part, bool setActive = true );

  /**
   * Remove a part from the manager (this does not delete the object) .
   *
   * Sets the active part to 0 if @p part is the @ref activePart() .
   */
  virtual void removePart( Part *part );

  /**
   * Set the active part.
   *
   * The active part receives activation events.
   *
   * @p widget can be used to specify which widget was responsible for the activation.
   * This is important if you have multiple views for a document/part , like in KOffice .
   */
  virtual void setActivePart( Part *part, QWidget *widget = 0L );

  /**
   * Retrieve the active part.
   **/
  virtual Part *activePart() const;

  /**
   * Retrieve the active widget of the current active part (see @ref activePart ).
   */
  virtual QWidget *activeWidget() const;

  /**
   * Set the selected part.
   *
   * The selected part receives selection events.
   *
   * @p widget can be used to specify which widget was responsible for the selection.
   * This is important if you have multiple views for a document/part , like in KOffice .
   */
  virtual void setSelectedPart( Part *part, QWidget *widget = 0L );

  /**
   * Retrieve the current selected part.
   */
  virtual Part *selectedPart() const;

  /**
   * Retrieve the selected widget of the current selected part (see @ref selectedPart ).
   */
  virtual QWidget *selectedWidget() const;

  /**
   * Retrieve the list of parts being managed by the partmanager.
   */
  const QList<Part> *parts() const;

signals:
  /**
   * Emitted when a new part has been added.
   * @see addPart()
   **/
  void partAdded( KParts::Part *part );
  /**
   * Emitted when a part has been removed.
   * @see removePart()
   **/
  void partRemoved( KParts::Part *part );
  /**
   * Emitted when the active part has changed.
   * @see setActivePart()
   **/
  void activePartChanged( KParts::Part *newPart );

protected slots:
  /**
   * Removes a part when it is destroyed.
   **/
  void slotObjectDestroyed();

  /**
   * @internal
   */
  void slotWidgetDestroyed();

private:
  Part * findPartFromWidget( QWidget * widget, const QPoint &pos );

  PartManagerPrivate *d;
};

};

kdelibs'PartManager::PartManager() (./kdelibs/kparts/partmanager.cpp:65)

PartManager::PartManager( QWidget * parent, const char * name )
 : QObject( parent, name )
{
  d = new PartManagerPrivate;

  qApp->installEventFilter( this );

  d->m_policy = Direct;
}

kdelibs'PartManager::~PartManager() (./kdelibs/kparts/partmanager.cpp:75)

PartManager::~PartManager()
{
  // core dumps ... setActivePart( 0L );
  qApp->removeEventFilter( this );
  delete d;
}

kdelibs'PartManager::setSelectionPolicy() (./kdelibs/kparts/partmanager.cpp:82)

void PartManager::setSelectionPolicy( SelectionPolicy policy )
{
  d->m_policy = policy;
}

PartManager::SelectionPolicy PartManager::selectionPolicy() const
{
  return d->m_policy;
}

kdelibs'PartManager::setAllowNestedParts() (./kdelibs/kparts/partmanager.cpp:92)

void PartManager::setAllowNestedParts( bool allow )
{
  d->m_bAllowNestedParts = allow;
}

kdelibs'PartManager::allowNestedParts() (./kdelibs/kparts/partmanager.cpp:97)

bool PartManager::allowNestedParts() const
{
  return d->m_bAllowNestedParts;
}

kdelibs'PartManager::eventFilter() (./kdelibs/kparts/partmanager.cpp:102)

bool PartManager::eventFilter( QObject *obj, QEvent *ev )
{

  if ( ev->type() != QEvent::MouseButtonPress &&
       ev->type() != QEvent::MouseButtonDblClick &&
       ev->type() != QEvent::FocusIn )
    return false;

  if ( !obj->isWidgetType() )
    return false;

  QWidget *w = (QWidget *)obj;

  if ( ( w->testWFlags( WStyle_Dialog ) && w->isModal() ) ||
       w->testWFlags( WType_Popup ) || w->testWFlags( WStyle_Tool ) )
    return false;

  Part * part;
  while ( w )
  {
    QPoint pos;

    if ( ev->type() == QEvent::MouseButtonPress || ev->type() == QEvent::MouseButtonDblClick )
      pos = ((QMouseEvent *)ev)->globalPos();

    if ( w->topLevelWidget() != ((QWidget *)parent())->topLevelWidget() )
      return false;

    part = findPartFromWidget( w, pos );
    if ( part ) // We found a part whose widget is w
    {
      if ( d->m_policy == PartManager::TriState )
      {
        if ( ev->type() == QEvent::MouseButtonDblClick )
	{
	  if ( part == d->m_activePart && w == d->m_activeWidget )
	    return false;
	
	  setActivePart( part, w );
	  return true;
	}
	
	if ( ( d->m_selectedWidget != w || d->m_selectedPart != part ) &&
	     ( d->m_activeWidget != w || d->m_activePart != part ) )
	{
	  if ( part->isSelectable() )
  	    setSelectedPart( part, w );
	  else
	    setActivePart( part, w );
	  return true;
	}
	else if ( d->m_selectedWidget == w && d->m_selectedPart == part )
	{
	  setActivePart( part, w );
	  return true;
	}
	else if ( d->m_activeWidget == w && d->m_activePart == part )
	{
  	  setSelectedPart( 0L );
	  return false;
	}
	
	return false;
      }
      else if ( part != d->m_activePart )
      {
        kdDebug(1000) << QString("Part %1 made active because %2 got event").arg(part->name()).arg(w->className()) << endl;

        setActivePart( part, w );
      }

      // I suppose we don't return here in case of child parts, right ?
      // But it means we'll emit the event for each intermediate parent ? (David)
      // Perhaps we should store the new part and emit at the end ?

      // I think we should return here (Simon)
      return false; // Ok, let's return. We'll test child parts later on. (David)
    }

    w = w->parentWidget();

    if ( w && ( ( w->testWFlags( WStyle_Dialog ) && w->isModal() ) ||
                w->testWFlags( WType_Popup ) || w->testWFlags( WStyle_Tool ) ) )
    {
      kdDebug(1000) << QString("No part made active although %1/%2 got event - loop aborted").arg(obj->name()).arg(obj->className()) << endl;
      return false;
    }

  }

  kdDebug(1000) << QString("No part made active although %1/%2 got event").arg(obj->name()).arg(obj->className()) << endl;
  return false;
}

kdelibs'PartManager::findPartFromWidget() (./kdelibs/kparts/partmanager.cpp:196)

Part * PartManager::findPartFromWidget( QWidget * widget, const QPoint &pos )
{
  QListIterator<Part> it ( d->m_parts );
  for ( ; it.current() ; ++it )
  {
    Part *part = it.current()->hitTest( widget, pos );
    if ( part )
      return part;
  }
  return 0L;
}

kdelibs'PartManager::addPart() (./kdelibs/kparts/partmanager.cpp:208)

void PartManager::addPart( Part *part, bool setActive )
{
  connect( part, SIGNAL( destroyed() ), this, SLOT( slotObjectDestroyed() ) );

  d->m_parts.append( part );

  part->setManager( this );

  if ( setActive )
  {
    setActivePart( part );
    if ( part->widget() )
      part->widget()->setFocus();
  }

  // Prevent focus problems
  if ( part->widget() &&
      ( part->widget()->focusPolicy() == QWidget::NoFocus ||
        part->widget()->focusPolicy() == QWidget::TabFocus ) )
  {
    kdWarning(1000) << QString("Part %1 must have at least a ClickFocus policy. Prepare for trouble !").arg(part->name()) << endl;
  }

  if ( part->widget() )
    part->widget()->show();
  emit partAdded( part );
}

kdelibs'PartManager::removePart() (./kdelibs/kparts/partmanager.cpp:236)

void PartManager::removePart( Part *part )
{
  if ( d->m_parts.findRef( part ) == -1 )
  {
    kdFatal(1000) << QString("Can't remove part %1, not in KPartManager's list.").arg(part->name()) << endl;
    return;
  }
  disconnect( part, SIGNAL( destroyed() ), this, SLOT( slotObjectDestroyed() ) );

  kdDebug(1000) << QString("Part %1 removed").arg(part->name()) << endl;
  d->m_parts.removeRef( part );

  if ( part == d->m_activePart )
    setActivePart( 0 );

  emit partRemoved( part );
}

kdelibs'PartManager::setActivePart() (./kdelibs/kparts/partmanager.cpp:254)

void PartManager::setActivePart( Part *part, QWidget *widget )
{
  //check whether nested parts are disallowed and activate the top parent part then, by traversing the
  //tree recursively (Simon)
  if ( part && !d->m_bAllowNestedParts && part->parent() && part->parent()->inherits( "KParts::Part" ) )
    setActivePart( (KParts::Part *)part->parent() );

  KParts::Part *oldActivePart = d->m_activePart;
  QWidget *oldActiveWidget = d->m_activeWidget;

  setSelectedPart( 0L );

  d->m_activePart = part;
  d->m_activeWidget = widget;

  if ( oldActivePart )
  {
    KParts::Part *savedActivePart = part;
    QWidget *savedActiveWidget = widget;

    PartActivateEvent ev( false, oldActivePart, oldActiveWidget );
    QApplication::sendEvent( oldActivePart, &ev );
    if ( oldActiveWidget )
    {
      disconnect( oldActiveWidget, SIGNAL( destroyed() ),
		  this, SLOT( slotWidgetDestroyed() ) );
      QApplication::sendEvent( oldActiveWidget, &ev );
    }

    d->m_activePart = savedActivePart;
    d->m_activeWidget = savedActiveWidget;
  }

  if ( d->m_activePart )
  {
    if ( !widget )
      d->m_activeWidget = part->widget();

    PartActivateEvent ev( true, d->m_activePart, d->m_activeWidget );
    QApplication::sendEvent( d->m_activePart, &ev );
    if ( d->m_activeWidget )
    {
      connect( d->m_activeWidget, SIGNAL( destroyed() ),
	       this, SLOT( slotWidgetDestroyed() ) );
      QApplication::sendEvent( d->m_activeWidget, &ev );
    }
  }

  emit activePartChanged( d->m_activePart );
}

kdelibs'PartManager::activePart() (./kdelibs/kparts/partmanager.cpp:305)

Part *PartManager::activePart() const
{
  return d->m_activePart;
}

kdelibs'PartManager::activeWidget() (./kdelibs/kparts/partmanager.cpp:310)

QWidget *PartManager::activeWidget() const
{
  return  d->m_activeWidget;
}

kdelibs'PartManager::setSelectedPart() (./kdelibs/kparts/partmanager.cpp:315)

void PartManager::setSelectedPart( Part *part, QWidget *widget )
{
  if ( part == d->m_selectedPart && widget == d->m_selectedWidget )
    return;

  Part *oldPart = d->m_selectedPart;
  QWidget *oldWidget = d->m_selectedWidget;

  d->m_selectedPart = part;
  d->m_selectedWidget = widget;

  if ( part && !widget )
    d->m_selectedWidget = part->widget();

  if ( oldPart )
  {
    PartSelectEvent ev( false, oldPart, oldWidget );
    QApplication::sendEvent( oldPart, &ev );
    QApplication::sendEvent( oldWidget, &ev );
  }

  if ( d->m_selectedPart )
  {
    PartSelectEvent ev( true, d->m_selectedPart, d->m_selectedWidget );
    QApplication::sendEvent( d->m_selectedPart, &ev );
    QApplication::sendEvent( d->m_selectedWidget, &ev );
  }
}

kdelibs'PartManager::selectedPart() (./kdelibs/kparts/partmanager.cpp:344)

Part *PartManager::selectedPart() const
{
  return d->m_selectedPart;
}

kdelibs'PartManager::selectedWidget() (./kdelibs/kparts/partmanager.cpp:349)

QWidget *PartManager::selectedWidget() const
{
  return d->m_selectedWidget;
}

kdelibs'PartManager::slotObjectDestroyed() (./kdelibs/kparts/partmanager.cpp:354)

void PartManager::slotObjectDestroyed()
{
  kdDebug(1000) << "KPartManager::slotObjectDestroyed()" << endl;
  removePart( (Part *)sender() );
}

kdelibs'PartManager::slotWidgetDestroyed() (./kdelibs/kparts/partmanager.cpp:360)

void PartManager::slotWidgetDestroyed()
{
  kdDebug(1000) << "KPartsManager::slotWidgetDestroyed()" << endl;
  if ( (QWidget *)sender() == d->m_activeWidget )
    setActivePart( 0L ); //do not remove the part because if the part's widget dies, then the
                         //part will delete itself anyway (which ends up in a slotObjectDestroyed() call
}

kdelibs'PartManager::parts() (./kdelibs/kparts/partmanager.cpp:368)

const QList<Part> *PartManager::parts() const
{
  return &d->m_parts;
}