Bugzilla

  NPEventMem.h \

/* -*- Mode: C++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */

/* vim: set sw=4 ts=8 et tw=80 ft=cpp : */

/* ***** BEGIN LICENSE BLOCK *****

 * Version: MPL 1.1/GPL 2.0/LGPL 2.1

 *

 * The contents of this file are subject to the Mozilla Public License Version

 * 1.1 (the "License"); you may not use this file except in compliance with

 * the License. You may obtain a copy of the License at

 * http://www.mozilla.org/MPL/

 *

 * Software distributed under the License is distributed on an "AS IS" basis,

 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

 * for the specific language governing rights and limitations under the

 * License.

 *

 * The Original Code is Mozilla Plugin App.

 *

 * The Initial Developer of the Original Code is

 *   The Mozilla Foundation.

 * Portions created by the Initial Developer are Copyright (C) 2010

 * the Initial Developer. All Rights Reserved.

 *

 * Contributor(s):

 *   Oleg Romashin <romaxa@gmail.com>

 *

 * Alternatively, the contents of this file may be used under the terms of

 * either the GNU General Public License Version 2 or later (the "GPL"), or

 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

 * in which case the provisions of the GPL or the LGPL are applicable instead

 * of those above. If you wish to allow use of your version of this file only

 * under the terms of either the GPL or the LGPL, and not to allow others to

 * use your version of this file under the terms of the MPL, indicate your

 * decision by deleting the provisions above and replace them with the notice

 * and other provisions required by the GPL or the LGPL. If you do not delete

 * the provisions above, a recipient may use your version of this file under

 * the terms of any one of the MPL, the GPL or the LGPL.

 *

 * ***** END LICENSE BLOCK ***** */

#ifndef mozilla_dom_plugins_NPEventMem_h

#define mozilla_dom_plugins_NPEventMem_h 1

#include "npapi.h"

namespace mozilla {

namespace plugins {

struct NPRemoteMemEvent {

    NPImageExpose event;

};

}

}

namespace IPC {

template <>

struct ParamTraits<mozilla::plugins::NPRemoteMemEvent>     // synonym for XEvent

{

    typedef mozilla::plugins::NPRemoteMemEvent paramType;

    static void Write(Message* aMsg, const paramType& aParam)

    {

        aMsg->WriteBytes(&aParam, sizeof(paramType));

    }

    static bool Read(const Message* aMsg, void** aIter, paramType* aResult)

    {

        const char* bytes = 0;

        if (!aMsg->ReadBytes(aIter, &bytes, sizeof(paramType))) {

            return false;

        }

        memcpy(aResult, bytes, sizeof(paramType));

        return true;

    }

    static void Log(const paramType& aParam, std::wstring* aLog)

    {

        // TODO

        aLog->append(L"(MemEvent)");

    }

};

} // namespace IPC

#endif // ifndef mozilla_dom_plugins_NPEventMem_h

using NPRemoteMemEvent;

  rpc NPP_GetValue_NPPVpluginWindowlessLocalBool()

    returns (bool value, NPError result);

  // special cases where we need to a shared memory buffer maemo

  rpc NPP_HandleEvent_ShmemDirect(NPRemoteMemEvent eventMem, Shmem buffer)

    returns (int16_t handled, Shmem rtnbuffer);

PluginInstanceChild::AnswerNPP_GetValue_NPPVpluginWindowlessLocalBool(

    bool* needs, NPError* rv)

{

    AssertPluginThread();

    PRBool winlessLocal = 0;

    if (!mPluginIface->getvalue) {

        *rv = NPERR_GENERIC_ERROR;

    }

    else {

        *rv = mPluginIface->getvalue(GetNPP(), NPPVpluginWindowlessLocalBool,

                                     &winlessLocal);

    }

    *needs = winlessLocal;

    return true;

}

bool

#ifdef MOZ_PLATFORM_MAEMO

bool

PluginInstanceChild::AnswerNPP_HandleEvent_ShmemDirect(const NPRemoteMemEvent& eventMem,

                                                       Shmem& mem,

                                                       int16_t* handled,

                                                       Shmem* rtnmem)

