QGIS » QGIS Application

class QgsMeasureDialog : public QDialog, private Ui::QgsMeasureBase

{

public:

/**A map tool that draws a line and splits the features cut by the line*/

class QgsMapToolSplitFeatures: public QgsMapToolCapture

{

 public:

  QgsMapToolSplitFeatures(QgsMapCanvas* canvas);

  virtual ~QgsMapToolSplitFeatures();

 */

class QgisApp : public QMainWindow

{

  public:

  //! Constructor

  QgisApp(QSplashScreen *splash, QWidget * parent = 0, Qt::WFlags fl = Qt::Window);

*/

class QgsLegendLayerFile : public QgsLegendItem

{

public:

    QgsLegendLayerFile(QTreeWidgetItem * theLegendItem, QString theString, QgsMapLayer* theLayer);

class QgsLegend : public QTreeWidget

{

 private:

    // Moved here to match access of declaration later in file.

    // Previous location raised a warning in msvc as the forward

class QgsIdentifyResults: public QDialog, private Ui::QgsIdentifyResultsBase

{

  public:

  //! Constructor - takes it own copy of the QgsAttributeAction so

QgsAttributeTableItemDelegate::QgsAttributeTableItemDelegate(QgsAttributeTable *table, QObject *parent)

{

}

void QgsAttributeTable::fillTable(QgsVectorLayer *layer)

{

  const QgsFieldMap &fields = layer->pendingFields();

	// set up the column headers

class QgsVectorLayerProperties : public QDialog, private Ui::QgsVectorLayerPropertiesBase

{

public:

  QgsVectorLayerProperties(QgsVectorLayer *lyr = 0,QWidget *parent = 0, Qt::WFlags fl = QgisGui::ModalDialogFlags);

  ~QgsVectorLayerProperties();

int QgsMapToolEdit::insertSegmentVerticesForSnap(const QList<QgsSnappingResult>& snapResults, QgsVectorLayer* editedLayer)

{

  QgsPoint layerPoint;

  if(!editedLayer || !editedLayer->isEditable())

  mModelValues->blockSignals(true);

  lstValues->setUpdatesEnabled(false);

  while (provider->getNextFeature(feat) &&

  {

    const QgsAttributeMap& attributes = feat.attributeMap();

    value = attributes[fieldIndex].toString();

QgsRasterLayerProperties::QgsRasterLayerProperties(QgsMapLayer *lyr, QWidget *parent, Qt::WFlags fl)

  : QDialog(parent, fl), 

  // Constant that signals property not used.

{

  ignoreSpinBoxEvent = false; //Short circuit signal loop between min max field and stdDev spin box

  mGrayActualMinimumMaximum = false;

	dbssType=0,

	dbssDetail,

	dbssSql,

    };

    typedef std::pair<QString, QString> geomPair;

    enum {

      AttributeIndex = Qt::UserRole,

      AttributeName = Qt::UserRole+1,

    };

    void setReadOnly(bool b);

The tables have the following columns: Type, Schema, Tablename, Geometry Column, Sql*/

class QgsDbTableModel: public QStandardItemModel

{

 public:

  QgsDbTableModel();

  ~QgsDbTableModel();

QgsAttributeDialog::QgsAttributeDialog(QgsVectorLayer *vl, QgsFeature *thepFeature)

  : QDialog(),

    mSettingsPath("/Windows/AttributeDialog/"),

{

  setupUi(this);

  if (mpFeature==NULL || vl->getDataProvider()==NULL )

QgsMapToolDeleteVertex*/

class QgsMapToolVertexEdit: public QgsMapToolEdit

{

 public:

 */

class QgsPasteTransformations : public QDialog, private Ui::QgsPasteTransformationsBase

{

 public:

    //! Constructor

    QgsPasteTransformations();

 */

class QgsOptions :public QDialog, private Ui::QgsOptionsBase

{

  public:

    /**

     * Constructor

/** QgsLabelDialog is the dialog for label. */

class QgsLabelDialog: public QWidget, private Ui::QgsLabelDialogBase

{

public:

    QgsLabelDialog( QgsLabel *label,  QWidget * parent = 0 );

 */

class QgisAppInterface : public QgisInterface

{

    public:

        /**

class QgsAttributeActionDialog: public QWidget, private Ui::QgsAttributeActionDialogBase

{

 public:

  QgsAttributeActionDialog(QgsAttributeAction* actions, 

class QgsAttributeDialog: public QDialog, private Ui::QgsAttributeDialogBase

{

  public:

  QgsAttributeDialog(QgsVectorLayer *vl, QgsFeature * thepFeature);

  QgisApp::QgisApp(QSplashScreen *splash, QWidget * parent, Qt::WFlags fl)

: QMainWindow(parent,fl),

  mSplash(splash),

{

  if(smInstance) {

    QMessageBox::critical(

      break;

  }

class QgsMeasureTool : public QgsMapTool

{

public:

#ifdef QGISDEBUG 

  printf ("Loading mug: %s\n", myString.toLocal8Bit().constData()); 

#endif 

  /* Uncomment this block to use preloaded images

  pixAuthorMug->setPixmap(mugs[myString]);

  */

*/

class QgsMapToolIdentify : public QgsMapTool

{

  public:

    QgsMapToolIdentify(QgsMapCanvas* canvas);

class QgsSpit : public QDialog, private Ui::QgsSpitBase

{

public:

  QgsSpit( QWidget *parent = 0, Qt::WFlags fl = 0 );

  ~QgsSpit();

class ShapefileTableDelegate : public QItemDelegate

{

 public:

  ShapefileTableDelegate(QObject *parent, QStringList& schema_list) :

//standard includes

QuickPrintGui::QuickPrintGui( QgsMapCanvas * thepMapCanvas, 

{

  setupUi(this);

  grpOuput->hide();  //until properly implemented

*/

class QuickPrintPlugin:public QObject, public QgisPlugin

{

  public:

  //////////////////////////////////////////////////////////////////////

void dxf2shpConverterGui::on_buttonBox_helpRequested()

{

  QString s = "Fields description:\n"

  "* Input DXF file: path to the DXF file to be converted\n" 

  "* Output Shp file: desired filename of the ShapeFile to be created\n"

 */

class dxf2shpConverter: public QObject, public QgisPlugin

{

  public:

  //////////////////////////////////////////////////////////////////////

    return;

  }

  logfile << "(Add Circle  (%6.3f, %6.3f, %6.3f) %6.3f\n", data.cx, data.cy, data.cz, data.radius;

  if (ignoringBlock)

 */

void DL_WriterA::dxfReal(int gc, double value) const {

    char str[256];

	// fix for german locale:

	strReplace(str, ',', '.');

*/

class QgsCopyrightLabelPluginGui : public QDialog, private Ui::QgsCopyrightLabelPluginGuiBase

{

public:

    QgsCopyrightLabelPluginGui( QWidget* parent = 0, Qt::WFlags fl = 0 );

    ~QgsCopyrightLabelPluginGui();

*/

class CoordinateCaptureMapTool : public QgsMapTool

{

  public:

    CoordinateCaptureMapTool(QgsMapCanvas* thepCanvas);

*/

class CoordinateCapture:public QObject, public QgisPlugin

{

  public:

  //////////////////////////////////////////////////////////////////////

*/

class QgsScaleBarPluginGui : public QDialog, private Ui::QgsScaleBarPluginGuiBase

{

public:

    QgsScaleBarPluginGui( QWidget* parent = 0, Qt::WFlags fl = 0 );

    ~QgsScaleBarPluginGui();

  // the screen resolution is which we store and then 

  // reset the resolution of the printer after that...

  QPrinter myPrinter ( QPrinter::ScreenResolution ); 

  // Try to force the printer resolution to 300dpi

  // to get past platform specific defaults in printer

  // resolution...

      if ( mypVectorLayer )

      {

        QString myLayerName = mypVectorLayer->name();

        QIcon myIcon;

        QPixmap myPixmap ( QSize ( myIconWidth, myIconWidth ) ); //square

        //based on code from qgslegendlayer.cpp - see that file for more info

          }

          myLegendXPos += myIconWidth + myLegendSpacer;

          myPrintPainter.setPen( Qt::black );

          QStringList myWrappedLayerNameList = wordWrap(myLayerName, 

              myLegendFontMetrics, 

              myLegendDimensionX - myIconWidth);

            }

            myLabel = myLabel.trimmed();

            myLegendXPos += myIconWidth + myLegendSpacer;

            myPrintPainter.setPen( Qt::black );

            QStringList myWrappedLayerNameList = wordWrap(myLabel, 

                myLegendFontMetrics, 

class GUI_EXPORT QgsDetailedItemDelegate : 

     public QAbstractItemDelegate 

{

  public:

    QgsDetailedItemDelegate(QObject * parent = 0);

    ~QgsDetailedItemDelegate();

class GUI_EXPORT QgsMapOverviewCanvas : public QWidget

{

  public:

    QgsMapOverviewCanvas(QWidget * parent = 0, QgsMapCanvas* mapCanvas = NULL);

  {

    QgsDetailedItemData myData = 

      qVariantValue<QgsDetailedItemData>(theIndex.data(Qt::UserRole));

    if (myData.isRenderedAsWidget())

    {

      paintAsWidget(thepPainter,theOption,myData);

*/

class GUI_EXPORT QgsQuickPrint:public QObject

{

  public:

  QgsQuickPrint();

class QgsDetailedItemWidget : 

     public QWidget, private Ui::QgsDetailedItemWidgetBase

{

  public:

    QgsDetailedItemWidget(QWidget * parent = 0);

    ~QgsDetailedItemWidget();

class GUI_EXPORT QgsMapCanvas : public QGraphicsView

{

  public:

class GUI_EXPORT QgisInterface : public QObject

{

  public:

class GUI_EXPORT QgsGenericProjectionSelector : public QDialog, private Ui::QgsGenericProjectionSelectorBase

{

  public:

    /**

     * Constructor

QgsFeature::QgsFeature( QgsFeature const & rhs )

    : mFid( rhs.mFid ),

      mAttributes( rhs.mAttributes ),

      mValid( rhs.mValid ),

      mDirty( rhs.mDirty ),

{

  // copy embedded geometry

  mProviderKey(providerKey),

  mEditable(false),

  mModified(false),

  mRenderer(0),

  mLabel(0),

  mLabelOn(false),

  mFetching(false)

{

  mActions = new QgsAttributeAction;

    /* Scale factor of the marker image*/

    /* We set this to the symbolScale, and if it is NOT changed, */

    /* we don't have to do another scaling here */

    if(mEditable)

    {

          emit drawingProgress(featureCount, totalFeatures);

          qApp->processEvents();

        }

#endif //Q_WS_MAC

        if (mEditable)

int QgsVectorLayer::splitFeatures(const QList<QgsPoint>& splitLine, bool topologicalEditing)

{

  QgsFeatureList newFeatures; //store all the newly created features

  double xMin, yMin, xMax, yMax;

  QgsRect bBox; //bounding box of the split line

        }

        break;

      }

  }

  return returnVal;

}

#include <QTextCodec>

#include <cassert>

#include <ogr_api.h>

#include <ogr_srs_api.h>

  bool ok = TRUE;

  const char* suffixes[] = { ".shp", ".shx", ".dbf", ".prj", ".qix" };

  {

    QString file = myFileBase + suffixes[i];

    QFileInfo myInfo(file);

    QString const & baseName, 

    bool loadDefaultStyleFlag)

  : QgsMapLayer(RASTER, baseName, path),

  mRasterXDim( std::numeric_limits<int>::max() ),

  mRasterYDim( std::numeric_limits<int>::max() ),

  mDebugOverlayFlag(false),

  mInvertPixelsFlag(false),

  mStandardDeviations(0),

{

  mUserDefinedRGBMinMaxFlag = false; //defaults needed to bypass stretch

  // a certain range -- in this case twenty times the smallest value that

  // doubles can take for the current system.  (Yes, 20 was arbitrary.)

  double myPrecision = std::numeric_limits<double>::epsilon() * 20;

  //ifdefs below to remove compiler warning about unused vars

#ifdef QGISDEBUG

    case USER_DEFINED:

      return QString("USER_DEFINED");

      break;

  }

  return QString("UNDEFINED_SHADING_ALGORITHM");

    case QGS_CFloat64:

    return std::numeric_limits<double>::max();

      break;

  }

  return std::numeric_limits<double>::max();

    case QGS_CFloat64:

    return std::numeric_limits<double>::max() * -1.0;

      break;

  }

  return std::numeric_limits<double>::max() * -1.0;

  for (unsigned int i=0, j=0; i<numPoints; i++, j++)

  {

    // Do we insert the new vertex here?

    {

      GEOSCoordSeq_setX(*new_sequence, j, x);

      GEOSCoordSeq_setY(*new_sequence, j, y);

  //ratio intersect geometry / geometry. This should be close to 1

  //if the polygon belongs to the input geometry

  for(int i=0; i<GEOSGetNumGeometries(polygons); i++)

  {

    const GEOSGeometry *polygon = GEOSGetGeometryN(polygons, i);

    double polygonArea;

    GEOSArea(polygon, &polygonArea);

    if(areaRatio > 0.99 && areaRatio < 1.01)

      testedGeometries << GEOSGeom_clone(polygon);

      QgsCoordinateTransform tr(layer->srs(), *mDestCRS);

#ifdef QGISDEBUG

#endif

      // Split the extent into two if the source CRS is

      // geographic and the extent crosses the split in

    UniqueValuesEditable,

    ValueMap,

    Classification,

  };

  struct RangeData {

    void (QgsProjectFileTransform::* transformFunc)();

  } transform;

  QDomDocument mDom;

  QgsProjectVersion mCurrentVersion;

  return ((mMajor == other.mMajor) &&

          (mMinor == other.mMinor) &&

          (mSub == other.mSub));

/*! Boolean >= operator

 */

  return ( (mMajor >= other.mMajor) ||

          ((mMajor == other.mMajor) && (mMinor >= other.mMinor)) ||

          ((mMajor == other.mMajor) && (mMinor == other.mMinor) && (mSub >= other.mSub)));

/*! Boolean > operator

 */

  return ( (mMajor > other.mMajor) ||

           ((mMajor == other.mMajor) && (mMinor > other.mMinor)) ||

           ((mMajor == other.mMajor) && (mMinor == other.mMinor) && (mSub > other.mSub)));

QString QgsProjectVersion::text()

{

//    [email protected]

#include <cstring>

#include <limits>

#include <cfloat>

#include <Tools.h>

	m_propertySet.clear();

	unsigned long numberOfProperties;

	ptr += sizeof(unsigned long);

	Variant v;

	{

		std::string s(reinterpret_cast<const char*>(ptr));

		ptr += s.size() + 1;

		ptr += sizeof(VariantType);

		switch (v.m_varType)

		{

		case VT_LONG:

			long l;

			ptr += sizeof(long);

			v.m_val.lVal = l;

			break;

		case VT_LONGLONG:

			long long ll;

			ptr += sizeof(long long);

			v.m_val.llVal = ll;

			break;

		case VT_BYTE:

			byte b;

			ptr += sizeof(byte);

			v.m_val.bVal = b;

			break;

		case VT_SHORT:

			short s;

			ptr += sizeof(short);

			v.m_val.iVal = s;

			break;

		case VT_FLOAT:

			float f;

			ptr += sizeof(float);

			v.m_val.fltVal = f;

			break;

		case VT_DOUBLE:

			double d;

			ptr += sizeof(double);

			v.m_val.dblVal = d;

			break;

		case VT_CHAR:

			char c;

			ptr += sizeof(char);

			v.m_val.cVal = c;

			break;

		case VT_USHORT:

			unsigned short us;

			ptr += sizeof(unsigned short);

			v.m_val.uiVal = us;

			break;

		case VT_ULONG:

			unsigned long ul;

			ptr += sizeof(unsigned long);

			v.m_val.ulVal = ul;

			break;

		case VT_ULONGLONG:

			unsigned long long ull;

			ptr += sizeof(unsigned long long);

			v.m_val.ullVal = ull;

			break;

		case VT_INT:

			int i;

			ptr += sizeof(int);

			v.m_val.intVal = i;

			break;

		case VT_UINT:

			unsigned int ui;

			ptr += sizeof(unsigned int);

			v.m_val.uintVal = ui;

			break;

		case VT_BOOL:

			byte bl;

			ptr += sizeof(byte);

			v.m_val.blVal = bl!=0;

			break;

	byte* ptr = *data;

	unsigned long numberOfProperties = m_propertySet.size();

	ptr += sizeof(unsigned long);

	std::map<std::string, Variant>::iterator it;

	for (it = m_propertySet.begin(); it != m_propertySet.end(); it++)

	{

		unsigned long strSize = (*it).first.size();

		ptr += strSize;

		*ptr = 0;

		ptr++;

		ptr += sizeof(VariantType);

		switch ((*it).second.m_varType)

		{

		case VT_LONG:

			ptr += sizeof(long);

			break;

		case VT_LONGLONG:

			ptr += sizeof(long long);

			break;

		case VT_BYTE:

			ptr += sizeof(byte);

			break;

		case VT_SHORT:

			ptr += sizeof(short);

			break;

		case VT_FLOAT:

			ptr += sizeof(float);

			break;

		case VT_DOUBLE:

			ptr += sizeof(double);

			break;

		case VT_CHAR:

			ptr += sizeof(char);

			break;

		case VT_USHORT:

			ptr += sizeof(unsigned short);

			break;

		case VT_ULONG:

			ptr += sizeof(unsigned long);

			break;

		case VT_ULONGLONG:

			ptr += sizeof(unsigned long long);

			break;

		case VT_INT:

			ptr += sizeof(int);

			break;

		case VT_UINT:

			ptr += sizeof(unsigned int);

			break;

		case VT_BOOL:

			byte bl;

			bl = (*it).second.m_val.blVal;

			ptr += sizeof(byte);

			break;

		default:

	if (lin == 0) { *out = 0; lout = 0;	return; }

	byte *data = 0, *pdata = 0, *pin;

	byte* cv = new byte[blockSize];

	byte* pv = new byte[blockSize];

	byte rl;

	unsigned long bufferLength = 2 * lin;

	pin = in;

	pv[0] = ~cv[0]; // force next character to be different.

	assert(pv[0] != cv[0]);

	data = new byte[bufferLength];

	while (pin < in + lin)

	{

		pin += blockSize;

		assert(pin <= in + lin);

			catch(...)

			{

				delete[] data;

				delete[] cv;

				delete[] pv;

				throw;

			}

			pdata = tmp + (pdata - data);

			byte* tmp2 = data;

			data = tmp;

			bufferLength *= 2;

		}

		pdata += blockSize;

		if (memcmp(cv, pv, blockSize) == 0 && pin < in + lin)

		{

			pin += sizeof(byte);

			assert(pin <= in + lin);

			if (

				catch(...)

				{

					delete[] data;

					delete[] cv;

					delete[] pv;

					throw;

				}

				pdata = tmp + (pdata - data);

				byte* tmp2 = data;

				data = tmp;

			while (rl > 0)

			{

				pdata += blockSize;

				rl--;

			}

			pv[0] = ~cv[0];

			assert(pv[0] != cv[0]);

		}

	}

	lout = pdata - data;

	catch(...)

	{

		delete[] data;

		delete[] cv;

		delete[] pv;

		throw;

	}

	delete[] data;

	delete[] cv;

	delete[] pv;

}

#if HAVE_GETTIMEOFDAY

void Tools::Geometry::LineSegment::getCenter(Point& out) const

{

	double* coords = new double[m_dimension];

	for (unsigned long cDim = 0; cDim < m_dimension; cDim++)

	{

	out = Point(coords, m_dimension);

	delete[] coords;

}

unsigned long Tools::Geometry::LineSegment::getDimension() const

void Tools::Geometry::LineSegment::getMBR(Region& out) const

{

	double* low = new double[m_dimension];

	double* high = new double[m_dimension];

	for (unsigned long cDim = 0; cDim < m_dimension; cDim++)

	{

	out = Region(low, high, m_dimension);

	delete[] low;

	delete[] high;

}

double Tools::Geometry::LineSegment::getArea() const

#endif

#endif

#endif

#include <QTextStream>

#include <QDomDocument>

#include <QPrinter> //to find out screen resolution

typedef QgsProjectVersion PFV;

  if ( ! mDom.isNull() )

  {

    {

      if ( transformers[i].from == mCurrentVersion)

      {

    }

  }

  return returnValue;

void QgsProjectFileTransform::dump()

{

  }

  return;

void QgsProjectFileTransform::transform091to0100()

{

  }

  return;

void QgsProjectFileTransform::transform0100to0110()

{

    }

  else if (name == "star")

    {

      int oneSixth = 2*r/6;

      QPolygon pa(10);

*/

class QgsDelimitedTextProvider : public QgsVectorDataProvider

{

public:

  */

class QgsPostgresProvider : public QgsVectorDataProvider

{

  public:

    /**

QgsPostgresProvider::QgsPostgresProvider(QString const & uri)

: QgsVectorDataProvider(uri),

  geomType(QGis::WKBUnknown),

  mFeatureQueueSize(200),

{

  // assume this is a valid layer until we determine otherwise

  valid = true;

  bool returnValue = true;

  OGRFeatureDefnH fdef=OGR_L_GetLayerDefn(ogrLayer);

  OGRFeatureH feature= OGR_F_Create(fdef);

  unsigned char* wkb = f.geometry()->wkbBuffer();

  if( f.geometry()->wkbSize() > 0 )

  uniqueValues.clear();

    return;

  OGRFeatureH f;

  {

    uniqueValues.append( mEncoding->toUnicode(OGR_F_GetFieldAsString(f, 0)) );

    OGR_F_Destroy(f);

  }

}

QgsMemoryProvider::QgsMemoryProvider(QString uri)

  : QgsVectorDataProvider(uri),

{

  if (uri == "Point")

    mWkbType = QGis::WKBPoint;