/////////////////////////////////////////////////////////////////////////////
// Name:        flash.cpp
// Purpose:     Sample showing integration of Flash ActiveX control
// Author:      Vadim Zeitlin
// Created:     2009-01-13
// Copyright:   (c) 2009 Vadim Zeitlin
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

/*
    Documentation for embedding Flash into anything other than a web browser is
    not easy to find, here is the tech note which provided most of the
    information used here: http://www.adobe.com/go/tn_12059
 */

// ============================================================================
// declarations
// ============================================================================

// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------

#include "wx/wxprec.h"

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef __WXMSW__
    #error "ActiveX controls are MSW-only"
#endif

#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif

#include "wx/cmdline.h"
#include "wx/filename.h"

#ifndef wxHAS_IMAGES_IN_RESOURCES
    #include "../sample.xpm"
#endif

#include "wx/msw/ole/activex.h"

// we currently use VC-specific extensions in this sample, it could be
// rewritten to avoid them if there is real interest in doing it but compiler
// COM support in MSVC makes the code much simpler to understand
#ifndef __VISUALC__
    #error "This sample requires Microsoft Visual C++ compiler COM extensions"
#endif

// import Flash ActiveX control by using its (standard) type library UUID
//
// no_auto_exclude is needed to import IServiceProvider interface defined in
// this type library even though its name conflicts with a standard Windows
// interface with the same name
#import "libid:D27CDB6B-AE6D-11CF-96B8-444553540000" no_auto_exclude

using namespace ShockwaveFlashObjects;

const CLSID CLSID_ShockwaveFlash = __uuidof(ShockwaveFlash);
const IID IID_IShockwaveFlash = __uuidof(IShockwaveFlash);

inline wxString bstr2wx(const _bstr_t& bstr)
{
    return wxString(static_cast<const wchar_t *>(bstr));
}

inline _bstr_t wx2bstr(const wxString& str)
{
    return _bstr_t(str.wc_str());
}

// ----------------------------------------------------------------------------
// constants
// ----------------------------------------------------------------------------

// taken from type library
namespace
{

const int FLASH_DISPID_ONREADYSTATECHANGE = -609; // DISPID_ONREADYSTATECHANGE
const int FLASH_DISPID_ONPROGRESS = 0x7a6;
const int FLASH_DISPID_FSCOMMAND = 0x96;
const int FLASH_DISPID_FLASHCALL = 0xc5;

enum FlashState
{
    FlashState_Unknown = -1,
    FlashState_Loading,
    FlashState_Uninitialized,
    FlashState_Loaded,
    FlashState_Interactive,
    FlashState_Complete,
    FlashState_Max
};

} // anonymous namespace

// ----------------------------------------------------------------------------
// private classes
// ----------------------------------------------------------------------------

// Define a new application type, each program should derive a class from wxApp
class FlashApp : public wxApp
{
public:
    FlashApp() { }

    virtual bool OnInit();

    virtual void OnInitCmdLine(wxCmdLineParser& parser);
    virtual bool OnCmdLineParsed(wxCmdLineParser& parser);

    virtual bool OnExceptionInMainLoop();

private:
    wxString m_swf;

    wxDECLARE_NO_COPY_CLASS(FlashApp);
};

// Define a new frame type: this is going to be our main frame
class FlashFrame : public wxFrame
{
public:
    // ctor takes ownership of the pointer which must be non-NULL and opens the
    // given SWF file if it's non-empty
    FlashFrame(IShockwaveFlash *flash, const wxString& swf);
    virtual ~FlashFrame();

    void SetMovie(const wxString& movie);

    void Play();
    void Stop();

private:
    enum
    {
        Flash_Play = 100,
        Flash_Get,
        Flash_Set,
        Flash_Call,
        Flash_CallWithArg
    };

    void OnOpen(wxCommandEvent& event);
    void OnQuit(wxCommandEvent& event);
    void OnAbout(wxCommandEvent& event);

