added preliminary target body functionality to ipce (85e92860) · Commits · aflab / astrogeology / ISIS3

isis/src/qisis/objs/GuiCameraDisplayProperties/GuiCameraDisplayProperties.cpp

0 → 100644

+281 −0

Original line number	Diff line number	Diff line
		#include "GuiCameraDisplayProperties.h"

		#include <QAction>
		#include <QBitArray>
		#include <QBuffer>
		#include <QColorDialog>
		#include <QDebug>
		#include <QInputDialog>
		#include <QMap>
		#include <QVariant>
		#include <QXmlStreamWriter>

		#include "FileName.h"
		#include "Pvl.h"
		#include "XmlStackedHandlerReader.h"

		namespace Isis {
		/**
		* GuiCameraDisplayProperties constructor. This sets default values and
		* constructs the object *.
		*
		*
		* @param displayName The filename (fully expanded) of the object.
		* @param parent Qt parent object (this is destroyed when parent is destroyed)
		*/
		GuiCameraDisplayProperties::GuiCameraDisplayProperties(QString displayName, QObject *parent) :
		DisplayProperties(displayName, parent) {

		m_propertiesUsed = None;
		m_propertyValues = new QMap<int, QVariant>;

		// set all of the defaults to prevent unwanted change signals from
		// being emitted later.
		setShowLabel(false);
		setSelected(false);

		setValue(Color, QVariant::fromValue(randomColor()));
		}


		GuiCameraDisplayProperties::GuiCameraDisplayProperties(XmlStackedHandlerReader *xmlReader,
		QObject *parent) : DisplayProperties("", parent) {
		m_propertiesUsed = None;
		m_propertyValues = new QMap<int, QVariant>;

		xmlReader->pushContentHandler(new XmlHandler(this));
		}


		/**
		* destructor
		*/
		GuiCameraDisplayProperties::~GuiCameraDisplayProperties() {
		}


		// void GuiCameraDisplayProperties::fromPvl(const PvlObject &pvl) {
		// m_displayName = ((IString)pvl["DisplayName"][0]).ToQt();

		// QByteArray hexValues(pvl["Values"][0].c_str());
		// QDataStream valuesStream(QByteArray::fromHex(hexValues));
		// valuesStream >> *m_propertyValues;
		// }


		// /**
		// * Convert to Pvl for project files. This stores all of the data associated
		// * with all of the properties (but not what is supported). This also s tores
		// * the target filename.
		// */
		// PvlObject GuiCameraDisplayProperties::toPvl() const {
		// PvlObject output("DisplayProperties");
		// output += PvlKeyword("DisplayName", m_displayName);

		// QBuffer dataBuffer;
		// dataBuffer.open(QIODevice::ReadWrite);

		// QDataStream propsStream(&dataBuffer);
		// propsStream << *m_propertyValues;
		// dataBuffer.seek(0);

		// output += PvlKeyword("Values", QString(dataBuffer.data().toHex()));

		// return output;
		// }


		/**
		* Call this with every property you support, otherwise they will not
		* communicate properly between widgets.
		*
		* @param prop The property you are adding support for
		*/
		void GuiCameraDisplayProperties::addSupport(Property prop) {
		if (!supports(prop)) {
		m_propertiesUsed = (Property)(m_propertiesUsed \| prop);
		emit supportAdded(prop);
		}
		}


		/**
		* Support may come later, please make sure you are connected to the
		* supportAdded signal.
		*
		* @returns True if the property has support, false otherwise
		*/
		bool GuiCameraDisplayProperties::supports(Property prop) {
		return (m_propertiesUsed & prop) == prop;
		}


		/**
		* Get a property's associated data.
		*
		* @param prop The property
		*/
		QVariant GuiCameraDisplayProperties::getValue(Property prop) const {
		return (*m_propertyValues)[prop];
		}


		/**
		* Creates and returns a random color for the intial color of
		* the footprint polygon.
		*/
		QColor GuiCameraDisplayProperties::randomColor() {
		// Gives a random number between 0 and 255
		int red = 0;
		int green = 0;
		int blue = 0;

		// Generate dark
		while(red + green + blue < 300) {
		red = rand() % 256;
		green = rand() % 256;
		blue = rand() % 256;
		}

		return QColor(red, green, blue, 60);
		}


		void GuiCameraDisplayProperties::save(QXmlStreamWriter &stream, const Project *project,
		FileName newProjectRoot) const {
		stream.writeStartElement("displayProperties");

		stream.writeAttribute("displayName", displayName());

		// Get hex-encoded data
		QBuffer dataBuffer;
		dataBuffer.open(QIODevice::ReadWrite);
		QDataStream propsStream(&dataBuffer);
		propsStream << *m_propertyValues;
		dataBuffer.seek(0);

		stream.writeCharacters(dataBuffer.data().toHex());

		stream.writeEndElement();
		}


		/**
		* Change the color associated with this target.
		*/
		void GuiCameraDisplayProperties::setColor(QColor newColor) {
		setValue(Color, QVariant::fromValue(newColor));
		}


		/**
		* Change the selected state associated with this target.
		*/
		void GuiCameraDisplayProperties::setSelected(bool newValue) {
		setValue(Selected, newValue);
		}


		/**
		* Change the visibility of the display name associated with this target.
		*/
		void GuiCameraDisplayProperties::setShowLabel(bool newValue) {
		setValue(ShowLabel, newValue);
		}


		/**
		* Change the visibility of the display name. This should only be connected to
		* by an action with a list of displays as its data. This synchronizes all
		* of the values where at least one is guaranteed to be toggled.
		*/
		void GuiCameraDisplayProperties::toggleShowLabel() {
		QList<GuiCameraDisplayProperties *> displays = senderToData(sender());

		bool value = getValue(ShowLabel).toBool();
		value = !value;

		GuiCameraDisplayProperties *display;
		foreach(display, displays) {
		display->setShowLabel(value);
		}
		}


		GuiCameraDisplayProperties::XmlHandler::XmlHandler(GuiCameraDisplayProperties *displayProperties) {
		m_displayProperties = displayProperties;
		}


		bool GuiCameraDisplayProperties::XmlHandler::startElement(const QString &namespaceURI,
		const QString &localName, const QString &qName, const QXmlAttributes &atts) {
		if (XmlStackedHandler::startElement(namespaceURI, localName, qName, atts)) {
		if (localName == "displayProperties") {
		QString displayName = atts.value("displayName");

		if (!displayName.isEmpty()) {
		m_displayProperties->setDisplayName(displayName);
		}
		}
		}

		return true;
		}


		bool GuiCameraDisplayProperties::XmlHandler::characters(const QString &ch) {
		m_hexData += ch;

		return XmlStackedHandler::characters(ch);
		}


		bool GuiCameraDisplayProperties::XmlHandler::endElement(const QString &namespaceURI,
		const QString &localName, const QString &qName) {
		if (localName == "displayProperties") {
		QByteArray hexValues(m_hexData.toAscii());
		QDataStream valuesStream(QByteArray::fromHex(hexValues));
		valuesStream >> *m_displayProperties->m_propertyValues;
		}

		return XmlStackedHandler::endElement(namespaceURI, localName, qName);
		}


		/**
		* This is the generic mutator for properties. Given a value, this will
		* change it and emit propertyChanged if its different and supported.
		*/
		void GuiCameraDisplayProperties::setValue(Property prop, QVariant value) {
		if ((*m_propertyValues)[prop] != value) {
		(*m_propertyValues)[prop] = value;

		if (supports(prop)) {
		emit propertyChanged(this);
		}
		}
		}


		/**
		* This is for the slots that have a list of display properties as associated
		* data. This gets that list out of the data.
		*/
		QList<GuiCameraDisplayProperties *> GuiCameraDisplayProperties::senderToData(
		QObject *senderObj) {
		QList<GuiCameraDisplayProperties *> data;

		if (senderObj) {
		QAction caller = (QAction )senderObj;
		QVariant callerData = caller->data();

		if (callerData.canConvert< QList<GuiCameraDisplayProperties *> >() ) {
		data = callerData.value< QList<GuiCameraDisplayProperties *> >();
		}
		}

		return data;
		}


		}

