qgslegend.cpp

一个非常好的GIS开源新版本

    QgsLegendLayerFile * llfile = new QgsLegendLayerFile(llfgroup, QgsLegendLayerFile::nameFromLayer(layer), layer);
    llayer->setLayerTypeIcon();
    llayer->setToolTip(0, layer->publicSource());
    
    //set the correct check states
    blockSignals(true);
    if(llfile->isVisible())
      {
	llfile->setCheckState(0, Qt::Checked);
	llayer->setCheckState(0, Qt::Checked);
	mStateOfCheckBoxes.insert(std::make_pair(llfile, Qt::Checked)); //insert the check state into the map to query for changes later
	mStateOfCheckBoxes.insert(std::make_pair(llayer, Qt::Checked));
      }
    else
      {
	llfile->setCheckState(0, Qt::Unchecked);
	llayer->setCheckState(0, Qt::Unchecked);
	mStateOfCheckBoxes.insert(std::make_pair(llfile, Qt::Unchecked)); //insert the check state into the map to query for changes later
	mStateOfCheckBoxes.insert(std::make_pair(llayer, Qt::Unchecked));
      }
    blockSignals(false);
   
    insertTopLevelItem(0, llayer);
    setItemExpanded(llayer, true);
    setItemExpanded(llfgroup, false);
    //only if qsetting for 'legend layer file visible' is not set
    if(!mShowLegendLayerFiles)
      {
	llfgroup->setHidden(true);
      }
      
    llfile->updateLegendItem();
    refreshLayerSymbology(layer->getLayerID());
    
    updateMapCanvasLayerSet();
    
    // first layer?
    if (mMapCanvas->layerCount() == 1)
      mMapCanvas->zoomFullExtent();
    setCurrentItem(llayer);
    //make the QTreeWidget item up-to-date
    doItemsLayout();
}

QgsLegendLayerFile* QgsLegend::currentLayerFile()
{
  QgsLegendItem* citem=dynamic_cast<QgsLegendItem*>(currentItem());
  
  if(citem)
  {
    QgsLegendLayerFile* llf=dynamic_cast<QgsLegendLayerFile*>(citem);
    if(llf)
    {
      return llf; //the current item is itself a legend layer file
    }
      
    QgsLegendLayer* ll = dynamic_cast<QgsLegendLayer*>(citem);
    if(ll)
    {
      return ll->firstLayerFile(); //the current item is a legend layer, so return its first layer
    }
    
    QgsLegendLayer* lpl = dynamic_cast<QgsLegendLayer*>(citem->parent());
    if(lpl)
    {
      return lpl->firstLayerFile(); //the parent of the current item is a legend layer, return its first layer
    }  
  }

  return 0;
}

QgsMapLayer* QgsLegend::currentLayer()
{
  QgsLegendLayerFile* llf = currentLayerFile();
  if (llf)
  {
    return llf->layer();
  }
  else
  {
    return 0;
  }
}

void QgsLegend::legendGroupRemove()
{
  if(!mMapCanvas || mMapCanvas->isDrawing())
    {
      return;
    }

    QgsLegendGroup* lg = dynamic_cast<QgsLegendGroup*>(currentItem());
    if(lg)
    {
	//delete the legend layers first
	QTreeWidgetItem * child = lg->child(0);
        while(child) 
	{
	    setCurrentItem(child);
	    legendLayerRemove();
            child = lg->child(0);
        }
	delete lg;
	adjustIconSize();
    }
}