    void OnPlay(wxCommandEvent&) { Play(); }
    void OnStop(wxCommandEvent&) { Stop(); }
    void OnBack(wxCommandEvent& event);
    void OnForward(wxCommandEvent& event);
    void OnInfo(wxCommandEvent& event);
    void OnVarGet(wxCommandEvent& event);
    void OnVarSet(wxCommandEvent& event);
    void OnCall(wxCommandEvent& event);
    void OnCallWithArg(wxCommandEvent& event);

    void OnActiveXEvent(wxActiveXEvent& event);

    // give an error message if hr is not S_OK
    void CheckFlashCall(HRESULT hr, const char *func);

    // return the name of the Flash control state
    wxString GetFlashStateString(int state);

    // call CallFunction() with a single argument of the type specified by
    // argtype or without any arguments if it is empty
    void CallFlashFunc(const wxString& argtype,
                       const wxString& func,
                       const wxString& arg = wxString());


    const IShockwaveFlashPtr m_flash;
    wxLog *m_oldLog;
    wxString m_swf;
    FlashState m_state;

    wxTextCtrl *m_varname,
               *m_varvalue,
               *m_funcname,
               *m_funcarg;

    wxDECLARE_EVENT_TABLE();
    wxDECLARE_NO_COPY_CLASS(FlashFrame);
};

// ----------------------------------------------------------------------------
// event tables and other macros for wxWidgets
// ----------------------------------------------------------------------------

wxBEGIN_EVENT_TABLE(FlashFrame, wxFrame)
    EVT_MENU(wxID_OPEN,  FlashFrame::OnOpen)
    EVT_MENU(wxID_EXIT,  FlashFrame::OnQuit)
    EVT_MENU(wxID_ABOUT, FlashFrame::OnAbout)

    EVT_BUTTON(Flash_Play, FlashFrame::OnPlay)
    EVT_BUTTON(wxID_STOP,  FlashFrame::OnStop)
    EVT_BUTTON(wxID_BACKWARD, FlashFrame::OnBack)
    EVT_BUTTON(wxID_FORWARD,  FlashFrame::OnForward)

    EVT_BUTTON(wxID_INFO, FlashFrame::OnInfo)
    EVT_BUTTON(Flash_Get, FlashFrame::OnVarGet)
    EVT_BUTTON(Flash_Set, FlashFrame::OnVarSet)
    EVT_BUTTON(Flash_Call, FlashFrame::OnCall)
    EVT_BUTTON(Flash_CallWithArg, FlashFrame::OnCallWithArg)

    EVT_ACTIVEX(wxID_ANY, FlashFrame::OnActiveXEvent)
wxEND_EVENT_TABLE()

IMPLEMENT_APP(FlashApp)

// ============================================================================
// implementation
// ============================================================================

// ----------------------------------------------------------------------------
// the application class
// ----------------------------------------------------------------------------

void FlashApp::OnInitCmdLine(wxCmdLineParser& parser)
{
    wxApp::OnInitCmdLine(parser);

    parser.AddParam("SWF file to play",
                    wxCMD_LINE_VAL_STRING, wxCMD_LINE_PARAM_OPTIONAL);
}

bool FlashApp::OnCmdLineParsed(wxCmdLineParser& parser)
{
    if ( parser.GetParamCount() )
        m_swf = parser.GetParam(0);

    return wxApp::OnCmdLineParsed(parser);
}

bool FlashApp::OnInit()
{
    if ( !wxApp::OnInit() )
        return false;

    IShockwaveFlash *flash = NULL;
    HRESULT hr = ::CoCreateInstance
                   (
                    CLSID_ShockwaveFlash,
                    NULL,
                    CLSCTX_INPROC_SERVER,
                    IID_IShockwaveFlash,
                    (void **)&flash
                   );
    if ( FAILED(hr) )
    {
        wxLogSysError(hr, "Failed to create Flash ActiveX control");
        return false;
    }

    new FlashFrame(flash, m_swf);

    return true;
}