isis/src/qisis/objs/GuiCameraDisplayProperties/GuiCameraDisplayProperties.h

0 → 100644

+169 −0

Original line number	Diff line number	Diff line
		#ifndef GuiCameraDisplayProperties_H
		#define GuiCameraDisplayProperties_H
		/**
		* @file
		* $Revision: 1.9 $
		* $Date: 2012/06/12 06:30:00 $
		*
		* Unless noted otherwise, the portions of Isis written by the USGS are
		* public domain. See individual third-party library and package descriptions
		* for intellectual property information, user agreements, and related
		* information.
		*
		* Although Isis has been used by the USGS, no warranty, expressed or
		* implied, is made by the USGS as to the accuracy and functioning of such
		* software and related material nor shall the fact of distribution
		* constitute any such warranty, and no responsibility is assumed by the
		* USGS in connection therewith.
		*
		* For additional information, launch
		* $ISISROOT/doc//documents/Disclaimers/Disclaimers.html
		* in a browser or see the Privacy & Disclaimers page on the Isis website,
		* http://isis.astrogeology.usgs.gov, and the USGS privacy and disclaimers on
		* http://www.usgs.gov/privacy.html.
		*/

		#include <QObject>
		#include <QMetaType> // required since we're adding to QVariant
		#include <QColor> // This is required since QColor is in a slot

		#include "DisplayProperties.h"
		#include "XmlStackedHandler.h"

		class QAction;
		class QXmlStreamWriter;

		namespace Isis {
		class FileName;
		class Project;
		class Pvl;
		class PvlObject;
		class XmlStackedHandlerReader;

		/**
		* @brief This is the GUI communication mechanism for target body objects.
		*
		* This class is the connector between various GUI interfaces for target body objects.
		* We use this to communicate shared properties that various widgets need
		* to know/should react to in a generic way.
		*
		* This is how this class is supposed to "connect" widgets:
		*
		* widgetA widgetB widgetC
		* \| \| \|
		* ------DisplayProperties -------
		*
		* When a user selects a target in widgetA, widgetB and widgetC now have a
		* chance to also select the same target. This applies to all shared
		* properties. Some of the properties are actions - such as ?????. This
		* also allows a widget with no ??? (such as a list) to have an option
		* to ???? (if any of the widgets support it*) and have that option work.
		* There is no state associated with ????? - it's an action connected
		* to a signal.
		*
		* The proper way to detect a target going away is to connect to the
		* destroyed signal (from the parent QObject). Once that is emitted you
		* cannot call any methods on this object.
		*
		* @author 2015-05-27 Ken Edmundson
		*
		* @internal
		* @history 2015-05-27 Ken Edmundson - Creation.
		*/
		class GuiCameraDisplayProperties : public DisplayProperties {
		Q_OBJECT
		public:
		/**
		* This is a list of properties and actions that are possible.
		*/
		enum Property {
		//! Null display property for bit-flag purposes
		None = 0,
		//! The color of the control net, default randomized (QColor)
		Color = 1,
		//! The selection state of this control net (bool)
		Selected = 2,
		//! True if the control net should show its display name (bool)
		ShowLabel = 16,
		};


		GuiCameraDisplayProperties(QString displayName, QObject *parent = NULL);
		GuiCameraDisplayProperties(XmlStackedHandlerReader xmlReader, QObject parent = NULL);
		virtual ~GuiCameraDisplayProperties();

		// void fromPvl(const PvlObject &pvl);
		// PvlObject toPvl() const;

		void addSupport(Property prop);
		bool supports(Property prop);

		QVariant getValue(Property prop) const;

		static QColor randomColor();

		void save(QXmlStreamWriter &stream, const Project *project, FileName newProjectRoot) const;

		signals:
		void propertyChanged(GuiCameraDisplayProperties *);
		void supportAdded(Property);

		public slots:
		void setColor(QColor newColor);
		void setShowLabel(bool);
		void setSelected(bool);

		private slots:
		void toggleShowLabel();

		private:
		/**
		* @author 2012-??-?? ???
		*
		* @internal
		*/
		class XmlHandler : public XmlStackedHandler {
		public:
		XmlHandler(GuiCameraDisplayProperties *displayProperties);

		virtual bool startElement(const QString &namespaceURI, const QString &localName,
		const QString &qName, const QXmlAttributes &atts);

		virtual bool characters(const QString &ch);

		virtual bool endElement(const QString &namespaceURI, const QString &localName,
		const QString &qName);

		private:
		Q_DISABLE_COPY(XmlHandler);

		GuiCameraDisplayProperties *m_displayProperties;
		QString m_hexData;
		};

		private:
		GuiCameraDisplayProperties(const GuiCameraDisplayProperties &);
		GuiCameraDisplayProperties &operator=(const GuiCameraDisplayProperties &);

		void setValue(Property prop, QVariant value);
		static QList<GuiCameraDisplayProperties > senderToData(QObject sender);

		/**
		* This indicated whether any widgets with this DisplayProperties
		* is using a particular property. This helps others who can set
		* but not display know whether they should give the option to set.
		*/
		Property m_propertiesUsed;

		/**
		* This is a map from Property to value -- the reason I use an int is
		* so Qt knows how to serialize this QMap into binary data
		*/
		QMap<int, QVariant> *m_propertyValues;
		};
		}

		Q_DECLARE_METATYPE(QList<Isis::GuiCameraDisplayProperties *>);

		#endif

