You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

353 lines
12 KiB

/*==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);
}