KLDAP Library
ldapmodel.cpp
00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021 #include "ldapmodel.h"
00022 #include "ldapmodel_p.h"
00023 #include "ldapmodelnode_p.h"
00024 #include "ldapsearch.h"
00025
00026 #include <kdebug.h>
00027 #include <klocale.h>
00028
00029 using namespace KLDAP;
00030
00031 LdapModel::LdapModel( QObject *parent )
00032 : QAbstractItemModel( parent ),
00033 m_d( new LdapModelPrivate( this ) )
00034 {
00035 m_d->createConnections();
00036 }
00037
00038 LdapModel::LdapModel( LdapConnection &connection, QObject *parent )
00039 : QAbstractItemModel( parent ),
00040 m_d( new LdapModelPrivate( this, connection ) )
00041 {
00042 m_d->createConnections();
00043
00044
00045 m_d->populateRootToBaseDN();
00046 }
00047
00048 LdapModel::~LdapModel()
00049 {
00050 delete m_d;
00051 }
00052
00053 void LdapModel::setConnection( LdapConnection &connection )
00054 {
00055 m_d->setConnection( connection );
00056
00057
00058 m_d->recreateRootItem();
00059
00060
00061 m_d->populateRootToBaseDN();
00062 }
00063
00064 QModelIndex LdapModel::parent( const QModelIndex &child ) const
00065 {
00066 if ( !child.isValid() ) {
00067 return QModelIndex();
00068 }
00069
00070 LdapModelNode *childItem = static_cast<LdapModelNode*>( child.internalPointer() );
00071 LdapModelDNNode *parentItem = childItem->parent();
00072
00073 if ( parentItem == m_d->rootNode() ) {
00074 return QModelIndex();
00075 }
00076
00077 return createIndex( parentItem->row(), 0, parentItem );
00078 }
00079
00080 QModelIndex LdapModel::index( int row, int col, const QModelIndex &parent ) const
00081 {
00082
00083 LdapModelDNNode *parentItem;
00084 if ( !parent.isValid() ) {
00085 parentItem = m_d->rootNode();
00086 } else {
00087 parentItem = static_cast<LdapModelDNNode*>( parent.internalPointer() );
00088 }
00089
00090 LdapModelNode *childItem = parentItem->child( row );
00091 if ( childItem ) {
00092 return createIndex( row, col, childItem );
00093 }
00094 kDebug(5322) << "Could not create valid index for row =" << row << ", col =" << col;
00095 return QModelIndex();
00096 }
00097
00098 QVariant LdapModel::data( const QModelIndex &index, int role ) const
00099 {
00100 if ( !index.isValid() ) {
00101 return QVariant();
00102 }
00103
00104 if ( role == Qt::DisplayRole ) {
00105
00106 LdapModelNode *node = static_cast<LdapModelNode*>( index.internalPointer() );
00107 if ( node->nodeType() == LdapModelNode::DN ) {
00108 LdapModelDNNode* dn = static_cast<LdapModelDNNode*>( node );
00109 if ( index.column() == 0 ) {
00110 return dn->dn().rdnString();
00111 } else {
00112 return QVariant();
00113 }
00114 } else {
00115 LdapModelAttrNode* attr = static_cast<LdapModelAttrNode*>( node );
00116 if ( index.column() == 0 ) {
00117 return QVariant( attr->attributeName() );
00118 } else {
00119 return QVariant( QString( attr->attributeData().constData() ) );
00120 }
00121 }
00122 } else if ( role == NodeTypeRole ) {
00123 LdapModelNode* node = static_cast<LdapModelNode*>( index.internalPointer() );
00124 return QVariant( int( node->nodeType() ) );
00125 }
00126
00131 return QVariant();
00132 }
00133
00134 bool LdapModel::setData( const QModelIndex &index,
00135 const QVariant &value,
00136 int role )
00137 {
00138 Q_UNUSED( index );
00139 Q_UNUSED( value );
00140 Q_UNUSED( role );
00141 return false;
00142 }
00143
00144 QVariant LdapModel::headerData( int section, Qt::Orientation orientation, int role ) const
00145 {
00146 if ( orientation == Qt::Horizontal && role == Qt::DisplayRole ) {
00147 if ( section == 0 ) {
00148 return QString( i18n( "Attribute" ) );
00149 } else {
00150 return QString( i18n( "Value" ) );
00151 }
00152 }
00153
00154 return QVariant();
00155 }
00156
00157 Qt::ItemFlags LdapModel::flags( const QModelIndex &index ) const
00158 {
00160 if ( !index.isValid() ) {
00161 return Qt::ItemIsEnabled;
00162 }
00163
00164 return Qt::ItemFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
00165 }
00166
00167 int LdapModel::columnCount( const QModelIndex &parent ) const
00168 {
00169 LdapModelDNNode *parentNode =
00170 parent.isValid() ? static_cast<LdapModelDNNode*>( parent.internalPointer() ) : m_d->rootNode();
00171 return parentNode->columnCount();
00172 }
00173
00174 int LdapModel::rowCount( const QModelIndex &parent ) const
00175 {
00176 if ( parent.column() > 0 ) {
00177 return 0;
00178 }
00179
00180 const LdapModelDNNode *parentNode =
00181 parent.isValid() ? static_cast<LdapModelDNNode*>( parent.internalPointer() ) : m_d->rootNode();
00182 return parentNode->childCount();
00183 }
00184
00185 bool LdapModel::hasChildren( const QModelIndex &parent ) const
00186 {
00187
00188 const LdapModelNode *node = parent.isValid()
00189 ? static_cast<const LdapModelNode*>( parent.internalPointer() )
00190 : m_d->rootNode();
00191
00192 if ( node->nodeType() != LdapModelNode::DN )
00193 return false;
00194
00195 const LdapModelDNNode* parentNode = static_cast<const LdapModelDNNode*>( node );
00196 if ( !parent.isValid() || parentNode->isPopulated() ) {
00197 return parentNode->childCount() > 0;
00198 }
00199 return true;
00200 }
00201
00202 bool LdapModel::canFetchMore( const QModelIndex &parent ) const
00203 {
00204 const LdapModelDNNode *parentNode =
00205 parent.isValid() ? static_cast<LdapModelDNNode*>( parent.internalPointer() ) : m_d->rootNode();
00206 return !parentNode->isPopulated();
00207 }
00208
00209 void LdapModel::fetchMore( const QModelIndex &parent )
00210 {
00211 LdapModelDNNode *parentNode =
00212 parent.isValid() ? static_cast<LdapModelDNNode*>( parent.internalPointer() ) : m_d->rootNode();
00213
00214
00215 m_d->searchResults().clear();
00216 m_d->setSearchType( LdapModelPrivate::ChildObjects, parentNode );
00217 m_d->search( parentNode->dn(),
00218 LdapUrl::One,
00219 QString() );
00220 parentNode->setPopulated( true );
00221 }
00222
00223 bool LdapModel::insertRows( int row, int count,
00224 const QModelIndex &parent )
00225 {
00226 Q_UNUSED( row );
00227 Q_UNUSED( count );
00228 Q_UNUSED( parent );
00229 return false;
00230 }
00231
00232 bool LdapModel::removeRows( int row, int count,
00233 const QModelIndex &parent )
00234 {
00235 Q_UNUSED( row );
00236 Q_UNUSED( count );
00237 Q_UNUSED( parent );
00238 return false;
00239 }
00240
00241 void LdapModel::sort( int column, Qt::SortOrder order )
00242 {
00243 Q_UNUSED( column );
00244 Q_UNUSED( order );
00245 }
00246
00247 Qt::DropActions LdapModel::supportedDropActions() const
00248 {
00249 return Qt::MoveAction;
00250 }
00251
00252 QMimeData *LdapModel::mimeData( const QModelIndexList &indexes ) const
00253 {
00254 Q_UNUSED( indexes );
00255 return 0;
00256 }
00257
00258 bool LdapModel::dropMimeData( const QMimeData *data, Qt::DropAction action,
00259 int row, int column, const QModelIndex &parent )
00260 {
00262 Q_UNUSED( data );
00263 Q_UNUSED( action );
00264 Q_UNUSED( row );
00265 Q_UNUSED( column );
00266 Q_UNUSED( parent );
00267 return false;
00268 }
00269
00270 bool LdapModel::hasChildrenOfType( const QModelIndex &parent, LdapDataType type ) const
00271 {
00272
00273 LdapModelNode::NodeType nodeType;
00274 switch ( type ) {
00275 case Attribute:
00276 nodeType = LdapModelNode::Attr;
00277 break;
00278
00279 case DistinguishedName:
00280 default:
00281 nodeType = LdapModelNode::DN;
00282 break;
00283 }
00284
00285 const LdapModelNode *node = parent.isValid()
00286 ? static_cast<const LdapModelNode*>( parent.internalPointer() )
00287 : m_d->rootNode();
00288
00289 const LdapModelDNNode* parentNode = static_cast<const LdapModelDNNode*>( node );
00290 if ( !parent.isValid() || parentNode->isPopulated() ) {
00291
00292 const QList<LdapModelNode*>& children = parentNode->children();
00293 foreach ( LdapModelNode *child, children ) {
00294 if ( child->nodeType() == nodeType ) {
00295 return true;
00296 }
00297 }
00298
00299
00300 return false;
00301 }
00302
00303
00304
00305 return true;
00306 }
00307
00308 void LdapModel::revert()
00309 {
00310
00311 }
00312
00313 bool LdapModel::submit()
00314 {
00315 return false;
00316 }
00317
00318 #include "ldapmodel.moc"