isis/src/qisis/objs/GuiCameraDisplayProperties/Makefile

0 → 100644

+7 −0

Original line number	Diff line number	Diff line
		ifeq ($(ISISROOT), $(BLANK))
		.SILENT:
		error:
		echo "Please set ISISROOT";
		else
		include $(ISISROOT)/make/isismake.objs
		endif
		No newline at end of file

isis/src/qisis/objs/GuiCameraDisplayProperties/moc_GuiCameraDisplayProperties.cpp

0 → 100644

+122 −0

Original line number	Diff line number	Diff line
		/****************************************************************************
		** Meta object code from reading C++ file 'GuiCameraDisplayProperties.h'
		**
		** Created by: The Qt Meta Object Compiler version 63 (Qt 4.8.6)
		**
		** WARNING! All changes made in this file will be lost!
		*****************************************************************************/

		#include "GuiCameraDisplayProperties.h"
		#if !defined(Q_MOC_OUTPUT_REVISION)
		#error "The header file 'GuiCameraDisplayProperties.h' doesn't include <QObject>."
		#elif Q_MOC_OUTPUT_REVISION != 63
		#error "This file was generated using the moc from 4.8.6. It"
		#error "cannot be used with the include files from this version of Qt."
		#error "(The moc has changed too much.)"
		#endif

		QT_BEGIN_MOC_NAMESPACE
		static const uint qt_meta_data_Isis__GuiCameraDisplayProperties[] = {

		// content:
		6, // revision
		0, // classname
		0, 0, // classinfo
		6, 14, // methods
		0, 0, // properties
		0, 0, // enums/sets
		0, 0, // constructors
		0, // flags
		2, // signalCount

		// signals: signature, parameters, type, tag, flags
		34, 33, 33, 33, 0x05,
		79, 33, 33, 33, 0x05,

		// slots: signature, parameters, type, tag, flags
		111, 102, 33, 33, 0x0a,
		128, 33, 33, 33, 0x0a,
		147, 33, 33, 33, 0x0a,
		165, 33, 33, 33, 0x08,

		0 // eod
		};

		static const char qt_meta_stringdata_Isis__GuiCameraDisplayProperties[] = {
		"Isis::GuiCameraDisplayProperties\0\0"
		"propertyChanged(GuiCameraDisplayProperties*)\0"
		"supportAdded(Property)\0newColor\0"
		"setColor(QColor)\0setShowLabel(bool)\0"
		"setSelected(bool)\0toggleShowLabel()\0"
		};

		void Isis::GuiCameraDisplayProperties::qt_static_metacall(QObject _o, QMetaObject::Call _c, int _id, void *_a)
		{
		if (_c == QMetaObject::InvokeMetaMethod) {
		Q_ASSERT(staticMetaObject.cast(_o));
		GuiCameraDisplayProperties _t = static_cast<GuiCameraDisplayProperties >(_o);
		switch (_id) {
		case 0: _t->propertyChanged((reinterpret_cast< GuiCameraDisplayProperties(*)>(_a[1]))); break;
		case 1: _t->supportAdded((reinterpret_cast< Property()>(_a[1]))); break;
		case 2: _t->setColor((reinterpret_cast< QColor()>(_a[1]))); break;
		case 3: _t->setShowLabel((reinterpret_cast< bool()>(_a[1]))); break;
		case 4: _t->setSelected((reinterpret_cast< bool()>(_a[1]))); break;
		case 5: _t->toggleShowLabel(); break;
		default: ;
		}
		}
		}

		const QMetaObjectExtraData Isis::GuiCameraDisplayProperties::staticMetaObjectExtraData = {
		0, qt_static_metacall
		};

		const QMetaObject Isis::GuiCameraDisplayProperties::staticMetaObject = {
		{ &DisplayProperties::staticMetaObject, qt_meta_stringdata_Isis__GuiCameraDisplayProperties,
		qt_meta_data_Isis__GuiCameraDisplayProperties, &staticMetaObjectExtraData }
		};

		#ifdef Q_NO_DATA_RELOCATION
		const QMetaObject &Isis::GuiCameraDisplayProperties::getStaticMetaObject() { return staticMetaObject; }
		#endif //Q_NO_DATA_RELOCATION

		const QMetaObject *Isis::GuiCameraDisplayProperties::metaObject() const
		{
		return QObject::d_ptr->metaObject ? QObject::d_ptr->metaObject : &staticMetaObject;
		}

		void Isis::GuiCameraDisplayProperties::qt_metacast(const char _clname)
		{
		if (!_clname) return 0;
		if (!strcmp(_clname, qt_meta_stringdata_Isis__GuiCameraDisplayProperties))
		return static_cast<void>(const_cast< GuiCameraDisplayProperties>(this));
		return DisplayProperties::qt_metacast(_clname);
		}

		int Isis::GuiCameraDisplayProperties::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
		{
		_id = DisplayProperties::qt_metacall(_c, _id, _a);
		if (_id < 0)
		return _id;
		if (_c == QMetaObject::InvokeMetaMethod) {
		if (_id < 6)
		qt_static_metacall(this, _c, _id, _a);
		_id -= 6;
		}
		return _id;
		}

		// SIGNAL 0
		void Isis::GuiCameraDisplayProperties::propertyChanged(GuiCameraDisplayProperties * _t1)
		{
		void _a[] = { 0, const_cast<void>(reinterpret_cast<const void*>(&_t1)) };
		QMetaObject::activate(this, &staticMetaObject, 0, _a);
		}

		// SIGNAL 1
		void Isis::GuiCameraDisplayProperties::supportAdded(Property _t1)
		{
		void _a[] = { 0, const_cast<void>(reinterpret_cast<const void*>(&_t1)) };
		QMetaObject::activate(this, &staticMetaObject, 1, _a);
		}
		QT_END_MOC_NAMESPACE