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

kdevelop'CKDevAccel (./kdevelop/kdevelop/ckdevaccel.h:46)

class CKDevAccel : public KAccel
{
  QIntDict<SActionInfo> m_Assoc;

public: 
	CKDevAccel( QWidget *parent, const char *name = 0 );
	~CKDevAccel();

protected:

public:
  // get the action string according to a resource ID
  //   if there's no entry, return an empty string
  QString getActionString(uint uMenuId) const;
  // get the resource ID according to the action
  //   if there is no entry, return 0
  uint getMenuID(const QString &action) const;

  // enables/disables all key accelerators according
  //  to the menu
  //  this will change entries only if
  //  the resource ID is present in the menu, otherwise
  //  the according accelerator will be unchanged
  void setEnableByMenuItems(const QMenuData *menu);

  // reimplementation of KAccel methods
  void connectItem(const QString &action,
                   const QObject *receiver, const char *member,
                   bool activate=true);
  void connectItem(KStdAccel::StdAccel accel,
                   const QObject *receiver, const char *member,
                   bool activate=true);
  void disconnectItem(const QString &action,
    const QObject* receiver, const char *member);
      
    //  these methods allow you to bind an accelerator with
  //  a resource ID
  void connectItem(const QString &action,
    const QObject* receiver, const char *member,
    bool activate, uint uMenuId);

  void connectItem(KStdAccel::StdAccel accel,
    const QObject* receiver, const char *member,
    bool activate, uint uMenuId);

  // reconnect does the same as connect
  //   only the enable state of the accelerator will
  //   be untouched.
  void reconnectItem(const QString &action,
    const QObject* receiver, const char *member);

  void reconnectItem(KStdAccel::StdAccel accel,
    const QObject* receiver, const char *member);

  // like reconnect, only by resource ID
  //   instead of action string or StdAccel number
  bool reconnectItemByID(uint uMenuId,
    const QObject* receiver, const char *member);

  // replacement for KAccel::readSettings
  // the additional parameter sets the enable structure of
  //   each item in CKDevAccel to the saved value
  void readSettings (KConfig* config = 0, bool setEnableStruct=true);

  // reimplementation of KAccel::setItemEnabled
  void setItemEnabled( const QString &action, bool activate );
  //   enables or disables a certain accelerator key
  //   by using either the resource ID or the action string
  bool setItemEnabled( uint uMenuId, bool activate );

};

kdevelop'CKDevAccel::CKDevAccel() (./kdevelop/kdevelop/ckdevaccel.cpp:23)

CKDevAccel::CKDevAccel( QWidget * parent, const char *name )
 : KAccel ( parent, name )
{
#warning FIXME CKDevAccel, maybe KAction would be an option in the future?

  m_Assoc.setAutoDelete(true);
}

kdevelop'CKDevAccel::~CKDevAccel() (./kdevelop/kdevelop/ckdevaccel.cpp:31)

CKDevAccel::~CKDevAccel()
{
  m_Assoc.clear();
}

kdevelop'CKDevAccel::getActionString() (./kdevelop/kdevelop/ckdevaccel.cpp:36)

QString CKDevAccel::getActionString(uint uMenuId) const
{
   QString action;
   if ( m_Assoc.find(uMenuId) )
       action=m_Assoc[uMenuId]->m_sAction;

   return action;
}

kdevelop'CKDevAccel::getMenuID() (./kdevelop/kdevelop/ckdevaccel.cpp:45)

uint CKDevAccel::getMenuID(const QString &action) const
{
  /*  
  QIntDictIterator<SActionInfo> it(m_Assoc);
  uint uMenuId=0;

  if (!action.isEmpty())
  {
    while ( it.current() && uMenuId==0)
    {
      if (it.current()->m_sAction == action)
        uMenuId=it.currentKey();
      ++it;
    }
  }
  
  return uMenuId;
  */
}

kdevelop'CKDevAccel::setEnableByMenuItems() (./kdevelop/kdevelop/ckdevaccel.cpp:65)

void CKDevAccel::setEnableByMenuItems(const QMenuData *menu)
{
  /*
  QIntDictIterator<SActionInfo> it(m_Assoc);

  while ( it.current() )
  {
    if (menu->indexOf(it.currentKey()) != -1)
      setItemEnabled(it.currentKey(), menu->isItemEnabled(it.currentKey()));
    ++it;
  }
  */

}

kdevelop'CKDevAccel::connectItem() (./kdevelop/kdevelop/ckdevaccel.cpp:80)

void CKDevAccel::connectItem(const QString &action,
                             const QObject *receiver, const char *member,
                             bool activate)
{
  /*
  if (!action)
    return;

  KKeyEntry *pEntry = aKeyDict[ action ];

	if ( !pEntry ) {
		QString str("KAccel : Cannot connect action ");
		str+=action;
		str.append(" which is not in the object dictionary");
		warning(str);
		return;
	}
	
	pEntry->receiver = receiver;
	pEntry->member = member;
	pEntry->aAccelId = aAvailableId;
	aAvailableId++;

  if (pEntry->aCurrentKeyCode)
  {
    QAccel::insertItem( pEntry->aCurrentKeyCode, pEntry->aAccelId );
    QAccel::connectItem( pEntry->aAccelId, receiver, member );
    
  }

  if ( !activate )
	setItemEnabled( action, FALSE );

  */
}

