QGIS » QGIS Application

Build-Depends: debhelper (>= 5.0.51~), libgdal1-dev, libpq-dev, 

 libgeos-dev (>= 3.0.0), grass-dev, libsqlite3-dev, libgsl0-dev, proj (<< 4.7.0) | libproj-dev (>= 4.7.0), libexpat1-dev, 

 flex, bison, python-dev, cmake (>= 2.6), python-sip4 (>= 4.5.0), python-central (>=0.5), python,

 sip4 (>= 4.5), libqt4-core (>=4.4.0), libqt4-dev (>=4.4.0), libqt4-gui (>=4.4.0),

 libqt4-sql (>=4.4.0), python-qt4 (>=4.1.0), python-qt4-dev (>=4.1.0),

 python-sip4-dev (>= 4.5.0), pyqt4-dev-tools, libqwt5-qt4-dev, libfcgi-dev, subversion

Depends: ${shlibs:Depends}, ${misc:Depends}, qgis-common (= ${source:Version}), qgis-providers (= ${binary:Version})

Depends: qgis (>= ${binary:Version})

Depends: qgis (= ${binary:Version}), qgis-plugin-grass-common (= ${source:Version}), ${shlibs:Depends}, ${misc:Depends}, grass

Depends: python-qt4 (>=4.1.0), python-sip4 (>= 4.5.0), python-qgis-common (= ${source:Version}), ${shlibs:Depends}, ${misc:Depends}

Depends: ${shlibs:Depends}, ${misc:Depends}

    bool isLeafNode() {return false;}

    DRAG_ACTION accept( LEGEND_ITEM_TYPE type );

    QgsLegendItem::DRAG_ACTION accept( const QgsLegendItem* li ) const;

    bool isLeafNode() {return mLeafNodeFlag;}

    DRAG_ACTION accept( LEGEND_ITEM_TYPE type );

    QgsLegendItem::DRAG_ACTION accept( const QgsLegendItem* li ) const;

    DRAG_ACTION accept( LEGEND_ITEM_TYPE type );

    QgsLegendItem::DRAG_ACTION accept( const QgsLegendItem* li ) const;

    bool isLeafNode() {return mLeafNodeFlag;}

    DRAG_ACTION accept( LEGEND_ITEM_TYPE type );

    QgsLegendItem::DRAG_ACTION accept( const QgsLegendItem* li ) const;

bool QgsLegendLayer::isLeafNode()

{

  return false;

}

QgsLegendItem::DRAG_ACTION QgsLegendLayer::accept( LEGEND_ITEM_TYPE type )

{

  if ( type == LEGEND_LAYER || type == LEGEND_GROUP )

  {

    return REORDER;

  }

  else

  {

    return NO_ACTION;

  }

}

QgsLegendItem::DRAG_ACTION QgsLegendLayer::accept( const QgsLegendItem* li ) const

{

  if ( li && li != this )

  {

    LEGEND_ITEM_TYPE type = li->type();

    if ( type == LEGEND_LAYER )

    {

      //if(parent() == li->parent())

      //{

      return REORDER;

      //}

    }

    else if ( type == LEGEND_GROUP )

    {

      //only parent legend layers can change positions with groups

      if ( parent() == 0 )

      {

        return REORDER;

      }

    }

  }

  return NO_ACTION;

}

    theMenu.addAction( tr( "&Query..." ), QgisApp::instance(), SLOT( layerSubsetString() ) );

