CWE-ou-minkata/Sources/Plasma/FeatureLib/pfPython/pyJournalBookGlue.cpp

/*==LICENSE==*

CyanWorlds.com Engine - MMOG client, server and tools
Copyright (C) 2011  Cyan Worlds, Inc.

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

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program.  If not, see <http://www.gnu.org/licenses/>.

You can contact Cyan Worlds, Inc. by email legal@cyan.com
 or by snail mail at:
      Cyan Worlds, Inc.
      14617 N Newport Hwy
      Mead, WA   99021

*==LICENSE==*/
#include "pyJournalBook.h"
#include "pyEnum.h"
#include "pyKey.h"
#include "pyImage.h"

#include "pfJournalBook/pfJournalBook.h"
#include <Python.h>

// glue functions
PYTHON_CLASS_DEFINITION(ptBook, pyJournalBook);

PYTHON_DEFAULT_NEW_DEFINITION(ptBook, pyJournalBook)
PYTHON_DEFAULT_DEALLOC_DEFINITION(ptBook)

PYTHON_INIT_DEFINITION(ptBook, args, keywords)
{
    char* kwlist[] = {"esHTMLSource", "coverImage", "callbackKey", "guiName", NULL};
    PyObject* sourceObj = NULL;
    PyObject* coverObj = NULL;
    PyObject* callbackObj = NULL;
    char* guiName = NULL;
    if (!PyArg_ParseTupleAndKeywords(args, keywords, "O|OOs", kwlist, &sourceObj, &coverObj, &callbackObj, &guiName))
    {
        PyErr_SetString(PyExc_TypeError, "__init__ expects a string or unicode string, and optionally a ptImage, ptKey, and string");
        PYTHON_RETURN_INIT_ERROR;
    }

    // convert all the optional arguments
    plKey coverKey = nil;
    if (coverObj)
    {
        if (pyKey::Check(coverObj))
        {
            // this is really the callback key
            if (callbackObj) // callbackObj was already defined, can't have two keys
            {
                PyErr_SetString(PyExc_TypeError, "__init__ expects a string or unicode string, and optionally a ptImage, ptKey, and string");
                PYTHON_RETURN_INIT_ERROR;
            }
            callbackObj = coverObj;
            coverObj = nil;
        }
        else if (!pyImage::Check(coverObj))
        {
            PyErr_SetString(PyExc_TypeError, "__init__ expects a string or unicode string, and optionally a ptImage, ptKey, and string");
            PYTHON_RETURN_INIT_ERROR;
        }
        else
            coverKey = pyImage::ConvertFrom(coverObj)->GetKey();
    }

    plKey callbackKey = nil;
    if (callbackObj)
    {
        if (!pyKey::Check(callbackObj))
        {
            PyErr_SetString(PyExc_TypeError, "__init__ expects a string or unicode string, and optionally a ptImage, ptKey, and string");
            PYTHON_RETURN_INIT_ERROR;
        }
        callbackKey = pyKey::ConvertFrom(callbackObj)->getKey();
    }

    std::string guiNameStr = "";
    if (guiName)
        guiNameStr = guiName;

    // convert the sourcecode object
    if (PyUnicode_Check(sourceObj))
    {
        int len = PyUnicode_GetSize(sourceObj);
        wchar_t* temp = TRACKED_NEW wchar_t[len + 1];
        PyUnicode_AsWideChar((PyUnicodeObject*)sourceObj, temp, len);
        temp[len] = L'\0';

        std::wstring source = temp;
        delete [] temp;

        self->fThis->MakeBook(source, coverKey, callbackKey, guiNameStr);
        PYTHON_RETURN_INIT_OK;
    }
    else if (PyString_Check(sourceObj))
    {
        std::string source = PyString_AsString(sourceObj);

        self->fThis->MakeBook(source, coverKey, callbackKey, guiNameStr);
        PYTHON_RETURN_INIT_OK;
    }

    // source wasn't a string or unicode string
    PyErr_SetString(PyExc_TypeError, "__init__ expects a string or unicode string, and optionally a ptImage, ptKey, and string");
    PYTHON_RETURN_INIT_ERROR;
}

