No OneTemporary
Actions

Size

26 KB

Referenced Files

None

Subscribers

None

View Options

	diff --git a/nepomuk/core/org.kde.nepomuk.ResourceWatcherConnection.xml b/nepomuk/core/org.kde.nepomuk.ResourceWatcherConnection.xml
	index 7684c4ab53..4ec24f19ef 100644
	--- a/nepomuk/core/org.kde.nepomuk.ResourceWatcherConnection.xml
	+++ b/nepomuk/core/org.kde.nepomuk.ResourceWatcherConnection.xml
	@@ -1,65 +1,65 @@
	<!DOCTYPE node PUBLIC "-//freedesktop//DTD D-BUS Object Introspection 1.0//EN" "http://www.freedesktop.org/standards/dbus/1.0/introspect.dtd">
	<node>
	<interface name="org.kde.nepomuk.ResourceWatcherConnection">
	<signal name="resourceCreated">
	<arg name="uri" type="s" direction="out"/>
	<arg name="types" type="as" direction="out"/>
	</signal>
	<signal name="resourceRemoved">
	<arg name="uri" type="s" direction="out"/>
	<arg name="types" type="as" direction="out"/>
	</signal>
	<signal name="resourceTypeAdded">
	<arg name="resUri" type="s" direction="out"/>
	<arg name="type" type="s" direction="out"/>
	</signal>
	<signal name="resourceTypeRemoved">
	<arg name="resUri" type="s" direction="out"/>
	<arg name="type" type="s" direction="out"/>
	</signal>
	<signal name="propertyAdded">
	<arg name="resource" type="s" direction="out"/>
	<arg name="property" type="s" direction="out"/>
	- <arg name="value" type="v" direction="out"/>
	+ <arg name="values" type="av" direction="out"/>
	</signal>
	<signal name="propertyRemoved">
	<arg name="resource" type="s" direction="out"/>
	<arg name="property" type="s" direction="out"/>
	- <arg name="value" type="v" direction="out"/>
	+ <arg name="values" type="av" direction="out"/>
	</signal>
	<signal name="propertyChanged">
	<arg name="resource" type="s" direction="out"/>
	<arg name="property" type="s" direction="out"/>
	<arg name="oldValues" type="av" direction="out"/>
	<arg name="newValues" type="av" direction="out"/>
	</signal>
	<method name="setResources">
	<arg name="resources" type="as" direction="in"/>
	</method>
	<method name="addResource">
	<arg name="resource" type="s" direction="in"/>
	</method>
	<method name="removeResource">
	<arg name="resource" type="s" direction="in"/>
	</method>
	<method name="setProperties">
	<arg name="properties" type="as" direction="in"/>
	</method>
	<method name="addProperty">
	<arg name="property" type="s" direction="in"/>
	</method>
	<method name="removeProperty">
	<arg name="property" type="s" direction="in"/>
	</method>
	<method name="setTypes">
	<arg name="types" type="as" direction="in"/>
	</method>
	<method name="addType">
	<arg name="type" type="s" direction="in"/>
	</method>
	<method name="removeType">
	<arg name="type" type="s" direction="in"/>
	</method>
	<method name="close" />
	</interface>
	</node>
	diff --git a/nepomuk/core/resourcewatcher.cpp b/nepomuk/core/resourcewatcher.cpp
	index 8feaefca96..617950320a 100644
	--- a/nepomuk/core/resourcewatcher.cpp
	+++ b/nepomuk/core/resourcewatcher.cpp
	@@ -1,276 +1,280 @@
	/*
	This file is part of the Nepomuk KDE project.
	Copyright (C) 2011 Vishesh Handa <handa.vish@gmail.com>
	Copyright (C) 2011 Sebastian Trueg <trueg@kde.org>

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*/


	#include "resourcewatcher.h"
	#include "resourcewatcherconnectioninterface.h"
	#include "resourcewatchermanagerinterface.h"

	#include <QtDBus/QDBusObjectPath>

	#include "resource.h"

	#include "kurl.h"
	#include "kdebug.h"

	namespace {
	QString convertUri(const QUrl& uri) {
	return KUrl(uri).url();
	}

	QStringList convertUris(const QList<QUrl>& uris) {
	QStringList cs;
	foreach(const QUrl& uri, uris) {
	cs << convertUri(uri);
	}
	return cs;
	}

	QList<QUrl> convertUris(const QStringList& uris) {
	QList<QUrl> us;
	foreach(const QString& uri, uris) {
	us << KUrl(uri);
	}
	return us;
	}
	}

	class Nepomuk::ResourceWatcher::Private {
	public:
	QList<QUrl> m_types;
	QList<QUrl> m_resources;
	QList<QUrl> m_properties;

	org::kde::nepomuk::ResourceWatcherConnection * m_connectionInterface;
	org::kde::nepomuk::ResourceWatcher * m_watchManagerInterface;
	};

	Nepomuk::ResourceWatcher::ResourceWatcher(QObject* parent)
	: QObject(parent),
	d(new Private)
	{
	d->m_watchManagerInterface
	= new org::kde::nepomuk::ResourceWatcher( "org.kde.nepomuk.DataManagement",
	"/resourcewatcher",
	QDBusConnection::sessionBus() );
	d->m_connectionInterface = 0;
	}

	Nepomuk::ResourceWatcher::~ResourceWatcher()
	{
	stop();
	delete d;
	}

	bool Nepomuk::ResourceWatcher::start()
	{
	//
	// Convert to list of strings
	//
	QList<QString> uris = convertUris(d->m_resources);
	QList<QString> props = convertUris(d->m_properties);
	QList<QString> types_ = convertUris(d->m_types);

	//
	// Create the dbus object to watch
	//
	QDBusPendingReply<QDBusObjectPath> reply = d->m_watchManagerInterface->watch( uris, props, types_ );
	QDBusObjectPath path = reply.value();

	if(!path.path().isEmpty()) {
	d->m_connectionInterface = new org::kde::nepomuk::ResourceWatcherConnection( "org.kde.nepomuk.DataManagement",
	path.path(),
	QDBusConnection::sessionBus() );
	- connect( d->m_connectionInterface, SIGNAL(propertyAdded(QString,QString,QDBusVariant)),
	- this, SLOT(slotPropertyAdded(QString,QString,QDBusVariant)) );
	- connect( d->m_connectionInterface, SIGNAL(propertyRemoved(QString,QString,QDBusVariant)),
	- this, SLOT(slotPropertyRemoved(QString,QString,QDBusVariant)) );
	+ connect( d->m_connectionInterface, SIGNAL(propertyAdded(QString,QString,QVariantList)),
	+ this, SLOT(slotPropertyAdded(QString,QString,QVariantList)) );
	+ connect( d->m_connectionInterface, SIGNAL(propertyRemoved(QString,QString,QVariantList)),
	+ this, SLOT(slotPropertyRemoved(QString,QString,QVariantList)) );
	connect( d->m_connectionInterface, SIGNAL(resourceCreated(QString,QStringList)),
	this, SLOT(slotResourceCreated(QString,QStringList)) );
	connect( d->m_connectionInterface, SIGNAL(propertyChanged(QString,QString,QVariantList,QVariantList)),
	this, SLOT(slotPropertyChanged(QString,QString,QVariantList,QVariantList)) );
	connect( d->m_connectionInterface, SIGNAL(resourceRemoved(QString,QStringList)),
	this, SLOT(slotResourceRemoved(QString,QStringList)) );
	connect( d->m_connectionInterface, SIGNAL(resourceTypeAdded(QString,QString)),
	this, SLOT(slotResourceTypeAdded(QString,QString)) );
	connect( d->m_connectionInterface, SIGNAL(resourceTypeRemoved(QString,QString)),
	this, SLOT(slotResourceTypeRemoved(QString,QString)) );
	return true;
	}
	else {
	return false;
	}
	}

	void Nepomuk::ResourceWatcher::stop()
	{
	if (d->m_connectionInterface) {
	d->m_connectionInterface->close();
	delete d->m_connectionInterface;
	d->m_connectionInterface = 0;
	}
	}

	void Nepomuk::ResourceWatcher::addProperty(const Nepomuk::Types::Property& property)
	{
	d->m_properties << property.uri();
	if(d->m_connectionInterface) {
	d->m_connectionInterface->addProperty(convertUri(property.uri()));
	}
	}

	void Nepomuk::ResourceWatcher::addResource(const Nepomuk::Resource& res)
	{
	d->m_resources << res.resourceUri();
	if(d->m_connectionInterface) {
	d->m_connectionInterface->addResource(convertUri(res.resourceUri()));
	}
	}

	void Nepomuk::ResourceWatcher::addType(const Nepomuk::Types::Class& type)
	{
	d->m_types << type.uri();
	if(d->m_connectionInterface) {
	d->m_connectionInterface->addType(convertUri(type.uri()));
	}
	}

	void Nepomuk::ResourceWatcher::removeProperty(const Nepomuk::Types::Property& property)
	{
	d->m_properties.removeAll(property.uri());
	if(d->m_connectionInterface) {
	d->m_connectionInterface->removeProperty(convertUri(property.uri()));
	}
	}

	void Nepomuk::ResourceWatcher::removeResource(const Nepomuk::Resource& res)
	{
	d->m_resources.removeAll(res.resourceUri());
	if(d->m_connectionInterface) {
	d->m_connectionInterface->removeResource(convertUri(res.resourceUri()));
	}
	}

	void Nepomuk::ResourceWatcher::removeType(const Nepomuk::Types::Class& type)
	{
	d->m_types.removeAll(type.uri());
	if(d->m_connectionInterface) {
	d->m_connectionInterface->removeType(convertUri(type.uri()));
	}
	}

	QList< Nepomuk::Types::Property > Nepomuk::ResourceWatcher::properties() const
	{
	QList< Nepomuk::Types::Property > props;
	foreach(const QUrl& uri, d->m_properties)
	props << Types::Property(uri);
	return props;
	}

	QList<Nepomuk::Resource> Nepomuk::ResourceWatcher::resources() const
	{
	QList<Nepomuk::Resource> resources;
	foreach(const QUrl& uri, d->m_resources)
	resources << Resource::fromResourceUri(uri);
	return resources;
	}

	QList< Nepomuk::Types::Class > Nepomuk::ResourceWatcher::types() const
	{
	QList<Nepomuk::Types::Class> types;
	foreach(const QUrl& uri, d->m_types)
	types << Types::Class(uri);
	return types;
	}

	void Nepomuk::ResourceWatcher::setProperties(const QList< Nepomuk::Types::Property >& properties_)
	{
	d->m_properties.clear();
	foreach(const Nepomuk::Types::Property& p, properties_) {
	d->m_properties << p.uri();
	}

	if(d->m_connectionInterface) {
	d->m_connectionInterface->setProperties(convertUris(d->m_properties));
	}
	}

	void Nepomuk::ResourceWatcher::setResources(const QList< Nepomuk::Resource >& resources_)
	{
	d->m_resources.clear();
	foreach(const Nepomuk::Resource& res, resources_) {
	d->m_resources << res.resourceUri();
	}

	if(d->m_connectionInterface) {
	d->m_connectionInterface->setResources(convertUris(d->m_resources));
	}
	}

	void Nepomuk::ResourceWatcher::setTypes(const QList< Nepomuk::Types::Class >& types_)
	{
	d->m_types.clear();
	foreach(const Nepomuk::Types::Class& t, types_) {
	d->m_types << t.uri();
	}

	if(d->m_connectionInterface) {
	d->m_connectionInterface->setTypes(convertUris(d->m_types));
	}
	}

	void Nepomuk::ResourceWatcher::slotResourceCreated(const QString &res, const QStringList &types)
	{
	emit resourceCreated(Nepomuk::Resource::fromResourceUri(KUrl(res)), convertUris(types));
	}

	void Nepomuk::ResourceWatcher::slotResourceRemoved(const QString &res, const QStringList &types)
	{
	emit resourceRemoved(KUrl(res), convertUris(types));
	}

	void Nepomuk::ResourceWatcher::slotResourceTypeAdded(const QString &res, const QString &type)
	{
	emit resourceTypeAdded(KUrl(res), KUrl(type));
	}

	void Nepomuk::ResourceWatcher::slotResourceTypeRemoved(const QString &res, const QString &type)
	{
	emit resourceTypeRemoved(KUrl(res), KUrl(type));
	}

	-void Nepomuk::ResourceWatcher::slotPropertyAdded(const QString& res, const QString& prop, const QDBusVariant& object)
	+void Nepomuk::ResourceWatcher::slotPropertyAdded(const QString& res, const QString& prop, const QVariantList &objects)
	{
	- emit propertyAdded( Resource::fromResourceUri(KUrl(res)), Types::Property( KUrl(prop) ), object.variant() );
	+ foreach(const QVariant& v, objects) {
	+ emit propertyAdded( Resource::fromResourceUri(KUrl(res)), Types::Property( KUrl(prop) ), v );
	+ }
	}

	-void Nepomuk::ResourceWatcher::slotPropertyRemoved(const QString& res, const QString& prop, const QDBusVariant& object)
	+void Nepomuk::ResourceWatcher::slotPropertyRemoved(const QString& res, const QString& prop, const QVariantList &objects)
	{
	- emit propertyRemoved( Resource::fromResourceUri(KUrl(res)), Types::Property( KUrl(prop) ), object.variant() );
	+ foreach(const QVariant& v, objects) {
	+ emit propertyRemoved( Resource::fromResourceUri(KUrl(res)), Types::Property( KUrl(prop) ), v );
	+ }
	}

	void Nepomuk::ResourceWatcher::slotPropertyChanged(const QString& res, const QString& prop, const QVariantList& oldObjs, const QVariantList& newObjs)
	{
	emit propertyChanged( Resource::fromResourceUri(KUrl(res)), Types::Property( KUrl(prop) ),
	oldObjs, newObjs );
	}

	#include "resourcewatcher.moc"

	diff --git a/nepomuk/core/resourcewatcher.h b/nepomuk/core/resourcewatcher.h
	index 7061fd0b1b..06b96229cd 100644
	--- a/nepomuk/core/resourcewatcher.h
	+++ b/nepomuk/core/resourcewatcher.h
	@@ -1,315 +1,315 @@
	/*
	This file is part of the Nepomuk KDE project.
	Copyright (C) 2011 Vishesh Handa <handa.vish@gmail.com>
	Copyright (C) 2011 Sebastian Trueg <trueg@kde.org>

	This library is free software; you can redistribute it and/or
	modify it under the terms of the GNU Lesser General Public
	License as published by the Free Software Foundation; either
	version 2.1 of the License, or (at your option) any later version.

	This library is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	Lesser General Public License for more details.

	You should have received a copy of the GNU Lesser General Public
	License along with this library; if not, write to the Free Software
	Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	*/


	#ifndef RESOURCEWATCHER_H
	#define RESOURCEWATCHER_H

	#include "../types/class.h"
	#include "../types/property.h"
	#include "resource.h"

	#include <QtDBus/QDBusVariant>
	#include <QtCore/QVariant>

	namespace Nepomuk {

	/**
	* \class ResourceWatcher resourcewatcher.h
	*
	* \brief Selectively monitor the nepomuk repository for changes.
	*
	* Resources may be monitored on the basis of types, properties, and uris.
	*
	* Changes may be monitored in one of the following ways:
	* -# By resources -
	* Specify the exact resources that should be watched. Any changes made to the specified resources
	* (Excluding \ref nepomuk_dms_metadata) will be notified through the propertyAdded() and propertyRemoved()
	* signals. Notifications will also be sent if any of the watched resources is deleted.
	* -# By resources and properties -
	* Specify the exact resources and their properties. Any changes made to the specified resources
	* which touch one of the specified properties will be notified through the propertyAdded() and propertyRemoved()
	* signals.
	* -# By types -
	* Specific types may be specified via add/setType. If types are set, then notifications will be
	* sent for all new resources of that type. This includes property changes and resource creation and removal.
	* TODO: add flags that allow to only watch for resource creation and removal.
	* -# By types and properties -
	* Both the types and properties may be specified. Notifications will be sent for property changes
	* in resource with the specified types.
	*
	* \section nepomuk_rw_examples Resource Watcher Usage Example
	*
	* The following code creates a new ResourceWatcher, configures it to listen to changes on the \c nmm:performer
	* property on one specific resource \c res.
	*
	* \code
	* Nepomuk::ResourceWatcher* watcher = new Nepomuk::ResourceWatcher(this);
	* watcher->addResource(res);
	* watcher->addProperty(NMM:performer());
	* connect(watcher, SIGNAL(propertyAdded(Nepomuk::Resource, Nepomuk::Types::Property, QVariant)),
	* this, SLOT(slotPropertyChanged()));
	* connect(watcher, SIGNAL(propertyRemoved(Nepomuk::Resource, Nepomuk::Types::Property, QVariant)),
	* this, SLOT(slotPropertyChanged()));
	* rwatcher->start();
	* \endcode
	*
	* \author Vishesh Handa <handa.vish@gmail.com>, Sebastian Trueg <trueg@kde.org>
	*
	* \ingroup nepomuk_datamanagement
	*/
	class ResourceWatcher : public QObject
	{
	Q_OBJECT

	public:
	/**
	* \brief Create a new %ResourceWatcher instance.
	*
	* This instance will not emit any signals before it has been configured
	* and started.
	*/
	ResourceWatcher( QObject* parent = 0 );

	/**
	* \brief Destructor.
	*/
	virtual ~ResourceWatcher();

	/**
	* \brief Add a type to be watched.
	*
	* Every resource of this type will be watched for changes.
	*
	* \sa setTypes()
	*/
	void addType( const Types::Class & type );

	/**
	* \brief Add a resource to be watched.
	*
	* Every change to this resource will be
	* signalled, depending on the configured properties().
	*
	* \sa setResources()
	*/
	void addResource( const Nepomuk::Resource & res );

	/**
	* \brief Add a property to be watched.
	*
	* Every change to a value of this property
	* will be signalled, depending on the configured resources() or types().
	*
	* \sa setProperties()
	*/
	void addProperty( const Types::Property & property );

	/**
	* \brief Remove a type to be watched.
	*
	* Every resource of this type will be watched for changes.
	*
	* \sa setTypes()
	*/
	void removeType( const Types::Class & type );

	/**
	* \brief Remove a resource to be watched.
	*
	* Every change to this resource will be
	* signalled, depending on the configured properties().
	*
	* \sa setResources()
	*/
	void removeResource( const Nepomuk::Resource & res );

	/**
	* \brief Remove a property to be watched.
	*
	* Every change to a value of this property
	* will be signalled, depending on the configured resources() or types().
	*
	* \sa setProperties()
	*/
	void removeProperty( const Types::Property & property );

	/**
	* \brief Set the types to be watched.
	*
	* Every resource having one of these types will be watched for changes.
	*
	* \sa addType()
	*/
	void setTypes( const QList<Types::Class> & types_ );

	/**
	* \brief Set the resources to be watched.
	*
	* Every change to one of these resources will be
	* signalled, depending on the configured properties().
	*
	* \sa addResource()
	*/
	void setResources( const QList<Nepomuk::Resource> & resources_ );

	/**
	* \brief Set the properties to be watched.
	*
	* Every change to a value of any of these properties
	* will be signalled, depending on the configured resources() or types().
	*
	* \sa addProperty()
	*/
	void setProperties( const QList<Types::Property> & properties_ );

	/**
	* \brief The types that have been configured via addType() and setTypes().
	*
	* Every resource having one of these types will be watched
	* for changes.
	*/
	QList<Types::Class> types() const;

	/**
	* \brief The resources that have been configured via addResource() and setResources().
	*
	* Every change to one of these resources will be
	* signalled, depending on the configured properties().
	*/
	QList<Nepomuk::Resource> resources() const;

	/**
	* \brief The properties that have been configured via addProperty() and setProperties().
	*
	* Every change to a value of any of these properties
	* will be signalled, depending on the configured resources() or types().
	*/
	QList<Types::Property> properties() const;

	public Q_SLOTS:
	/**
	* \brief Start the signalling of changes.
	*
	* Before calling this method no signal will be emitted. In
	* combination with stop() this allows to suspend the watching.
	* Calling start() multiple times has no effect.
	*/
	bool start();

	/**
	* \brief Stop the signalling of changes.
	*
	* Allows to stop the watcher which has been started
	* via start(). Calling stop() multiple times has no effect.
	*/
	void stop();

	Q_SIGNALS:
	/**
	* \brief This signal is emitted when a new resource is created.
	* \param resource The newly created resource.
	* \param types The types the new resource has. If types() have been configured this list will always
	* contain one of the configured types.
	*/
	void resourceCreated( const Nepomuk::Resource & resource, const QList<QUrl>& types ); //FIXME: Use either Resource or uri, not a mix

	/**
	* \brief This signal is emitted when a resource is deleted.
	* \param uri The resource URI of the removed resource.
	* \param types The types the removed resource had. If types() have been configured this list will always
	* contain one of the configured types.
	*/
	void resourceRemoved( const QUrl & uri, const QList<QUrl>& types );

	/**
	* \brief This signal is emitted when a type has been added to a resource. This does not include creation which
	* is signalled via resourceCreated(). It only applies to changes in a resource's types.
	* \param res The changed resource.
	* \param type The newly added type. If types() have been configured it will be one of them.
	*/
	void resourceTypeAdded( const Nepomuk::Resource & res, const Types::Class & type );

	/**
	* \brief This signal is emitted when a type has been removed from a resource.
	*
	* This does not include removal of entire resources which is signalled via resourceRemoved().
	* It only applies to changes in a resource's types.
	* \param res The changed resource.
	* \param type The removed type. If types() have been configured it will be one of them.
	*/
	void resourceTypeRemoved( const Nepomuk::Resource & res, const Types::Class & type );

	/**
	* \brief This signal is emitted when a property value is added.
	* \param resource The changed resource.
	* \param property The property which has a new value.
	* \param value The newly added property value.
	*/
	void propertyAdded( const Nepomuk::Resource & resource,
	const Nepomuk::Types::Property & property,
	const QVariant & value );

	/**
	* \brief This signal is emitted when a property value is removed.
	* \param resource The changed resource.
	* \param property The property which was changed.
	* \param value The removed property value.
	*/
	void propertyRemoved( const Nepomuk::Resource & resource,
	const Nepomuk::Types::Property & property,
	const QVariant & value );

	/**
	* \brief This signal is emitted when a property value is changed.
	*
	* This signal cannot be emitted for all changes. It doesn't work if a property is first
	* removed and then set, cause the Data Mangement Service does not maintain an internal
	* cache for the purpose of emitting the propertyChanged signal.
	*
	* Specially, since one could theoretically take forever between the removal and the
	* setting of the property.
	*
	* \param resource The changed resource.
	* \param property The property which was changed.
	* \param oldValue The removed property value.
	*/
	void propertyChanged( const Nepomuk::Resource & resource,
	const Nepomuk::Types::Property & property,
	const QVariantList & oldValue,
	const QVariantList & newValue );

	private Q_SLOTS:
	void slotResourceCreated(const QString& res, const QStringList& types);
	void slotResourceRemoved(const QString& res, const QStringList& types);
	void slotResourceTypeAdded(const QString& res, const QString& type);
	void slotResourceTypeRemoved(const QString& res, const QString& type);
	- void slotPropertyAdded(const QString& res, const QString& prop, const QDBusVariant& object);
	- void slotPropertyRemoved(const QString& res, const QString& prop, const QDBusVariant& object);
	+ void slotPropertyAdded(const QString& res, const QString& prop, const QVariantList& objects);
	+ void slotPropertyRemoved(const QString& res, const QString& prop, const QVariantList& objects);
	void slotPropertyChanged(const QString& res, const QString& prop,
	const QVariantList & oldObjs,
	const QVariantList & newObjs);
	private:
	class Private;
	Private * d;
	};
	}

	#endif // RESOURCEWATCHER_H

File Metadata

Mime Type: text/x-diff
Expires: Fri, Nov 1, 8:21 AM (1 d, 5 h)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 10074939
Default Alt Text: (26 KB)

No OneTemporaryActions

View Options

File Metadata

Event Timeline

No OneTemporary
Actions