{

    PLUGIN_LOG_DEBUG_FUNCTION;

    AssertPluginThread();

    NPImageExpose imageExpose = eventMem.event;

    imageExpose.data = (char*)mem.get<char>();

    // Wrap NPImageExpose due to missing HandlePaintEvent(NPImageExpose*) NPAPI

    NPEvent xEvent;

    XGraphicsExposeEvent& exposeEvent = xEvent.xgraphicsexpose;

    exposeEvent.drawable = (Drawable)&imageExpose;

    exposeEvent.display = 0;

    exposeEvent.type = GraphicsExpose;

    exposeEvent.x = imageExpose.x;

    exposeEvent.y = imageExpose.y;

    exposeEvent.width = imageExpose.width;

    exposeEvent.height = imageExpose.height;

    exposeEvent.count = 0;

    // information not set:

    exposeEvent.serial = 0;

    exposeEvent.send_event = False;

    exposeEvent.major_code = 0;

    exposeEvent.minor_code = 0;

    if (!mPluginIface->event) {

        *handled = false;

    } else {

        *handled = mPluginIface->event(&mData, reinterpret_cast<void*>(&xEvent));

    }

    *rtnmem = mem;

    return true;

}

#else

bool

PluginInstanceChild::AnswerNPP_HandleEvent_ShmemDirect(const NPRemoteMemEvent& event,

                                                       Shmem& mem,

                                                       int16_t* handled,

                                                       Shmem* rtnmem)

{

    NS_RUNTIMEABORT("not reached.");

    *rtnmem = mem;

    return true;

}

#endif

    virtual bool

    AnswerNPP_GetValue_NPPVpluginWindowlessLocalBool(bool* needs, NPError* rv);

    virtual bool

    AnswerNPP_HandleEvent_ShmemDirect(const NPRemoteMemEvent& eventMem, Shmem& mem,

                                      int16_t* handled, Shmem* rtnmem);

#include "gfxContext.h"

#include "gfxImageSurface.h"

#if defined(XP_MACOSX) || (MOZ_PLATFORM_MAEMO == 6)

    , mShBpx(0)

    int bpx = 4;

#if defined(MOZ_X11) && defined(XP_UNIX) && !defined(XP_MACOSX)

    const NPSetWindowCallbackStruct* ws_info =

      static_cast<NPSetWindowCallbackStruct*>(aWindow->ws_info);

    window.visualID = ws_info->visual ? ws_info->visual->visualid : None;

    window.colormap = ws_info->colormap;

    bpx = ws_info->depth == 16 ? 2 : 4;

#endif

