IFlashControl.h

Go to the documentation of this file.

/*
        This file is part of Hikari, a library that allows developers
        to use Flash in their Ogre3D applications.
 
        Copyright (C) 2008 Adam J. Simmons
 
        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
*/
/****************************************************************************************************
   ___ ___ .__ __                 .__ 
 /   |   \|__|  | _______ _______|__|
/    ~    \  |  |/ /\__  \\_  __ \  |
\    Y    /  |    <  / __ \|  | \/  |
 \___|_  /|__|__|_ \‍(____  /__|  |__|  v0.4
       \/         \/     \/          
 
 
* Zed Games PC Development Team - Jaime Crespillo Vilchez (jcrespillo@zed.com)
* Build: 0.1 - Date: 13/10/2008
* Undocked version of Hikari Lib
* Brief: new interface class IFlashControl to undock the Hikari core from control object
******************************************************************************************************/
 
#ifndef __IFlashControl_H__
#define __IFlashControl_H__
 
#include <windows.h>
#include "Position.h"
#include "Delegate.h"
namespace ShockwaveFlashObjects { struct IShockwaveFlash; }
struct IOleObject;
struct IOleInPlaceObjectWindowless;
 
//pre-definition of the Client-Side implementation class based on Abstract IFlashControl used by Hikari and
//needed for FlashDelegate
class FlashControl;
 
namespace Hikari {
  class IFlashControl;
        typedef Impl::fastdelegate::FastDelegate2<IFlashControl*, const Arguments&, FlashValue> FlashDelegate;
        namespace Impl {
                class FlashSite;
                class FlashHandler;
                class RenderBuffer;
        }
 
        enum RenderQuality
        {RQ_LOW, RQ_MEDIUM, RQ_HIGH, RQ_BEST, RQ_AUTOLOW, RQ_AUTOHIGH};
 
        enum ScaleMode
        {SM_SHOWALL, SM_NOBORDER, SM_EXACTFIT};
 
class _HikariExport IFlashControl
{
        friend class Impl::FlashSite;
        friend class Impl::FlashHandler;
        friend class Impl::RenderBuffer;
        friend class HikariManager;
        friend struct Position;
        friend class HikariManager;
public:
 
        Hikari::Impl::FlashSite* site;
        Hikari::Impl::FlashHandler* handler;
        Hikari::Impl::RenderBuffer* renderBuffer;
 
        ShockwaveFlashObjects::IShockwaveFlash* flashInterface;
        IOleObject*     oleObject;
        IOleInPlaceObjectWindowless* windowlessObject;
 
        HDC mainContext, altContext;
        HBITMAP mainBitmap, altBitmap;
  HGDIOBJ hOldMainBmp, hOldAltBmp;
        BYTE *mainBuffer, *altBuffer;
        
        
        std::string name;
        int zOrder;
        int initialZOrder;
        int currentZOrder;
        int comCount;
        int width;
        int height;
        int lastBufferSize;
        RECT dirtyBounds;
        bool isClean, isTotallyDirty;
        bool okayToDelete;
        bool compensateNPOT;
        bool isTransparent;
        bool isDraggable;
        bool isInputListener;
        bool isVisible;
        bool isBlocked;
        bool Foreground;
        bool topOnFocus;
        bool keyBoardEnable;
        bool mouseEnable;
        bool isOverlay;
        int scolFlags;
 
        IFlashControl():site(0), handler(0), renderBuffer(0), flashInterface(0), oleObject(0), windowlessObject(0), mainContext(0), altContext(0), mainBitmap(0), altBitmap(0), mainBuffer(0), altBuffer(0) {}
        virtual ~IFlashControl(){}
        virtual void setZOrder(unsigned short zorder) = 0;
        virtual unsigned short getZOrder() = 0;
        //virtual unsigned short getPanelZOrder() = 0;// maybe we will need for keeping the access to the HIKARI object´s model
        virtual int getRelativeX(int absX) = 0;
        virtual int getRelativeY(int absY) = 0;
 
        virtual bool isPointOverMe(int screenX, int screenY) = 0;
        virtual void invalidateTotally() = 0;
        virtual void handleKeyEvent(UINT msg, WPARAM wParam, LPARAM lParam) = 0;
        virtual void handleFlashCall(const std::wstring& xmlString) = 0;
        virtual void update() = 0;
        virtual void load(const std::string& movieFilename, HikariManager* hikariMgr,int type) = 0;
        virtual void play() = 0;
        virtual void stop() = 0;
        virtual void rewind() = 0;
        virtual void gotoFrame(long frameNum) = 0;
        virtual void setLoop(bool shouldLoop) = 0;
        virtual void setTransparent(bool isTransparent, bool useAlphaHack = false) = 0;
        virtual void setQuality(short renderQuality) = 0;
        virtual void setScaleMode(short scaleMode) = 0;
        virtual void setDraggable(bool isDraggable) = 0;
        virtual void setIgnoreTransparentPixels(bool shouldIgnore, float threshold = 0.04) = 0;
        virtual const std::string & getName() const = 0;
        virtual const std::string & getMaterialName() const = 0;
        virtual void bind(const std::wstring& funcName, const FlashDelegate& callback) = 0;
        virtual void unbind(const std::wstring& funcName) = 0;
        virtual FlashValue callFunction(const std::wstring& funcName, const Arguments& args = Args()) = 0;
        virtual void hide() = 0;
        virtual void show() = 0;
        virtual bool getVisibility() const = 0;
        virtual void setOpacity(float opacity) = 0;
        virtual void focus() = 0;
        virtual void move(int deltaX, int deltaY) = 0;
        virtual void getExtents(unsigned short &width, unsigned short &height) const = 0;
        virtual void getUVScale(float &uScale, float &vScale) const = 0;
        virtual void injectMouseMove(int xPos, int yPos, int btn) = 0;
        virtual void injectMouseDown(int xPos, int yPos, int index) = 0;
        virtual void injectMouseUp(int xPos, int yPos, int index) = 0;
        virtual void injectMouseWheel(int relScroll, int xPos, int yPos) = 0;
};
 
 
}
 
#endif