bool FlashApp::OnExceptionInMainLoop()
{
    try
    {
        throw;
    }
    catch ( _com_error& ce )
    {
        wxLogMessage("COM exception: %s", ce.ErrorMessage());

        return true;
    }
    catch ( ... )
    {
        throw;
    }
}

// ----------------------------------------------------------------------------
// main frame creation
// ----------------------------------------------------------------------------

// frame constructor
FlashFrame::FlashFrame(IShockwaveFlash *flash, const wxString& swf)
    : wxFrame(NULL, wxID_ANY, "wxWidgets Flash sample"),
      m_flash(flash, false /* take ownership */),
      m_swf(swf),
      m_state(FlashState_Unknown)
{
    // set the frame icon
    SetIcon(wxICON(sample));

    // create the new log target before doing anything with the Flash that
    // could result in log messages
    wxTextCtrl * const log = new wxTextCtrl(this, wxID_ANY, "",
                                            wxDefaultPosition, wxSize(-1, 100),
                                            wxTE_MULTILINE);
    m_oldLog = wxLog::SetActiveTarget(new wxLogTextCtrl(log));

#if wxUSE_MENUS
    // create a menu bar
    wxMenu *fileMenu = new wxMenu;
    fileMenu->Append(wxID_OPEN);
    fileMenu->AppendSeparator();
    fileMenu->Append(wxID_EXIT);

    wxMenu *helpMenu = new wxMenu;
    helpMenu->Append(wxID_ABOUT);

    wxMenuBar *menuBar = new wxMenuBar();
    menuBar->Append(fileMenu, "&File");
    menuBar->Append(helpMenu, "&Help");
    SetMenuBar(menuBar);
#endif // wxUSE_MENUS

#if wxUSE_STATUSBAR
    CreateStatusBar(2);
    SetStatusText("Welcome to wxWidgets Flash embedding sample");
    SetStatusText("No loaded file", 1);
#endif // wxUSE_STATUSBAR

    wxPanel * const panel = new wxPanel(this);
    wxSizer * const sizerPanel = new wxBoxSizer(wxVERTICAL);
    wxWindow * const activeXParent = new wxWindow(panel, wxID_ANY,
                                                  wxDefaultPosition,
                                                  wxSize(300, 200));
    new wxActiveXContainer(activeXParent, IID_IShockwaveFlash, flash);
    if ( !swf.empty() )
        SetMovie(swf);

    sizerPanel->Add(activeXParent,
                    wxSizerFlags(1).Expand().Border());

    const wxSizerFlags flagsHorz(wxSizerFlags().Centre().HorzBorder());

    wxSizer * const sizerBtns = new wxBoxSizer(wxHORIZONTAL);
    sizerBtns->Add(new wxButton(panel, wxID_BACKWARD), flagsHorz);
    sizerBtns->Add(new wxButton(panel, Flash_Play, "&Play"), flagsHorz);
    sizerBtns->Add(new wxButton(panel, wxID_STOP), flagsHorz);
    sizerBtns->Add(new wxButton(panel, wxID_FORWARD), flagsHorz);
    sizerBtns->AddSpacer(20);
    sizerBtns->Add(new wxButton(panel, wxID_INFO), flagsHorz);
    sizerPanel->Add(sizerBtns, wxSizerFlags().Center().Border());

    wxSizer * const sizerVar = new wxBoxSizer(wxHORIZONTAL);
    sizerVar->Add(new wxStaticText(panel, wxID_ANY, "Variable &name:"),
                  flagsHorz);
    m_varname = new wxTextCtrl(panel, wxID_ANY);
    sizerVar->Add(m_varname, flagsHorz);
    sizerVar->Add(new wxStaticText(panel, wxID_ANY, "&value:"),
                  flagsHorz);
    m_varvalue = new wxTextCtrl(panel, wxID_ANY);
    sizerVar->Add(m_varvalue, flagsHorz);
    sizerVar->AddSpacer(10);
    sizerVar->Add(new wxButton(panel, Flash_Get, "&Get"), flagsHorz);
    sizerVar->Add(new wxButton(panel, Flash_Set, "&Set"), flagsHorz);
    sizerPanel->Add(sizerVar, wxSizerFlags().Center().Border());

    wxSizer * const sizerCall = new wxBoxSizer(wxHORIZONTAL);
    sizerCall->Add(new wxStaticText(panel, wxID_ANY, "&Function name:"),
                   flagsHorz);
    m_funcname = new wxTextCtrl(panel, wxID_ANY);
    sizerCall->Add(m_funcname, flagsHorz);
    sizerCall->Add(new wxButton(panel, Flash_Call, "&Call"), flagsHorz);
    sizerCall->Add(new wxStaticText(panel, wxID_ANY, "&argument:"),
                   flagsHorz);
    m_funcarg = new wxTextCtrl(panel, wxID_ANY);
    sizerCall->Add(m_funcarg, flagsHorz);
    sizerCall->Add(new wxButton(panel, Flash_CallWithArg, "Call &with arg"),
                   flagsHorz);
    sizerPanel->Add(sizerCall, wxSizerFlags().Center().Border());

    panel->SetSizer(sizerPanel);

    wxSizer * const sizerFrame = new wxBoxSizer(wxVERTICAL);
    sizerFrame->Add(panel, wxSizerFlags(2).Expand());
    sizerFrame->Add(log, wxSizerFlags(1).Expand());
    SetSizerAndFit(sizerFrame);

    Show();

    m_flash->PutAllowScriptAccess(L"always");
    wxLogMessage("Script access changed to \"%s\"",
                 bstr2wx(m_flash->GetAllowScriptAccess()));
}