/**

   @note

   set mItemBeingMoved pointer to 0 to prevent SuSE 9.0 crash

*/

    : QTreeWidget( parent ),

    mMousePressedFlag( false ),

    mItemBeingMoved( 0 ),

    mMapCanvas( canvas ),

    mMinimumIconSize( 20, 20 )

  QgsLegendGroup* group = new QgsLegendGroup( this, name );

  mItemBeingMoved = 0;

      theItem->setCheckState( 0, ( select ? Qt::Checked : Qt::Unchecked ) );

    mLastPressPos = e->pos();

  if ( mMousePressedFlag )

    //set the flag back such that the else if(mItemBeingMoved)

    //code part is passed during the next mouse moves

    mMousePressedFlag = false;

    // remember item we've pressed as the one being moved

    // and where it was originally

    QTreeWidgetItem* item = itemAt( mLastPressPos );

    if ( item )

      mItemBeingMoved = item;

      mItemBeingMovedOrigPos = getItemPos( mItemBeingMoved );

      //store information to insert the item back to the original position

      storeInitialPosition( mItemBeingMoved );

      setCursor( Qt::SizeVerCursor );

  else if ( mItemBeingMoved )

    QPoint p( e->pos() );

    mLastPressPos = p;

    // change the cursor appropriate to if drop is allowed

    QTreeWidgetItem* item = itemAt( p );

    hideLine();

    updateLineWidget();

    scrollToItem( item );

    QgsLegendItem* origin = dynamic_cast<QgsLegendItem *>( mItemBeingMoved );

    QgsLegendItem* dest = dynamic_cast<QgsLegendItem *>( item );

    if ( item )

      mDropTarget = item;

      QgsLegendItem::DRAG_ACTION action = dest->accept( origin );

      if ( item != mItemBeingMoved )

        if ( yCoordAboveCenter( dest, e->y() ) ) //over center of item

          int line_y    = visualItemRect( item ).top() + 1;

          int line_left = visualItemRect( item ).left();

          if ( action == QgsLegendItem::REORDER ||  action == QgsLegendItem::INSERT )

          {

            QgsDebugMsg( "mouseMoveEvent::INSERT or REORDER" );

            mDropAction = BEFORE;

            showLine( line_y, line_left );

            setCursor( QCursor( Qt::SizeVerCursor ) );

          }

          else //no action

          {

            QgsDebugMsg( "mouseMoveEvent::NO_ACTION" );

            mDropAction = NO_ACTION;

            setCursor( QCursor( Qt::ForbiddenCursor ) );

          }

        else // below center of item

          int line_y    = visualItemRect( item ).bottom() - 2;

          int line_left = visualItemRect( item ).left();

          if ( action == QgsLegendItem::REORDER )

          {

            QgsDebugMsg( "mouseMoveEvent::REORDER bottom half" );

            mDropAction = AFTER;

            showLine( line_y, line_left );

            setCursor( QCursor( Qt::SizeVerCursor ) );

          }

          else if ( action == QgsLegendItem::INSERT )

          {

            QgsDebugMsg( "mouseMoveEvent::INSERT" );

            mDropAction = INTO_GROUP;

            showLine( line_y, line_left );

            setCursor( QCursor( Qt::SizeVerCursor ) );

          }

          else//no action

          {

            mDropAction = NO_ACTION;

            QgsDebugMsg( "mouseMoveEvent::NO_ACTION" );

            setCursor( QCursor( Qt::ForbiddenCursor ) );

          }

      else

      {

        setCursor( QCursor( Qt::ForbiddenCursor ) );

      }

    else if ( !item && e->pos().y() >= 0 && e->pos().y() < viewport()->height() &&  e->pos().x() >= 0 && e->pos().x() < viewport()->width() )

    {

      // Outside the listed items, but check if we are in the empty area

      // of the viewport, so we can drop after the last top level item.

      QgsDebugMsg( "You are below the table" );

      mDropTarget = topLevelItem( topLevelItemCount() - 1 );

      dest = dynamic_cast<QgsLegendItem *>( mDropTarget );

      QgsLegendItem::DRAG_ACTION action = dest->accept( origin );

      if ( action == QgsLegendItem::REORDER ||  action == QgsLegendItem::INSERT )

      {

        QgsDebugMsg( "mouseMoveEvent::INSERT or REORDER" );

        mDropAction = AFTER;

        showLine( visualItemRect( lastVisibleItem() ).bottom() + 1, 0 );

        setCursor( QCursor( Qt::SizeVerCursor ) );

      }

      else //no action

      {

        QgsDebugMsg( "mouseMoveEvent::NO_ACTION" );

        mDropAction = NO_ACTION;

        setCursor( QCursor( Qt::ForbiddenCursor ) );

      }

    }

      QgsDebugMsg( "No item here" );

      mDropTarget = NULL;

  setCursor( QCursor( Qt::ArrowCursor ) );

  // move only if we have a valid item and drop place

  // otherwise reset the stored values

  if ( !mItemBeingMoved || !mDropTarget )

  {

    mItemBeingMoved = NULL;

    mDropTarget = NULL;

  }

  QgsLegendItem* origin = dynamic_cast<QgsLegendItem *>( mItemBeingMoved );

  mItemBeingMoved = NULL;

  QModelIndex oldIndex = indexFromItem( origin );

  QgsLegendItem* dest = dynamic_cast<QgsLegendItem *>( mDropTarget );

  mDropTarget = NULL;

  // no change?

  if ( !dest || !origin || ( dest == origin ) )

    checkLayerOrderUpdate();

    return;

    // Do the actual move here.

    QgsDebugMsg( "Drag'n'drop happened!" );

    if ( mDropAction == AFTER ) //over center of item

      if ( dest->nextSibling() != origin )

        moveItem( origin, dest );

        setCurrentItem( origin );

        emit itemMoved( oldIndex, indexFromItem( origin ) );

    else if ( mDropAction == BEFORE )// below center of item

      QgsDebugMsg( "Drop BEFORE" );

      if ( dest->findYoungerSibling() != origin )

        moveItem( origin, dest ); // Insert after, as above...

        moveItem( dest, origin ); // ... and then switch places!

        setCurrentItem( origin );

        emit itemMoved( oldIndex, indexFromItem( origin ) );

    else if ( mDropAction == INTO_GROUP )

      QgsDebugMsg( "Drop INTO_GROUP" );

      if ( origin->parent() != dest )

        insertItem( origin, dest );

        setCurrentItem( origin );

        emit itemMoved( oldIndex, indexFromItem( origin ) );

    else//no action

      QgsDebugMsg( "Drop NO_ACTION" );

    Qt::CheckState cs = visible ? Qt::Checked : Qt::Unchecked;

    ll->setCheckState( 0, cs );

