NS_INTERFACE_MAP_END
NS_IMETHODIMP
ImageLoader::Notify(imgIRequest* aRequest, int32_t aType, const nsIntRect* aData)
{
if (aType == imgINotificationObserver::SIZE_AVAILABLE) {
nsCOMPtr<imgIContainer> image;
aRequest->GetImage(getter_AddRefs(image));
return OnSizeAvailable(aRequest, image);
}
if (aType == imgINotificationObserver::IS_ANIMATED) {
return OnImageIsAnimated(aRequest);
}
if (aType == imgINotificationObserver::FRAME_COMPLETE) {
return OnFrameComplete(aRequest);
}
if (aType == imgINotificationObserver::FRAME_UPDATE) {
return OnFrameUpdate(aRequest);
}
return NS_OK;
}
void EC_MediaPlayer::TargetMeshMaterialChanged(uint index, const QString &material)
{
if (!componentPrepared_)
return;
if (sceneCanvasName_.isEmpty())
return;
if (!ParentEntity())
return;
if (!getenabled())
return;
if (index == (uint)getrenderSubmeshIndex())
{
EC_WidgetCanvas *sceneCanvas = GetSceneCanvasComponent();
if (sceneCanvas)
{
if (material != sceneCanvas->GetMaterialName())
{
// This will make 3DCanvas to update its internals, which means
// our material is re-applied to the submesh.
sceneCanvas->SetSubmesh(getrenderSubmeshIndex());
if (pendingMediaDownload_)
OnFrameUpdate(downloadingLogo_);
else if (mediaPlayer_)
mediaPlayer_->ForceUpdateImage();
}
}
}
}
//==============================
// OvrSliderComponent::OnEvent_Impl
eMsgStatus OvrSliderComponent::OnEvent_Impl( OvrGuiSys & guiSys, VrFrame const & vrFrame,
VRMenuObject * self, VRMenuEvent const & event )
{
switch ( event.EventType )
{
case VRMENU_EVENT_INIT:
return OnInit( guiSys, vrFrame, self, event );
case VRMENU_EVENT_FRAME_UPDATE:
return OnFrameUpdate( guiSys, vrFrame, self, event );
case VRMENU_EVENT_TOUCH_DOWN:
return OnTouchDown( guiSys, vrFrame, self, event );
case VRMENU_EVENT_TOUCH_UP:
if ( OnReleaseFunction )
{
( *OnReleaseFunction )( this, OnReleaseObject, SliderFrac );
}
TouchDown = false;
return OnTouchUp( guiSys, vrFrame, self, event );
case VRMENU_EVENT_TOUCH_RELATIVE:
return OnTouchRelative( guiSys, vrFrame, self, event );
default:
OVR_ASSERT( false );
return MSG_STATUS_ALIVE;
}
return MSG_STATUS_CONSUMED;
}
/* static */ void
ProgressTracker::SyncNotifyInternal(ProxyArray& aProxies,
bool aHasImage,
Progress aProgress,
const nsIntRect& aDirtyRect)
{
MOZ_ASSERT(NS_IsMainThread());
// OnStartRequest
if (aProgress & FLAG_REQUEST_STARTED)
NOTIFY_IMAGE_OBSERVERS(aProxies, OnStartRequest());
// OnStartContainer
if (aProgress & FLAG_HAS_SIZE)
NOTIFY_IMAGE_OBSERVERS(aProxies, OnStartContainer());
// OnStartDecode
if (aProgress & FLAG_DECODE_STARTED)
NOTIFY_IMAGE_OBSERVERS(aProxies, OnStartDecode());
// BlockOnload
if (aProgress & FLAG_ONLOAD_BLOCKED)
NOTIFY_IMAGE_OBSERVERS(aProxies, BlockOnload());
if (aHasImage) {
// OnFrameUpdate
// If there's any content in this frame at all (always true for
// vector images, true for raster images that have decoded at
// least one frame) then send OnFrameUpdate.
if (!aDirtyRect.IsEmpty())
NOTIFY_IMAGE_OBSERVERS(aProxies, OnFrameUpdate(&aDirtyRect));
if (aProgress & FLAG_FRAME_STOPPED)
NOTIFY_IMAGE_OBSERVERS(aProxies, OnStopFrame());
// OnImageIsAnimated
if (aProgress & FLAG_IS_ANIMATED)
NOTIFY_IMAGE_OBSERVERS(aProxies, OnImageIsAnimated());
}
// Send UnblockOnload before OnStopDecode and OnStopRequest. This allows
// observers that can fire events when they receive those notifications to do
// so then, instead of being forced to wait for UnblockOnload.
if (aProgress & FLAG_ONLOAD_UNBLOCKED) {
NOTIFY_IMAGE_OBSERVERS(aProxies, UnblockOnload());
}
if (aProgress & FLAG_DECODE_STOPPED) {
MOZ_ASSERT(aHasImage, "Stopped decoding without ever having an image?");
NOTIFY_IMAGE_OBSERVERS(aProxies, OnStopDecode());
}
if (aProgress & FLAG_REQUEST_STOPPED) {
NOTIFY_IMAGE_OBSERVERS(aProxies,
OnStopRequest(aProgress & FLAG_MULTIPART_STOPPED));
}
}
//==============================
// OvrScrollBarComponent::OnEvent_Impl
eMsgStatus OvrScrollBarComponent::OnEvent_Impl( OvrGuiSys & guiSys, VrFrame const & vrFrame,
VRMenuObject * self, VRMenuEvent const & event )
{
switch ( event.EventType )
{
case VRMENU_EVENT_FRAME_UPDATE:
return OnFrameUpdate( guiSys, vrFrame, self, event );
default:
OVR_ASSERT( false );
break;
}
return MSG_STATUS_ALIVE;
}
//==============================
// OvrScrollBarComponent::OnEvent_Impl
eMsgStatus OvrScrollBarComponent::OnEvent_Impl( App * app, VrFrame const & vrFrame, OvrVRMenuMgr & menuMgr,
VRMenuObject * self, VRMenuEvent const & event )
{
switch ( event.EventType )
{
case VRMENU_EVENT_FRAME_UPDATE:
return OnFrameUpdate( app, vrFrame, menuMgr, self, event );
default:
OVR_ASSERT( false );
return MSG_STATUS_ALIVE;
}
return MSG_STATUS_CONSUMED;
}
//==============================
// OvrSliderComponent::OnEvent_Impl
eMsgStatus OvrSliderComponent::OnEvent_Impl( App * app, VrFrame const & vrFrame, OvrVRMenuMgr & menuMgr,
VRMenuObject * self, VRMenuEvent const & event )
{
switch ( event.EventType )
{
case VRMENU_EVENT_INIT:
return OnInit( app, vrFrame, menuMgr, self, event );
case VRMENU_EVENT_FRAME_UPDATE:
return OnFrameUpdate( app, vrFrame, menuMgr, self, event );
case VRMENU_EVENT_TOUCH_DOWN:
return OnTouchDown( app, vrFrame, menuMgr, self, event );
case VRMENU_EVENT_TOUCH_UP:
return OnTouchUp( app, vrFrame, menuMgr, self, event );
TouchDown = false;
case VRMENU_EVENT_TOUCH_RELATIVE:
return OnTouchRelative( app, vrFrame, menuMgr, self, event );
default:
OVR_ASSERT( false );
return MSG_STATUS_ALIVE;
}
return MSG_STATUS_CONSUMED;
}
EC_MediaPlayer::EC_MediaPlayer(Scene* scene) :
IComponent(scene),
mediaPlayer_(0),
componentPrepared_(false),
pendingMediaDownload_(false),
sourceRef(this, "Media Source", AssetReference("", "")),
renderSubmeshIndex(this, "Render Submesh", 0),
interactive(this, "Interactive", false),
illuminating(this, "Illuminating", true),
streamingAllowed(this, "Streaming Allowed", true),
enabled(this, "Enabled", true)
{
if (!ViewEnabled() || GetFramework()->IsHeadless())
return;
// Set metadata min/max/step
static AttributeMetadata submeshMetaData;
static bool metadataInitialized = false;
if (!metadataInitialized)
{
submeshMetaData.minimum = "0";
submeshMetaData.step = "1";
metadataInitialized = true;
}
renderSubmeshIndex.SetMetadata(&submeshMetaData);
// Init our internal media player
mediaPlayer_ = new VlcMediaPlayer();
connect(mediaPlayer_, SIGNAL(FrameUpdate(QImage)), SLOT(OnFrameUpdate(QImage)), Qt::UniqueConnection);
// Connect signals from IComponent
connect(this, SIGNAL(ParentEntitySet()), SLOT(PrepareComponent()), Qt::UniqueConnection);
// Connect window size changes to update rendering as the ogre textures go black.
if (GetFramework()->Ui()->MainWindow())
connect(GetFramework()->Ui()->MainWindow(), SIGNAL(WindowResizeEvent(int,int)), SLOT(RenderWindowResized()), Qt::UniqueConnection);
resizeRenderTimer_ = new QTimer(this);
resizeRenderTimer_->setSingleShot(true);
connect(resizeRenderTimer_, SIGNAL(timeout()), mediaPlayer_, SLOT(ForceUpdateImage()), Qt::UniqueConnection);
// Prepare scene interactions
SceneInteract *sceneInteract = GetFramework()->GetModule<SceneInteract>();
if (sceneInteract)
{
connect(sceneInteract, SIGNAL(EntityClicked(Entity*, Qt::MouseButton, RaycastResult*)),
SLOT(EntityClicked(Entity*, Qt::MouseButton, RaycastResult*)));
}
// Prepare media downloader
mediaDownloader_ = new AssetRefListener();
connect(mediaDownloader_, SIGNAL(Loaded(AssetPtr)), SLOT(OnMediaLoaded(AssetPtr)));
connect(mediaDownloader_, SIGNAL(TransferFailed(IAssetTransfer*, QString)), SLOT(OnMediaFailed(IAssetTransfer*, QString)));
// Construct loading image
downloadingLogo_ = QImage(500, 300, QImage::Format_ARGB32);
downloadingLogo_.fill(Qt::black);
QPixmap bufferingIcon(":/images/buffering.png");
QPoint centerPos = downloadingLogo_.rect().center();
QRect target(centerPos.x() - (bufferingIcon.width()/2), centerPos.y() - (bufferingIcon.height()/2), bufferingIcon.width(), bufferingIcon.height());
QPainter p(&downloadingLogo_);
p.setPen(Qt::white);
p.drawPixmap(target, bufferingIcon, bufferingIcon.rect());
p.drawText(5, 12, "Downloading media...");
p.end();
}
void EC_MediaPlayer::PrepareComponent()
{
// Don't do anything if rendering is not enabled
if (!ViewEnabled() || GetFramework()->IsHeadless())
return;
// Some security checks
if (componentPrepared_)
{
LogWarning("EC_MediaPlayer: Preparations seem to be done already, you might not want to do this multiple times.");
}
if (!mediaPlayer_)
{
LogError("EC_MediaPlayer: Cannot start preparing, webview object is null. This should never happen!");
return;
}
// Get parent and connect to the component removed signal.
Entity *parent = ParentEntity();
if (parent)
connect(parent, SIGNAL(ComponentRemoved(IComponent*, AttributeChange::Type)), SLOT(ComponentRemoved(IComponent*, AttributeChange::Type)), Qt::UniqueConnection);
else
{
LogError("EC_MediaPlayer: Could not get parent entity pointer!");
return;
}
// Get EC_Mesh component
EC_Mesh *mesh = GetMeshComponent();
if (!mesh)
{
// Wait for EC_Mesh to be added.
connect(parent, SIGNAL(ComponentAdded(IComponent*, AttributeChange::Type)), SLOT(ComponentAdded(IComponent*, AttributeChange::Type)), Qt::UniqueConnection);
return;
}
else
{
// Inspect if this mesh is ready for rendering. EC_Mesh being present != being loaded into Ogre and ready for rendering.
if (!mesh->GetEntity())
{
connect(mesh, SIGNAL(MeshChanged()), SLOT(TargetMeshReady()), Qt::UniqueConnection);
return;
}
else
connect(mesh, SIGNAL(MaterialChanged(uint, const QString&)), SLOT(TargetMeshMaterialChanged(uint, const QString&)), Qt::UniqueConnection);
}
if (sceneCanvasName_.isEmpty())
sceneCanvasName_ = "VlcMediaPlayerCanvas-" + QUuid::createUuid().toString().replace("{", "").replace("}", "");
// Get or create local EC_WidgetCanvas component
ComponentPtr iComponent = parent->GetOrCreateComponent(EC_WidgetCanvas::TypeNameStatic(), sceneCanvasName_, AttributeChange::LocalOnly, false);
EC_WidgetCanvas *sceneCanvas = dynamic_cast<EC_WidgetCanvas*>(iComponent.get());
if (!sceneCanvas)
{
LogError("EC_MediaPlayer: Could not get or create EC_WidgetCanvas component!");
return;
}
sceneCanvas->SetTemporary(true);
sceneCanvas->SetSelfIllumination(getilluminating());
// All the needed components are present, mark prepared as true.
componentPrepared_ = true;
// We are now prepared, check enabled state and restore possible materials now
if (!getenabled())
sceneCanvas->RestoreOriginalMeshMaterials();
// Show downloading info icon or if not downloading,
// ask for a image update from the player
if (pendingMediaDownload_)
OnFrameUpdate(downloadingLogo_);
else
mediaPlayer_->ForceUpdateImage();
}