void QgsLegend::legendLayerRemove()
{
  if(!mMapCanvas || mMapCanvas->isDrawing())
    {
      return;
    }

    //if the current item is a legend layer: remove all layers of the current legendLayer
   QgsLegendLayer* ll = dynamic_cast<QgsLegendLayer*>(currentItem());
   if(ll)
   {
     std::list<QgsMapLayer*> maplayers = ll->mapLayers();
     mStateOfCheckBoxes.erase(ll);
     
     //also remove the entries for the QgsLegendLayerFiles from the map
     std::list<QgsLegendLayerFile*> llfiles = ll->legendLayerFiles();
     for(std::list<QgsLegendLayerFile*>::iterator it = llfiles.begin(); it != llfiles.end(); ++it)
       {
	 mStateOfCheckBoxes.erase(*it);
       }
     
     for(std::list<QgsMapLayer*>::iterator it = maplayers.begin(); it!=maplayers.end(); ++it)
       {
	 //remove the layer
	 if(*it)
	   {
	     //the map layer registry emits a signal an this will remove the legend layer
	     //from the legend and from memory by calling QgsLegend::removeLayer(QString layer key)
	     QgsMapLayerRegistry::instance()->removeMapLayer((*it)->getLayerID());
	   }
       }
     
     removeItem(ll);
     delete ll;
     adjustIconSize();
     return;
   }

   //if the current item is a legend layer file
   QgsLegendLayerFile* llf = dynamic_cast<QgsLegendLayerFile*>(currentItem());
   if(llf)
     {
       if(llf->layer())
	 {
	   //the map layer registry emits a signal an this will remove the legend layer
	   //from the legend and from memory by calling QgsLegend::removeLayer(QString layer key)
	   QgsMapLayerRegistry::instance()->removeMapLayer(llf->layer()->getLayerID());
	 }
     }
   return;
}



void QgsLegend::legendLayerShowProperties()
{
  if(!mMapCanvas || mMapCanvas->isDrawing())
    {
      return;
    }

  QgsLegendItem* li = dynamic_cast<QgsLegendItem*>(currentItem());
  QgsLegendLayerFile* llf = 0;

  if(!li)
  {
    return;
  }
  
  if(li->type() == QgsLegendItem::LEGEND_LAYER_FILE)
  {
    llf = dynamic_cast<QgsLegendLayerFile*>(li);
  }
  else if(li->type() == QgsLegendItem::LEGEND_LAYER)
  {
    QgsLegendLayer* ll = dynamic_cast<QgsLegendLayer*>(li);
    llf = ll->firstLayerFile();
  }
       
  if (!llf)
  {
    return;
  }
  
  //QgsDebugMsg("Showing layer properties dialog");
  
  QgsMapLayer* ml = llf->layer();

  /*
  TODO: Consider reusing the property dialogs again.
  Sometimes around mid 2005, the property dialogs were saved for later reuse;
  this resulted in a time savings when reopening the dialog. The code below
  cannot be used as is, however, simply by saving the dialog pointer here.
  Either the map layer needs to be passed as an argument to sync or else
  a separate copy of the dialog pointer needs to be stored with each layer.
  */

  if (ml->type() == QgsMapLayer::RASTER)
  {
    QgsRasterLayerProperties *rlp = NULL; // See note above about reusing this
    if (rlp)
    {
      rlp->sync();
    }
    else
    {
      rlp = new QgsRasterLayerProperties(ml);
      connect(rlp, SIGNAL(refreshLegend(QString,bool)), this, SLOT(refreshLayerSymbology(QString,bool)));
    }
    rlp->exec();
    delete rlp; // delete since dialog cannot be reused without updating code
  }
  else // VECTOR
  {
    QgsVectorLayer* vlayer = dynamic_cast<QgsVectorLayer*>(ml);

    QgsVectorLayerProperties *vlp = NULL; // See note above about reusing this
    if (vlp)
    {
      vlp->reset();
    }
    else
    {
      vlp = new QgsVectorLayerProperties(vlayer);
      connect(vlp, SIGNAL(refreshLegend(QString,bool)), this, SLOT(refreshLayerSymbology(QString,bool)));
    }
    vlp->exec();
    delete vlp; // delete since dialog cannot be reused without updating code
  }
  
  llf->updateLegendItem();

}