void QgsLegend::removeGroup( QgsLegendGroup * lg )

    QgsLegendLayer* ll = dynamic_cast<QgsLegendLayer *>( child );

    if ( ll )

      QgsMapLayerRegistry::instance()->removeMapLayer( ll->layer()->getLayerID() );

void QgsLegend::moveLayer( QgsMapLayer * ml, int groupIndex )

bool QgsLegend::writeXML( QDomNode & legendnode, QDomDocument & document )

  QDomNode tmplegendnode = legendnode; /*copy of the legendnode*/

  QDomElement legendgroupnode;

  QDomElement legendlayernode;

  QDomElement layerfilegroupnode;

  QDomElement legendsymbolnode;

  QDomElement legendpropertynode;

  QDomElement legendlayerfilenode;

  Qt::CheckState cstate; //check state for legend layers and legend groups

  for ( QTreeWidgetItem* currentItem = firstItem(); currentItem;   currentItem = nextItem( currentItem ) )

    switch ( item->type() )

      case QgsLegendItem::LEGEND_GROUP:

        //make sure the legendnode is 'legend' again after a legend group

        if ( !( item->parent() ) )

          legendnode = tmplegendnode;

        legendgroupnode = document.createElement( "legendgroup" );

        legendgroupnode.setAttribute( "open", isItemExpanded( item ) ? "true" : "false" );

        legendgroupnode.setAttribute( "name", item->text( 0 ) );

        cstate = item->checkState( 0 );

        if ( cstate == Qt::Checked )

        {

          legendgroupnode.setAttribute( "checked", "Qt::Checked" );

        }

        else if ( cstate == Qt::Unchecked )

        {

          legendgroupnode.setAttribute( "checked", "Qt::Unchecked" );

        }

        else if ( cstate == Qt::PartiallyChecked )

        {

          legendgroupnode.setAttribute( "checked", "Qt::PartiallyChecked" );

        }

        legendnode.appendChild( legendgroupnode );

        tmplegendnode =  legendnode;

        legendnode = legendgroupnode;

        break;

      case QgsLegendItem::LEGEND_LAYER:

        //make sure the legendnode is 'legend' again after a legend group

        if ( !( item->parent() ) )

          legendnode = tmplegendnode;

        legendlayernode = document.createElement( "legendlayer" );

        legendlayernode.setAttribute( "open", isItemExpanded( item ) ? "true" : "false" );

        cstate = item->checkState( 0 );

        if ( cstate == Qt::Checked )

          legendlayernode.setAttribute( "checked", "Qt::Checked" );

        else if ( cstate == Qt::Unchecked )

          legendlayernode.setAttribute( "checked", "Qt::Unchecked" );

        else if ( cstate == Qt::PartiallyChecked )

        {

          legendlayernode.setAttribute( "checked", "Qt::PartiallyChecked" );

        }

        legendlayernode.setAttribute( "name", item->text( 0 ) );

        legendnode.appendChild( legendlayernode );

        // save the information about layer

        // emulate a legend layer file group and a legend layer file

        // to keep it compatible with older projects

        {

          QgsLegendLayer *ll = dynamic_cast<QgsLegendLayer *>( item );

          QgsMapLayer* layer = ll->layer();

          layerfilegroupnode = document.createElement( "filegroup" );

          layerfilegroupnode.setAttribute( "open", isItemExpanded( item ) ? "true" : "false" );

          layerfilegroupnode.setAttribute( "hidden", isItemHidden( item ) ? "true" : "false" );

          legendlayernode.appendChild( layerfilegroupnode );

          legendlayerfilenode = document.createElement( "legendlayerfile" );

          // layer id

          legendlayerfilenode.setAttribute( "layerid", layer->getLayerID() );

          layerfilegroupnode.appendChild( legendlayerfilenode );

          // visible flag

          legendlayerfilenode.setAttribute( "visible", ll->isVisible() );

          // show in overview flag

          legendlayerfilenode.setAttribute( "isInOverview", ll->isInOverview() );

        }

        break;

      case QgsLegendItem::LEGEND_PROPERTY_GROUP:

        legendpropertynode = document.createElement( "propertygroup" );

        legendpropertynode.setAttribute( "open", isItemExpanded( item ) ? "true" : "false" );

        legendlayernode.appendChild( legendpropertynode );

        break;

      case QgsLegendItem::LEGEND_SYMBOL_GROUP:

        legendsymbolnode = document.createElement( "symbolgroup" );

        legendsymbolnode.setAttribute( "open", isItemExpanded( item ) ? "true" : "false" );

        legendlayernode.appendChild( legendsymbolnode );

        break;

      default: //do nothing for the leaf nodes

        break;