#if defined(XP_MACOSX) || defined(MOZ_PLATFORM_MAEMO)

    if (mShWidth * mShHeight != window.width * window.height || mShBpx != bpx) {

        if (!AllocShmem(window.width * window.height * bpx, &mShSurface)) {

        mShBpx = bpx;

    case NPPVpluginWindowlessLocalBool: {

        bool winlessLocal;

        NPError rv;

        if (!CallNPP_GetValue_NPPVpluginWindowlessLocalBool(&winlessLocal, &rv)) {

            return NPERR_GENERIC_ERROR;

        }

        if (NPERR_NO_ERROR != rv) {

            return rv;

        }

        (*(NPBool*)_retval) = winlessLocal;

        return NPERR_NO_ERROR;

    }

#if defined(MOZ_PLATFORM_MAEMO)

    if (npevent->type == GraphicsExpose && !npevent->xgraphicsexpose.display) {

        XGraphicsExposeEvent& exposeEvent = npevent->xgraphicsexpose;

        if (mShWidth == 0 && mShHeight == 0 && mShBpx == 0) {

            PLUGIN_LOG_DEBUG(("NPHandleEvent Expose on window of size 0."));

            return false;

        }

        if (!mShSurface.IsReadable()) {

            PLUGIN_LOG_DEBUG(("Shmem is not readable."));

            return false;

        }

        NPRemoteMemEvent npremotememevent;

        // Take NPImageExpose structure from hacked XEvent drawable

        NPImageExpose *imgExp = (NPImageExpose*)npevent->xgraphicsexpose.drawable;

        // Prepare remote NPImageExpose event for temporary shm buffer

        npremotememevent.event = *imgExp;

        // We should provide option for plugins to render directly into

        //   target context (imgExp->data)

        // But for now we will render into temporary buffer

        npremotememevent.event.stride = mShWidth * mShBpx;

        npremotememevent.event.dataSize.width = mShWidth;

        npremotememevent.event.dataSize.height = mShHeight;

        npremotememevent.event.translateX = 0;

        npremotememevent.event.translateY = 0;

        npremotememevent.event.scaleX = 1;

        npremotememevent.event.scaleY = 1;

        if (!CallNPP_HandleEvent_ShmemDirect(npremotememevent, mShSurface, &handled, &mShSurface)) {

            return false; // no good way to handle errors here...

        }

        if (!mShSurface.IsReadable()) {

            PLUGIN_LOG_DEBUG(("Shmem not returned. Either the plugin crashed or we have a bug."));

            return false;

        }

        // Init Image Format

        gfxASurface::gfxImageFormat imageFormat = gfxASurface::ImageFormatRGB24;

        if (imgExp->depth == 16) imageFormat = gfxASurface::ImageFormatRGB16;

        if (imgExp->depth == 32) imageFormat = gfxASurface::ImageFormatARGB32;

        // Get target gfx Context

        nsRefPtr<gfxImageSurface> surface =

           new gfxImageSurface((unsigned char*)imgExp->data,

                               gfxIntSize(imgExp->dataSize.width,

                                          imgExp->dataSize.height),

                               imgExp->stride,

                               imageFormat);

        nsRefPtr<gfxContext> ctx = new gfxContext(surface);

        // Get temp shm buffer image surface context

        nsRefPtr<gfxImageSurface> buffer =

           new gfxImageSurface((unsigned char*)mShSurface.get<unsigned char>(),

                               gfxIntSize(mShWidth, mShHeight),

                               mShWidth * mShBpx,

                               imageFormat);

        // Paint shm buffer to target surface

        ctx->Translate(gfxPoint(imgExp->translateX, imgExp->translateY));

        ctx->Scale(imgExp->scaleX, imgExp->scaleY);

        ctx->SetSource(buffer);

        ctx->Rectangle(gfxRect(imgExp->x, imgExp->y, imgExp->width, imgExp->height));

        ctx->Clip();

        ctx->Paint();

        return handled;

    }

#endif

#ifdef MOZ_X11

#if defined(OS_MACOSX) || defined(MOZ_PLATFORM_MAEMO)

    int mShBpx;

#endif // definied(OS_MACOSX) || defined(MOZ_PLATFORM_MAEMO)

        VARSTR(NPPVpluginWindowlessLocalBool);

#  include "mozilla/plugins/NPEventMem.h"

#ifdef MOZ_PLATFORM_MAEMO

  nsresult NativeDrawMemBuff(gfxContext *aContext,

                             NPWindow* mWindow,

                             const nsIntSize& mPluginSize,

                             const nsIntRect& mDirtyRect);

#endif

#ifdef MOZ_PLATFORM_MAEMO

  PRBool simpleImageRender = PR_FALSE;

  mInstance->GetValueFromPlugin(NPPVpluginWindowlessLocalBool,

                                &simpleImageRender);

  if (simpleImageRender &&

      aContext->OriginalSurface()->GetType() == gfxASurface::SurfaceTypeImage) {

    NativeDrawMemBuff(aContext, window, pluginSize, pluginDirtyRect);

    return;

  }

#endif

#ifdef MOZ_PLATFORM_MAEMO

// NativeDrawMemBuff

nsresult

nsPluginInstanceOwner::NativeDrawMemBuff(gfxContext *aContext,

                                         NPWindow* mWindow,

                                         const nsIntSize& mPluginSize,

                                         const nsIntRect& mDirtyRect)

{

  PRBool doupdatewindow = PR_FALSE;

  if (mWindow->x || mWindow->y) {

    mWindow->x = 0;

    mWindow->y = 0;

    doupdatewindow = PR_TRUE;

  }

  if (nsIntSize(mWindow->width, mWindow->height) != mPluginSize) {

    mWindow->width = mPluginSize.width;

    mWindow->height = mPluginSize.height;

    doupdatewindow = PR_TRUE;

  }

  // The clip rect is relative to drawable top-left.

  nsIntRect clipRect;

  clipRect.x = 0;

  clipRect.y = 0;

  clipRect.width  = mWindow->width;

  clipRect.height = mWindow->height;

  NPRect newClipRect;

  newClipRect.left = clipRect.x;

  newClipRect.top = clipRect.y;

  newClipRect.right = clipRect.XMost();

  newClipRect.bottom = clipRect.YMost();

  if (mWindow->clipRect.left    != newClipRect.left   ||

      mWindow->clipRect.top     != newClipRect.top    ||

      mWindow->clipRect.right   != newClipRect.right  ||

      mWindow->clipRect.bottom  != newClipRect.bottom) {

    mWindow->clipRect = newClipRect;

    doupdatewindow = PR_TRUE;

  }

  nsRefPtr<gfxImageSurface> surface = static_cast<gfxImageSurface*>(aContext->OriginalSurface());

  NS_ENSURE_TRUE(surface, NS_ERROR_OUT_OF_MEMORY);

  PRUint32 surfaceDepth = 24;

  if (surface->Format() == gfxASurface::ImageFormatRGB16)

    surfaceDepth = 16;

  if (surface->Format() == gfxASurface::ImageFormatARGB32)

    surfaceDepth = 32;

  NPSetWindowCallbackStruct* ws_info =

    static_cast<NPSetWindowCallbackStruct*>(mWindow->ws_info);

  ws_info->visual = 0;

  ws_info->colormap = 0;

  if (ws_info->depth != surfaceDepth) {

    ws_info->depth = surfaceDepth;

    doupdatewindow = PR_TRUE;

  }

  if (doupdatewindow)

    mInstance->SetWindow(mWindow);

  // Until we don't have agreement about how to pass NPImageExpose structure to plugin

  // it will be packed into XEvent.xgraphicsexpose.drawable member

  // Probably we have to use something like HandleEvent2 API. see bug 477456 in BMO

  // Translate the dirty rect to drawable coordinates.

  nsIntRect dirtyRect = mDirtyRect;

  // Intersect the dirty rect with the clip rect to ensure that it lies within

  // the drawable.

  if (!dirtyRect.IntersectRect(dirtyRect, clipRect))

    return NS_OK;

  NPEvent pluginEvent;

  NPImageExpose imageExpose;

  XGraphicsExposeEvent& exposeEvent = pluginEvent.xgraphicsexpose;

  // set the drawing info

  exposeEvent.type = GraphicsExpose;

  exposeEvent.display = 0;

  // Store imageExpose structure pointer as drawable member

  exposeEvent.drawable = (Drawable)&imageExpose;

  exposeEvent.x = mDirtyRect.x;

  exposeEvent.y = mDirtyRect.y;

  exposeEvent.width = mDirtyRect.width;

  exposeEvent.height = mDirtyRect.height;

  exposeEvent.count = 0;

  // information not set:

  exposeEvent.serial = 0;

  exposeEvent.send_event = False;

  exposeEvent.major_code = 0;

  exposeEvent.minor_code = 0;

  // Calculate src buffer pointer according to translation

  // and set it as drawable member

  gfxMatrix matr = aContext->CurrentMatrix();

  gfxPoint pt = matr.GetTranslation();

  imageExpose.depth = surfaceDepth;

  imageExpose.x = mDirtyRect.x;

  imageExpose.y = mDirtyRect.y;

  imageExpose.width = mDirtyRect.width;

  imageExpose.height = mDirtyRect.height;

  // Setup temporary context scaled size

  imageExpose.stride = surface->Stride();

  imageExpose.data = (char *)surface->Data();

  imageExpose.dataSize.width = surface->Width();

  imageExpose.dataSize.height = surface->Height();

  imageExpose.translateX = pt.x;

  imageExpose.translateY = pt.y;

  imageExpose.scaleX = matr.xx;

  imageExpose.scaleY = matr.yy;

  PRBool eventHandled = PR_FALSE;

  // Get Image surface from original context

  // Draw plugin content to temp surface

  mInstance->HandleEvent(&pluginEvent, &eventHandled);

  return NS_OK;

}

#endif

#if defined(MOZ_PLATFORM_MAEMO)