void QgsLegend::legendLayerShowInOverview()
{
  if(!mMapCanvas || mMapCanvas->isDrawing())
    {
      return;
    }

  QgsLegendItem* li = dynamic_cast<QgsLegendItem*>(currentItem());
  if(!li)
    return;
  
  if(li->type() == QgsLegendItem::LEGEND_LAYER_FILE)
  {
    QgsLegendLayerFile* llf = dynamic_cast<QgsLegendLayerFile*>(li);
    if (!llf) return;
    llf->showInOverview();
  }
  else if(li->type() == QgsLegendItem::LEGEND_LAYER)
  {
    QgsLegendLayer* ll = dynamic_cast<QgsLegendLayer*>(li);
    if (!ll) return;
    ll->showInOverview();
  }
}

void QgsLegend::expandAll()
{
    QTreeWidgetItem* theItem = firstItem();
    while(theItem)
      {
	setExpanded(indexFromItem(theItem), true);
	theItem = nextItem(theItem);
      }
}

void QgsLegend::collapseAll()
{
  QTreeWidgetItem* theItem = firstItem();
    while(theItem)
      {
	setExpanded(indexFromItem(theItem), false);
	theItem = nextItem(theItem);
      }
}

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;
    QgsLegendLayerFile* llf;
    Qt::CheckState cstate; //check state for legend layers and legend groups

    QTreeWidgetItem* currentItem = firstItem();
    while(currentItem) 
    {
	QgsLegendItem *item = dynamic_cast<QgsLegendItem*>(currentItem);
	if(item)
	{
	    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");
		    if(isItemExpanded(item))
		    {
			legendgroupnode.setAttribute("open","true");
		    }
		    else
		    {
			legendgroupnode.setAttribute("open","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");
		    if(isItemExpanded(item))
		    {
			legendlayernode.setAttribute("open","true");
		    }
		    else
		    {
			legendlayernode.setAttribute("open","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);
		    break;

		case QgsLegendItem::LEGEND_PROPERTY_GROUP:
		    legendpropertynode = document.createElement("propertygroup");
		    if(isItemExpanded(item))
		    {
			legendpropertynode.setAttribute("open","true");	
		    }
		    else
		    {
			legendpropertynode.setAttribute("open","false");
		    }
		    legendlayernode.appendChild(legendpropertynode);
		    break;

		case QgsLegendItem::LEGEND_SYMBOL_GROUP:
		    legendsymbolnode = document.createElement("symbolgroup");
		    if(isItemExpanded(item))
		    {
			legendsymbolnode.setAttribute("open", "true");
		    }
		    else
		    {
			legendsymbolnode.setAttribute("open", "false");
		    }
		    legendlayernode.appendChild(legendsymbolnode);
		    break;
		
  
		case QgsLegendItem::LEGEND_LAYER_FILE_GROUP:
		    layerfilegroupnode = document.createElement("filegroup");
		    if(isItemExpanded(item))
		    {
		      layerfilegroupnode.setAttribute("open", "true");
		    }
		    else
		    {
		      layerfilegroupnode.setAttribute("open", "false");
		    }
		    if(isItemHidden(item))
		    {
		      layerfilegroupnode.setAttribute("hidden", "true");
		    }
		    else
		    {
		      layerfilegroupnode.setAttribute("hidden", "false");
		    }
		       
		    legendlayernode.appendChild(layerfilegroupnode);
		    break;
	    
	      case QgsLegendItem::LEGEND_LAYER_FILE:
		legendlayerfilenode = document.createElement("legendlayerfile");
		llf = dynamic_cast<QgsLegendLayerFile*>(item);
		if(llf)
		  {
		    QgsMapLayer* layer = llf->layer();
        
		    // layer id
		    legendlayerfilenode.setAttribute("layerid", layer->getLayerID());
		    layerfilegroupnode.appendChild(legendlayerfilenode);
		  
		    // visible flag
		    legendlayerfilenode.setAttribute( "visible", llf->isVisible());

		    // show in overview flag
		    legendlayerfilenode.setAttribute( "inOverview", llf->isInOverview());
		  }
		break;

		default: //do nothing for the leaf nodes
		    break;
	    }
	}
	currentItem = nextItem(currentItem);
    }
    return true;
}

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
  QgsLegendLayerFileGroup* lastLayerFileGroup = 0; //pointer to the last inserted layerfilegroup
  
  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())
    {