bool QgsLegend::readXML( QDomNode& legendnode )

  QDomElement childelem;

  QDomNode child;

  QgsLegendGroup* lastGroup = 0; //pointer to the last inserted group

  QgsLegendLayer* lastLayer = 0; //pointer to the last inserted legendlayer

  child = legendnode.firstChild();

  // For some unexplained reason, collapsing/expanding the legendLayer items

  // immediately after they have been created doesn't work (they all end up

  // expanded). The legendGroups and legendLayerFiles seems ok through. The

  // workaround is to store the required states of the legendLayers and set

  // them at the end of this function.

  QList<QTreeWidgetItem*> collapsed, expanded;

  if ( !child.isNull() )

  {

    clear(); //remove all items first

    do

      QDomElement childelem = child.toElement();

      QString name = childelem.attribute( "name" );

      //test every possibility of element...

      if ( childelem.tagName() == "legendgroup" )

        QgsLegendGroup* theGroup = new QgsLegendGroup( this, name );

        childelem.attribute( "open" ) == "true" ? expanded.push_back( theGroup ) : collapsed.push_back( theGroup );

        //set the checkbox of the legend group to the right state

        blockSignals( true );

        QString checked = childelem.attribute( "checked" );

        if ( checked == "Qt::Checked" )

          theGroup->setCheckState( 0, Qt::Checked );

          theGroup->setData( 0, Qt::UserRole, Qt::Checked );

        else if ( checked == "Qt::Unchecked" )

          theGroup->setCheckState( 0, Qt::Unchecked );

          theGroup->setData( 0, Qt::UserRole, Qt::Checked );

        else if ( checked == "Qt::PartiallyChecked" )

          theGroup->setCheckState( 0, Qt::PartiallyChecked );

          theGroup->setData( 0, Qt::UserRole, Qt::PartiallyChecked );

        blockSignals( false );

        lastGroup = theGroup;

      }

      else if ( childelem.tagName() == "legendlayer" )

      {

        bool isOpen; // to receive info whether the item is open or closed

        lastLayer = readLayerFromXML( childelem, isOpen );

        if ( lastLayer )

          // add to tree - either as a top-level node or a child of a group

          if ( child.parentNode().toElement().tagName() == "legendgroup" )

          {

            lastGroup->addChild( lastLayer );

          }

          else

          {

            addTopLevelItem( lastLayer );

            lastGroup = 0;

          }

          // expanded or collapsed

          isOpen ? expanded.push_back( lastLayer ) : collapsed.push_back( lastLayer );

          // load symbology

          refreshLayerSymbology( lastLayer->layer()->getLayerID() );

      else if ( childelem.tagName() == "legendlayerfile" )

        // do nothing, this has been handled in readLayerFromXML()

      else if ( childelem.tagName() == "filegroup" )

        // do nothing, this has been handled in readLayerFromXML()

      else if ( childelem.tagName() == "propertygroup" )

      {

        QgsLegendPropertyGroup* thePropertyGroup = new QgsLegendPropertyGroup( lastLayer, "Properties" );

        childelem.attribute( "open" ) == "true" ? expandItem( thePropertyGroup ) : collapseItem( thePropertyGroup );

      }

      child = nextDomNode( child );

    while ( !( child.isNull() ) );

  // Do the tree item expands and collapses.

  for ( int i = 0; i < expanded.size(); ++i )

    expandItem( expanded[i] );

  for ( int i = 0; i < collapsed.size(); ++i )

    collapseItem( collapsed[i] );

void QgsLegend::storeInitialPosition( QTreeWidgetItem* li )

{

  if ( li == firstItem() ) //the item is the first item in the list view

  {

    mRestoreInformation = FIRST_ITEM;

    mRestoreItem = 0;

  }

  else if ( li->parent() == 0 ) //li is a toplevel item, but not the first one

  {

    mRestoreInformation = YOUNGER_SIBLING;

    mRestoreItem = (( QgsLegendItem* )( li ) )->findYoungerSibling();

  }

  else if ( li == li->parent()->child( 0 ) )//li is not a toplevel item, but the first child

  {

    mRestoreInformation = FIRST_CHILD;

    mRestoreItem = li->parent();

  }

  else

  {

    mRestoreInformation = YOUNGER_SIBLING;

    mRestoreItem = (( QgsLegendItem* )( li ) )->findYoungerSibling();

  }

  mLayersPriorToMove = layerIDs();

}

void QgsLegend::resetToInitialPosition( QTreeWidgetItem* li )

{

  QgsLegendItem* formerParent = dynamic_cast<QgsLegendItem *>( li->parent() ); //todo: make sure legend layers are updated

  if ( mRestoreInformation == FIRST_ITEM )

  {

    QgsDebugMsg( "FIRST_ITEM" );

    removeItem( li );

    insertTopLevelItem( 0, li );

  }

  else if ( mRestoreInformation == FIRST_CHILD )

  {

    QgsDebugMsg( "FIRST_CHILD" );

    removeItem( li );

    if ( formerParent )

    {

      formerParent->release(( QgsLegendItem* )li );

    }

    mRestoreItem->insertChild( 0, li );

    (( QgsLegendItem* )mRestoreItem )->receive(( QgsLegendItem* )li );

  }

  else if ( mRestoreInformation == YOUNGER_SIBLING )

  {

    QgsDebugMsg( "YOUNGER_SIBLING" );

    if ( formerParent )

    {

      formerParent->release(( QgsLegendItem* )li );

    }

    dynamic_cast<QgsLegendItem *>( li )->moveItem( dynamic_cast<QgsLegendItem*>( mRestoreItem ) );

    if ( mRestoreItem->parent() )

    {

      (( QgsLegendItem* )( mRestoreItem->parent() ) )->receive(( QgsLegendItem* )li );

    }

  }

}

  int nTopLevelItems = topLevelItemCount();

  QTreeWidgetItem* currentTopLevelItem = 0;

  for ( int i = 0; i < nTopLevelItems; ++i )

    currentTopLevelItem = topLevelItem( i );

    //layer?

    QgsLegendLayer* lLayer = dynamic_cast<QgsLegendLayer*>( currentTopLevelItem );

    //group?

    QgsLegendGroup* lGroup = dynamic_cast<QgsLegendGroup*>( currentTopLevelItem );

      int nLayers =  lGroup->childCount();

        QgsLegendLayer* lLayer = dynamic_cast<QgsLegendLayer*>( lGroup->child( i ) );

/**Returns the first item in the hierarchy*/

  else if ( !litem->parent() )

    return 0;

  //go to other levels to find the next item

  else if ( litem->parent() && dynamic_cast<QgsLegendItem *>( litem->parent() )->nextSibling() )

  {

    return dynamic_cast<QgsLegendItem *>( litem->parent() )->nextSibling();

  }

  else if ( litem->parent() && litem->parent()->parent() && dynamic_cast<QgsLegendItem*>( litem->parent()->parent() )->nextSibling() )

  {

    return dynamic_cast<QgsLegendItem *>( litem->parent()->parent() )->nextSibling();

  }

  else if ( litem->parent() && litem->parent()->parent() && litem->parent()->parent()->parent() &&

            dynamic_cast<QgsLegendItem *>( litem->parent()->parent()->parent() )->nextSibling() )//maximum four nesting states in the current legend

  {

    return dynamic_cast<QgsLegendItem *>( litem->parent()->parent()->parent() )->nextSibling();

  }

  else

  {

    return 0;

  }

QDomNode QgsLegend::nextDomNode( const QDomNode& theNode )

{

  if ( !theNode.firstChild().isNull() )

  {

    return theNode.firstChild();

  }

  QDomNode currentNode = theNode;

  do

  {

    if ( !currentNode.nextSibling().isNull() )

    {

      return currentNode.nextSibling();

    }

    currentNode = currentNode.parentNode();

  }

  while ( !currentNode.isNull() );

  QDomNode nullNode;

  return nullNode;

}

  QgsDebugMsg( QString( "after layer  : %1 (%2)" ).arg( after->text( 0 ) ).arg( after->type() ) );

  if ( after->parent() )

    after->parent()->insertChild( after->parent()->indexOfChild( after ) + 1, move );

  else //toplevel item

    insertTopLevelItem( indexOfTopLevelItem( after ) + 1, move );

std::deque<QString> QgsLegend::layerIDs()

  std::deque<QString> layers;

  for ( std::deque<QString>::iterator it = layers.begin(); it != layers.end(); ++it )

    QgsDebugMsg( *it );

    std::list<QgsLegendLayer*> subfiles = lg->legendLayers();

    for ( std::list<QgsLegendLayer*>::iterator iter = subfiles.begin(); iter != subfiles.end(); ++iter )

#ifdef QGISDEBUG

      if ( item->checkState( 0 ) == Qt::Checked )

        QgsDebugMsg( "item checked" );

      else if ( item->checkState( 0 ) == Qt::Unchecked )

        QgsDebugMsg( "item unchecked" );

      else if ( item->checkState( 0 ) == Qt::PartiallyChecked )

      {

        QgsDebugMsg( "item partially checked" );

      }

#endif

      blockSignals( true );

      ( *iter )->setCheckState( 0, item->checkState( 0 ) );

      blockSignals( false );

      item->setData( 0, Qt::UserRole, item->checkState( 0 ) );

      if (( *iter )->layer() )

      {

        ( *iter )->setVisible( item->checkState( 0 ) == Qt::Checked );

      }

    if ( ll->parent() )

      static_cast<QgsLegendGroup*>( ll->parent() )->updateCheckState();

      ll->parent()->setData( 0, Qt::UserRole, ll->parent()->checkState( 0 ) );

  std::deque<QString> layersAfterRelease = layerIDs(); //test if canvas redraw is really necessary

      ll->setCheckState( 0, ( lst.contains( ll->layer() ) ? Qt::Checked : Qt::Unchecked ) );

    bool isLeafNode();

    QgsLegendItem::DRAG_ACTION accept( LEGEND_ITEM_TYPE type );

    QgsLegendItem::DRAG_ACTION accept( const QgsLegendItem* li ) const;