kdevelop'CKDevAccel::connectItem() (./kdevelop/kdevelop/ckdevaccel.cpp:117)

void CKDevAccel::connectItem(KStdAccel::StdAccel accel,
                             const QObject* receiver, const char* member,
                             bool activate)
  
{
  /*
    if (stdAction(accel) && !aKeyDict[ stdAction(accel) ]){
        insertStdItem(accel);
    }
    connectItem(stdAction(accel), receiver, member, activate);
    */
}

kdevelop'CKDevAccel::connectItem() (./kdevelop/kdevelop/ckdevaccel.cpp:131)

void CKDevAccel::connectItem(const QString &action,
	const QObject* receiver, const char *member, bool activate, uint uMenuId)
{
  /*
  if (uMenuId!=0)
  {
   if ( m_Assoc.find(uMenuId) )
       m_Assoc.remove( uMenuId );
   m_Assoc.insert( uMenuId, new SActionInfo(action, activate) );
  }

  connectItem(action, receiver, member, activate);
  */
}

kdevelop'CKDevAccel::connectItem() (./kdevelop/kdevelop/ckdevaccel.cpp:146)

void CKDevAccel::connectItem(KStdAccel::StdAccel accel,
	const QObject* receiver, const char *member, bool activate, uint uMenuId)
{
  /*
  if (uMenuId!=0)
  {
   if ( m_Assoc.find(uMenuId) )
       m_Assoc.remove( uMenuId );
   m_Assoc.insert( uMenuId, new SActionInfo(stdAction(accel), activate) );
  }

  connectItem(accel, receiver, member, activate);
  */
}

kdevelop'CKDevAccel::disconnectItem() (./kdevelop/kdevelop/ckdevaccel.cpp:161)

void CKDevAccel::disconnectItem(const QString &action,
	const QObject* receiver, const char *member)
{
  /*
  int uMenuId=getMenuID(action);
  if (uMenuId!=0)
       m_Assoc.remove( uMenuId );

  KAccel::disconnectItem(action, receiver, member);
  */
}

kdevelop'CKDevAccel::reconnectItem() (./kdevelop/kdevelop/ckdevaccel.cpp:173)

void CKDevAccel::reconnectItem(const QString &action,
	const QObject* receiver, const char *member)
{
  /*
  uint uMenuId=getMenuID(action);
  bool activate=true;

  if (uMenuId!=0)
    activate=m_Assoc[uMenuId]->m_bEnabled;

  connectItem(action, receiver, member, activate);
  */
}

kdevelop'CKDevAccel::reconnectItem() (./kdevelop/kdevelop/ckdevaccel.cpp:187)

void CKDevAccel::reconnectItem(KStdAccel::StdAccel accel,
	const QObject* receiver, const char *member)
{
  /*
  uint uMenuId=getMenuID(stdAction(accel));
  bool activate=true;

  if (uMenuId!=0)
    activate=m_Assoc[uMenuId]->m_bEnabled;

  connectItem(accel, receiver, member, activate);
  */
}

kdevelop'CKDevAccel::reconnectItemByID() (./kdevelop/kdevelop/ckdevaccel.cpp:201)

bool CKDevAccel::reconnectItemByID(uint uMenuId,
	const QObject* receiver, const char *member)
{
  /*
  bool bFound=false;
  if ( m_Assoc.find(uMenuId) )
  {
       bool activated=m_Assoc[uMenuId]->m_bEnabled;
       QString action=m_Assoc[uMenuId]->m_sAction;

       connectItem(action, receiver, member, activated);
       bFound=true;
  }
  return bFound;
  */
}

kdevelop'CKDevAccel::readSettings() (./kdevelop/kdevelop/ckdevaccel.cpp:218)

void CKDevAccel::readSettings(KConfig* config, bool setEnableStruct)
{
  /*
   KAccel::readSettings(config);
   if (setEnableStruct)
   {
     QIntDictIterator<SActionInfo> it(m_Assoc);
     while ( it.current())
     {
       QString action=it.current()->m_sAction;
       if (!action.isEmpty())
        KAccel::setItemEnabled(action, it.current()->m_bEnabled);
       ++it;
     }

   }
  */
}


/**
    like KAccel::setItemEnabled()
    only the menu ID will be used to determine which
    accelerator is to disable

    returns true if an associated key-accel was found
*/

kdevelop'CKDevAccel::setItemEnabled() (./kdevelop/kdevelop/ckdevaccel.cpp:245)

bool CKDevAccel::setItemEnabled( uint uMenuId, bool activate )
{
  /*
  bool bRetVal=false;
  if ( m_Assoc.find(uMenuId) )
  {
    m_Assoc[uMenuId]->m_bEnabled=activate;
    KAccel::setItemEnabled(m_Assoc[uMenuId]->m_sAction, activate);
    bRetVal=true;
  }

  return bRetVal;
  */
}

kdevelop'CKDevAccel::setItemEnabled() (./kdevelop/kdevelop/ckdevaccel.cpp:260)

void CKDevAccel::setItemEnabled( const QString &action, bool activate )
{
  /*
    uint uMenuId=getMenuID(action);
    if (uMenuId != 0)
      m_Assoc[uMenuId]->m_bEnabled=activate;

    KAccel::setItemEnabled(action, activate);
  */
}