FlashFrame::~FlashFrame()
{
    delete wxLog::SetActiveTarget(m_oldLog);
}

// ----------------------------------------------------------------------------
// Flash API wrappers
// ----------------------------------------------------------------------------

void FlashFrame::CheckFlashCall(HRESULT hr, const char *func)
{
    if ( FAILED(hr) )
    {
        wxLogSysError(hr, "Call to IShockwaveFlash::%s() failed", func);
    }
}

void FlashFrame::CallFlashFunc(const wxString& argtype,
                               const wxString& func,
                               const wxString& arg)
{
    wxString args;
    if ( !argtype.empty() )
    {
        args = wxString::Format("<%s>%s</%s>", argtype, arg, argtype);
    }

    // take care with XML formatting: there should be no spaces in it or the
    // call would fail!
    wxString request = wxString::Format
                       (
                            "<invoke name=\"%s\" returntype=\"xml\">"
                                "<arguments>"
                                "%s"
                                "</arguments>"
                            "</invoke>",
                            func,
                            args
                       );

    wxLogMessage("%s(%s) returned \"%s\"",
                 func, args,
                 bstr2wx(m_flash->CallFunction(wx2bstr(request))));
}

wxString FlashFrame::GetFlashStateString(int state)
{
    static const char *knownStates[] =
    {
        "Loading", "Uninitialized", "Loaded", "Interactive", "Complete",
    };

    if ( state >= 0 && state < WXSIZEOF(knownStates) )
        return knownStates[state];

    return wxString::Format("unknown state (%d)", state);
}

void FlashFrame::SetMovie(const wxString& movie)
{
    // Flash doesn't like relative file names
    wxFileName fn(movie);
    fn.MakeAbsolute();
    const wxString swf = fn.GetFullPath();
    if ( swf == m_swf )
        m_flash->PutMovie(L"");
    else
        m_swf = swf;

    m_flash->PutMovie(m_swf.wc_str());

    SetStatusText("Loaded \"" + m_swf + '"', 1);
}