PYTHON_METHOD_DEFINITION(ptBook, show, args)
{
    char startOpened;
    if (!PyArg_ParseTuple(args, "b", &startOpened))
    {
        PyErr_SetString(PyExc_TypeError, "show expects a boolean");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->Show(startOpened != 0);
    PYTHON_RETURN_NONE;
}

PYTHON_BASIC_METHOD_DEFINITION(ptBook, hide, Hide)

PYTHON_METHOD_DEFINITION(ptBook, open, args)
{
    unsigned long startingPage;
    if (!PyArg_ParseTuple(args, "l", &startingPage))
    {
        PyErr_SetString(PyExc_TypeError, "open expects an unsigned long");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->Open(startingPage);
    PYTHON_RETURN_NONE;
}

PYTHON_BASIC_METHOD_DEFINITION(ptBook, close, Close)
PYTHON_BASIC_METHOD_DEFINITION(ptBook, closeAndHide, CloseAndHide)

PYTHON_BASIC_METHOD_DEFINITION(ptBook, nextPage, NextPage)
PYTHON_BASIC_METHOD_DEFINITION(ptBook, previousPage, PreviousPage)

PYTHON_METHOD_DEFINITION(ptBook, goToPage, args)
{
    unsigned long page;
    if (!PyArg_ParseTuple(args, "l", &page))
    {
        PyErr_SetString(PyExc_TypeError, "goToPage expects an unsigned long");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->GoToPage(page);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptBook, setSize, args)
{
    float width, height;
    if (!PyArg_ParseTuple(args, "ff", &width, &height))
    {
        PyErr_SetString(PyExc_TypeError, "setSize expects two floats");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->SetSize(width, height);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptBook, getCurrentPage)
{
    return PyLong_FromUnsignedLong(self->fThis->GetCurrentPage());
}

PYTHON_METHOD_DEFINITION(ptBook, allowPageTurning, args)
{
    char allow;
    if (!PyArg_ParseTuple(args, "b", &allow))
    {
        PyErr_SetString(PyExc_TypeError, "allowPageTurning expects a boolean");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->AllowPageTurning(allow != 0);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptBook, setPageMargin, args)
{
    unsigned long margin;
    if (!PyArg_ParseTuple(args, "l", &margin))
    {
        PyErr_SetString(PyExc_TypeError, "setPageMargin expects an unsigned long");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->SetPageMargin(margin);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptBook, setGUI, args)
{
    char* guiName;
    if (!PyArg_ParseTuple(args, "s", &guiName))
    {
        PyErr_SetString(PyExc_TypeError, "setGUI expects a string");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->SetGUI(guiName);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptBook, getMovie, args)
{
    unsigned char index;
    if (!PyArg_ParseTuple(args, "b", &index))
    {
        PyErr_SetString(PyExc_TypeError, "getMovie expects a unsigned 8-bit int");
        PYTHON_RETURN_ERROR;
    }
    return self->fThis->GetMovie(index);
}

PYTHON_METHOD_DEFINITION(ptBook, setEditable, args)
{
    char editable;
    if (!PyArg_ParseTuple(args, "b", &editable))
    {
        PyErr_SetString(PyExc_TypeError, "setEditable expects a boolean");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->SetEditable(editable != 0);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptBook, getEditableText, args)
{
    return PyString_FromString(self->fThis->GetEditableText().c_str());
}

PYTHON_METHOD_DEFINITION(ptBook, setEditableText, args)
{
    char* text;
    if (!PyArg_ParseTuple(args, "s", &text))
    {
        PyErr_SetString(PyExc_TypeError, "setEditableText expects a string");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->SetEditableText(text);
    PYTHON_RETURN_NONE;
}

PYTHON_START_METHODS_TABLE(ptBook)
    PYTHON_METHOD(ptBook, show, "Params: startOpened\nShows the book closed, or open if the the startOpened flag is true"),
    PYTHON_BASIC_METHOD(ptBook, hide, "Hides the book"),
    PYTHON_METHOD(ptBook, open, "Params: startingPage\nOpens the book to the specified page"),
    PYTHON_BASIC_METHOD(ptBook, close, "Closes the book"),
    PYTHON_BASIC_METHOD(ptBook, closeAndHide, "Closes the book and hides it once it finishes animating"),
    PYTHON_BASIC_METHOD(ptBook, nextPage, "Flips the book to the next page"),
    PYTHON_BASIC_METHOD(ptBook, previousPage, "Flips the book to the previous page"),
    PYTHON_METHOD(ptBook, goToPage, "Params: page\nFlips the book to the specified page"),
    PYTHON_METHOD(ptBook, setSize, "Params: width,height\nSets the size of the book (width and height are floats from 0 to 1)"),
    PYTHON_METHOD_NOARGS(ptBook, getCurrentPage, "Returns the currently shown page"),
    PYTHON_METHOD(ptBook, allowPageTurning, "Params: allow\nTurns on and off the ability to flip the pages in a book"),
    PYTHON_METHOD(ptBook, setPageMargin, "Params: margin\nSets the text margin for the book"),
    PYTHON_METHOD(ptBook, setGUI, "Params: guiName\nSets the gui to be used by the book, if the requested gui is not loaded, it will use the default\nDo not call while the book is open!"),
    PYTHON_METHOD(ptBook, getMovie, "Params: index\nGrabs a ptAnimation object representing the movie indexed by index. The index is the index of the movie in the source code"),
    PYTHON_METHOD(ptBook, setEditable, "Params: editable\nTurn book editing on or off. If the book GUI does not support editing, nothing will happen"),
    PYTHON_METHOD(ptBook, getEditableText, "Returns the editable text currently contained in the book."),
    PYTHON_METHOD(ptBook, setEditableText, "Params: text\nSets the book's editable text."),
PYTHON_END_METHODS_TABLE;

// Type structure definition
PLASMA_DEFAULT_TYPE(ptBook, "Params: esHTMLSource,coverImage=None,callbackKey=None,guiName=''\nCreates a new book");

// required functions for PyObject interoperability
PyObject *pyJournalBook::New(std::string htmlSource, plKey coverImageKey /* = nil */, plKey callbackKey /* = nil */, std::string guiName /* = "" */)
{
    ptBook *newObj = (ptBook*)ptBook_type.tp_new(&ptBook_type, NULL, NULL);
    newObj->fThis->MakeBook(htmlSource, coverImageKey, callbackKey, guiName);
    return (PyObject*)newObj;
}

PyObject *pyJournalBook::New(std::wstring htmlSource, plKey coverImageKey /* = nil */, plKey callbackKey /* = nil */, std::string guiName /* = "" */)
{
    ptBook *newObj = (ptBook*)ptBook_type.tp_new(&ptBook_type, NULL, NULL);
    newObj->fThis->MakeBook(htmlSource, coverImageKey, callbackKey, guiName);
    return (PyObject*)newObj;
}

PYTHON_CLASS_CHECK_IMPL(ptBook, pyJournalBook)
PYTHON_CLASS_CONVERT_FROM_IMPL(ptBook, pyJournalBook)

///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaClasses - the python module definitions
//
void pyJournalBook::AddPlasmaClasses(PyObject *m)
{
    PYTHON_CLASS_IMPORT_START(m);
    PYTHON_CLASS_IMPORT(m, ptBook);
    PYTHON_CLASS_IMPORT_END(m);
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtLoadBookGUI, args, "Params: guiName\nLoads the gui specified, a gui must be loaded before it can be used. If the gui is already loaded, doesn't do anything")
{
    char* guiName;
    if (!PyArg_ParseTuple(args, "s", &guiName))
    {
        PyErr_SetString(PyExc_TypeError, "PtLoadBookGUI expects a string");
        PYTHON_RETURN_ERROR;
    }
    pyJournalBook::LoadGUI(guiName);
    PYTHON_RETURN_NONE;
}

PYTHON_GLOBAL_METHOD_DEFINITION(PtUnloadBookGUI, args, "Params: guiName\nUnloads the gui specified. If the gui isn't loaded, doesn't do anything")
{
    char* guiName;
    if (!PyArg_ParseTuple(args, "s", &guiName))
    {
        PyErr_SetString(PyExc_TypeError, "PtUnloadBookGUI expects a string");
        PYTHON_RETURN_ERROR;
    }
    pyJournalBook::UnloadGUI(guiName);
    PYTHON_RETURN_NONE;
}

PYTHON_BASIC_GLOBAL_METHOD_DEFINITION(PtUnloadAllBookGUIs, pyJournalBook::UnloadAllGUIs, "Unloads all loaded guis except for the default one")

void pyJournalBook::AddPlasmaMethods(std::vector<PyMethodDef> &methods)
{
    PYTHON_GLOBAL_METHOD(methods, PtLoadBookGUI);
    PYTHON_GLOBAL_METHOD(methods, PtUnloadBookGUI);
    PYTHON_BASIC_GLOBAL_METHOD(methods, PtUnloadAllBookGUIs);
}

void pyJournalBook::AddPlasmaConstantsClasses(PyObject *m)
{
    PYTHON_ENUM_START(PtBookEventTypes);
    PYTHON_ENUM_ELEMENT(PtBookEventTypes, kNotifyImageLink,         pfJournalBook::kNotifyImageLink);
    PYTHON_ENUM_ELEMENT(PtBookEventTypes, kNotifyShow,              pfJournalBook::kNotifyShow);
    PYTHON_ENUM_ELEMENT(PtBookEventTypes, kNotifyHide,              pfJournalBook::kNotifyHide);
    PYTHON_ENUM_ELEMENT(PtBookEventTypes, kNotifyNextPage,          pfJournalBook::kNotifyNextPage);
    PYTHON_ENUM_ELEMENT(PtBookEventTypes, kNotifyPreviousPage,      pfJournalBook::kNotifyPreviousPage);
    PYTHON_ENUM_ELEMENT(PtBookEventTypes, kNotifyCheckUnchecked,    pfJournalBook::kNotifyCheckUnchecked);
    PYTHON_ENUM_ELEMENT(PtBookEventTypes, kNotifyClose,             pfJournalBook::kNotifyClose);
    PYTHON_ENUM_END(m, PtBookEventTypes);
}