void FlashFrame::Play()
{
    CheckFlashCall(m_flash->Play(), "Play");
}

void FlashFrame::Stop()
{
    CheckFlashCall(m_flash->Stop(), "Stop");
}

// ----------------------------------------------------------------------------
// event handlers
// ----------------------------------------------------------------------------

void FlashFrame::OnOpen(wxCommandEvent& WXUNUSED(event))
{
    wxString swf = wxLoadFileSelector("Flash movie", ".swf", m_swf, this);
    if ( swf.empty() )
        return;

    SetMovie(swf);
}

void FlashFrame::OnQuit(wxCommandEvent& WXUNUSED(event))
{
    // true is to force the frame to close
    Close(true);
}

void FlashFrame::OnAbout(wxCommandEvent& WXUNUSED(event))
{
    wxMessageBox("Flash ActiveX control embedding sample\n"
                 "\n"
                 "(c) 2009 Vadim Zeitlin",
                 "About " + GetTitle(),
                 wxOK | wxICON_INFORMATION,
                 this);
}

void FlashFrame::OnActiveXEvent(wxActiveXEvent& event)
{
    switch ( event.GetDispatchId() )
    {
        case FLASH_DISPID_ONREADYSTATECHANGE:
            {
                const int state = event[0].GetInteger();
                if ( state != m_state )
                {
                    wxLogMessage("State changed to %s",
                                 GetFlashStateString(state));

                    if ( state >= 0 && state < FlashState_Max )
                        m_state = static_cast<FlashState>(state);
                    else
                        m_state = FlashState_Unknown;
                }
            }
            break;

        case FLASH_DISPID_ONPROGRESS:
            wxLogMessage("Progress: %d%%", event[0].GetInteger());
            break;

        case FLASH_DISPID_FSCOMMAND:
            wxLogMessage("Flash command %s(%s)",
                         event[0].GetString(), event[1].GetString());
            break;

        case FLASH_DISPID_FLASHCALL:
            wxLogMessage("Flash request \"%s\"", event[0].GetString());
            break;

        default:
            wxLogMessage("Unknown event %ld", event.GetDispatchId());
    }

    event.Skip();
}

void FlashFrame::OnBack(wxCommandEvent& WXUNUSED(event))
{
    CheckFlashCall(m_flash->Back(), "Back");
}

void FlashFrame::OnForward(wxCommandEvent& WXUNUSED(event))
{
    CheckFlashCall(m_flash->Forward(), "Forward");
}

void FlashFrame::OnInfo(wxCommandEvent& WXUNUSED(event))
{
    const int state = m_flash->GetReadyState();
    wxString msg = "State: " + GetFlashStateString(state);

    if ( state == FlashState_Complete )
    {
        msg += wxString::Format(", frame: %ld/%ld",
                                m_flash->GetFrameNum() + 1,
                                m_flash->GetTotalFrames());
    }

    if ( m_flash->IsPlaying() )
        msg += ", playing";

    wxLogMessage("%s", msg);
}

void FlashFrame::OnVarGet(wxCommandEvent& WXUNUSED(event))
{
    m_varvalue->SetValue(bstr2wx(
        m_flash->GetVariable(wx2bstr(m_varname->GetValue()))));
}

void FlashFrame::OnVarSet(wxCommandEvent& WXUNUSED(event))
{
    m_flash->SetVariable(wx2bstr(m_varname->GetValue()),
                         wx2bstr(m_varvalue->GetValue()));
}

void FlashFrame::OnCall(wxCommandEvent& WXUNUSED(event))
{
    CallFlashFunc("", m_funcname->GetValue());
}

void FlashFrame::OnCallWithArg(wxCommandEvent& WXUNUSED(event))
{
    CallFlashFunc("string", m_funcname->GetValue(), m_funcarg->GetValue());
}