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.

461 lines
17 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 "pyGUIControlMultiLineEdit.h"
#include "pyEnum.h"
#include "pyColor.h"
#include "pfGameGUIMgr/pfGUIMultiLineEditCtrl.h"
#include <python.h>
// glue functions
PYTHON_CLASS_DEFINITION(ptGUIControlMultiLineEdit, pyGUIControlMultiLineEdit);
PYTHON_DEFAULT_NEW_DEFINITION(ptGUIControlMultiLineEdit, pyGUIControlMultiLineEdit)
PYTHON_DEFAULT_DEALLOC_DEFINITION(ptGUIControlMultiLineEdit)
PYTHON_INIT_DEFINITION(ptGUIControlMultiLineEdit, args, keywords)
{
PyObject *keyObject = NULL;
if (!PyArg_ParseTuple(args, "O", &keyObject))
{
PyErr_SetString(PyExc_TypeError, "__init__ expects a ptKey");
PYTHON_RETURN_INIT_ERROR;
}
if (!pyKey::Check(keyObject))
{
PyErr_SetString(PyExc_TypeError, "__init__ expects a ptKey");
PYTHON_RETURN_INIT_ERROR;
}
pyKey *key = pyKey::ConvertFrom(keyObject);
self->fThis->setKey(key->getKey());
PYTHON_RETURN_INIT_OK;
}
PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlMultiLineEdit, clickable, Clickable)
PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlMultiLineEdit, unclickable, Unclickable)
PYTHON_METHOD_DEFINITION(ptGUIControlMultiLineEdit, setScrollPosition, args)
{
long topLine;
if (!PyArg_ParseTuple(args, "l", &topLine))
{
PyErr_SetString(PyExc_TypeError, "setScrollPosition expects a long");
PYTHON_RETURN_ERROR;
}
self->fThis->SetScrollPosition(topLine);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptGUIControlMultiLineEdit, moveCursor, args)
{
long dir;
if (!PyArg_ParseTuple(args, "l", &dir))
{
PyErr_SetString(PyExc_TypeError, "moveCursor expects a long");
PYTHON_RETURN_ERROR;
}
self->fThis->MoveCursor(dir);
PYTHON_RETURN_NONE;
}
PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlMultiLineEdit, clearBuffer, ClearBuffer)
PYTHON_METHOD_DEFINITION(ptGUIControlMultiLineEdit, setString, args)
{
char* text;
if (!PyArg_ParseTuple(args, "s", &text))
{
PyErr_SetString(PyExc_TypeError, "setString expects a string");
PYTHON_RETURN_ERROR;
}
self->fThis->SetText(text);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptGUIControlMultiLineEdit, setStringW, args)
{
PyObject* textObj;
if (!PyArg_ParseTuple(args, "O", &textObj))
{
PyErr_SetString(PyExc_TypeError, "setStringW expects a unicode string");
PYTHON_RETURN_ERROR;
}
if (PyUnicode_Check(textObj))
{
int strLen = PyUnicode_GetSize(textObj);
wchar_t* temp = TRACKED_NEW wchar_t[strLen + 1];
PyUnicode_AsWideChar((PyUnicodeObject*)textObj, temp, strLen);
temp[strLen] = L'\0';
self->fThis->SetTextW(temp);
delete [] temp;
PYTHON_RETURN_NONE;
}
else if (PyString_Check(textObj))
{
// we'll allow this, just in case something goes weird
char* temp = PyString_AsString(textObj);
self->fThis->SetText(temp);
PYTHON_RETURN_NONE;
}
else
{
PyErr_SetString(PyExc_TypeError, "setStringW expects a unicode string");
PYTHON_RETURN_ERROR;
}
}
PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlMultiLineEdit, getString)
{
return PyString_FromString(self->fThis->GetText());
}
PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlMultiLineEdit, getStringW)
{
const wchar_t* text = self->fThis->GetTextW();
return PyUnicode_FromWideChar(text, wcslen(text));
}
PYTHON_METHOD_DEFINITION(ptGUIControlMultiLineEdit, setEncodedBuffer, args)
{
PyObject* bufferObj = NULL;
if (!PyArg_ParseTuple(args, "O", &bufferObj))
{
PyErr_SetString(PyExc_TypeError, "setEncodedBuffer expects a python buffer object");
PYTHON_RETURN_ERROR;
}
self->fThis->SetEncodedBuffer(bufferObj);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptGUIControlMultiLineEdit, setEncodedBufferW, args)
{
PyObject* bufferObj = NULL;
if (!PyArg_ParseTuple(args, "O", &bufferObj))
{
PyErr_SetString(PyExc_TypeError, "setEncodedBufferW expects a python buffer object");
PYTHON_RETURN_ERROR;
}
self->fThis->SetEncodedBufferW(bufferObj);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlMultiLineEdit, getEncodedBuffer)
{
const char* buffer = self->fThis->GetEncodedBuffer();
PyObject* retVal = PyString_FromString(buffer);
delete [] buffer;
return retVal;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlMultiLineEdit, getEncodedBufferW)
{
const wchar_t* text = self->fThis->GetEncodedBufferW();
PyObject* retVal = PyUnicode_FromWideChar(text, wcslen(text));
delete [] text;
return retVal;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlMultiLineEdit, getBufferSize)
{
return PyLong_FromUnsignedLong(self->fThis->GetBufferSize());
}
PYTHON_METHOD_DEFINITION(ptGUIControlMultiLineEdit, insertChar, args)
{
char c;
if (!PyArg_ParseTuple(args, "c", &c))
{
PyErr_SetString(PyExc_TypeError, "insertChar expects a single character");
PYTHON_RETURN_ERROR;
}
self->fThis->InsertChar(c);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptGUIControlMultiLineEdit, insertCharW, args)
{
PyObject* textObj;
if (!PyArg_ParseTuple(args, "O", &textObj))
{
PyErr_SetString(PyExc_TypeError, "insertCharW expects a single unicode character");
PYTHON_RETURN_ERROR;
}
if (PyUnicode_Check(textObj))
{
int strLen = PyUnicode_GetSize(textObj);
if (strLen != 1)
{
PyErr_SetString(PyExc_TypeError, "insertCharW expects a single unicode character");
PYTHON_RETURN_ERROR;
}
wchar_t* temp = TRACKED_NEW wchar_t[strLen + 1];
PyUnicode_AsWideChar((PyUnicodeObject*)textObj, temp, strLen);
temp[strLen] = L'\0';
self->fThis->InsertCharW(temp[0]);
delete [] temp;
PYTHON_RETURN_NONE;
}
else if (PyString_Check(textObj))
{
// we'll allow this, just in case something goes weird
char* temp = PyString_AsString(textObj);
if (strlen(temp) != 1)
{
PyErr_SetString(PyExc_TypeError, "insertCharW expects a single unicode character");
PYTHON_RETURN_ERROR;
}
self->fThis->InsertChar(temp[0]);
PYTHON_RETURN_NONE;
}
else
{
PyErr_SetString(PyExc_TypeError, "insertCharW expects a single unicode character");
PYTHON_RETURN_ERROR;
}
}
PYTHON_METHOD_DEFINITION(ptGUIControlMultiLineEdit, insertString, args)
{
char* str;
if (!PyArg_ParseTuple(args, "s", &str))
{
PyErr_SetString(PyExc_TypeError, "insertString expects a string");
PYTHON_RETURN_ERROR;
}
self->fThis->InsertString(str);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptGUIControlMultiLineEdit, insertStringW, args)
{
PyObject* textObj;
if (!PyArg_ParseTuple(args, "O", &textObj))
{
PyErr_SetString(PyExc_TypeError, "insertStringW expects a unicode string");
PYTHON_RETURN_ERROR;
}
if (PyUnicode_Check(textObj))
{
int strLen = PyUnicode_GetSize(textObj);
wchar_t* temp = TRACKED_NEW wchar_t[strLen + 1];
PyUnicode_AsWideChar((PyUnicodeObject*)textObj, temp, strLen);
temp[strLen] = L'\0';
self->fThis->InsertStringW(temp);
delete [] temp;
PYTHON_RETURN_NONE;
}
else if (PyString_Check(textObj))
{
// we'll allow this, just in case something goes weird
char* temp = PyString_AsString(textObj);
self->fThis->InsertString(temp);
PYTHON_RETURN_NONE;
}
else
{
PyErr_SetString(PyExc_TypeError, "insertStringW expects a unicode string");
PYTHON_RETURN_ERROR;
}
}
PYTHON_METHOD_DEFINITION(ptGUIControlMultiLineEdit, insertColor, args)
{
PyObject* colorObj = NULL;
if (!PyArg_ParseTuple(args, "O", &colorObj))
{
PyErr_SetString(PyExc_TypeError, "insertColor expects a ptColor");
PYTHON_RETURN_ERROR;
}
if (!pyColor::Check(colorObj))
{
PyErr_SetString(PyExc_TypeError, "insertColor expects a ptColor");
PYTHON_RETURN_ERROR;
}
pyColor* color = pyColor::ConvertFrom(colorObj);
self->fThis->InsertColor(*color);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION(ptGUIControlMultiLineEdit, insertStyle, args)
{
char style;
if (!PyArg_ParseTuple(args, "b", &style))
{
PyErr_SetString(PyExc_TypeError, "insertStyle expects a 8-bit integer");
PYTHON_RETURN_ERROR;
}
self->fThis->InsertStyle(style);
PYTHON_RETURN_NONE;
}
PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlMultiLineEdit, deleteChar, DeleteChar)
PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlMultiLineEdit, lock, Lock)
PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlMultiLineEdit, unlock, Unlock)
PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlMultiLineEdit, isLocked)
{
PYTHON_RETURN_BOOL(self->fThis->IsLocked());
}
PYTHON_METHOD_DEFINITION(ptGUIControlMultiLineEdit, setBufferLimit, args)
{
long limit;
if (!PyArg_ParseTuple(args, "l", &limit))
{
PyErr_SetString(PyExc_TypeError, "setBufferLimit expects a long");
PYTHON_RETURN_ERROR;
}
self->fThis->SetBufferLimit(limit);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlMultiLineEdit, getBufferLimit)
{
return PyLong_FromLong(self->fThis->GetBufferLimit());
}
PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlMultiLineEdit, enableScrollControl, EnableScrollControl)
PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlMultiLineEdit, disableScrollControl, DisableScrollControl)
PYTHON_METHOD_DEFINITION(ptGUIControlMultiLineEdit, deleteLinesFromTop, args)
{
long lines;
if (!PyArg_ParseTuple(args, "l", &lines))
{
PyErr_SetString(PyExc_TypeError, "deleteLinesFromTop expects an int");
PYTHON_RETURN_ERROR;
}
self->fThis->DeleteLinesFromTop(lines);
PYTHON_RETURN_NONE;
}
PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlMultiLineEdit, getFontSize)
{
return PyLong_FromUnsignedLong(self->fThis->GetFontSize());
}
PYTHON_METHOD_DEFINITION(ptGUIControlMultiLineEdit, setFontSize, args)
{
unsigned long fontSize;
if (!PyArg_ParseTuple(args, "l", &fontSize))
{
PyErr_SetString(PyExc_TypeError, "setFontSize expects an unsigned long");
PYTHON_RETURN_ERROR;
}
self->fThis->SetFontSize(fontSize);
PYTHON_RETURN_NONE;
}
PYTHON_START_METHODS_TABLE(ptGUIControlMultiLineEdit)
PYTHON_BASIC_METHOD(ptGUIControlMultiLineEdit, clickable, "Sets this listbox to be clickable by the user."),
PYTHON_BASIC_METHOD(ptGUIControlMultiLineEdit, unclickable, "Makes this listbox not clickable by the user.\n"
"Useful when just displaying a list that is not really selectable."),
PYTHON_METHOD(ptGUIControlMultiLineEdit, setScrollPosition, "Params: topLine\nSets the what line is the top line."),
PYTHON_METHOD(ptGUIControlMultiLineEdit, moveCursor, "Params: direction\nMove the cursor in the specified direction (see PtGUIMultiLineDirection)"),
PYTHON_BASIC_METHOD(ptGUIControlMultiLineEdit, clearBuffer, "Clears all text from the multi-line edit control."),
PYTHON_METHOD(ptGUIControlMultiLineEdit, setString, "Params: asciiText\nSets the multi-line edit control string."),
PYTHON_METHOD(ptGUIControlMultiLineEdit, setStringW, "Params: unicodeText\nUnicode version of setString."),
PYTHON_METHOD_NOARGS(ptGUIControlMultiLineEdit, getString, "Gets the string of the edit control."),
PYTHON_METHOD_NOARGS(ptGUIControlMultiLineEdit, getStringW, "Unicode version of getString."),
PYTHON_METHOD(ptGUIControlMultiLineEdit, setEncodedBuffer, "Params: bufferObject\nSets the edit control to the encoded buffer in the python buffer object. Do NOT use with a result from getEncodedBufferW."),
PYTHON_METHOD(ptGUIControlMultiLineEdit, setEncodedBufferW, "Params: bufferObject\nUnicode version of setEncodedBuffer. Do NOT use with a result from getEncodedBuffer."),
PYTHON_METHOD_NOARGS(ptGUIControlMultiLineEdit, getEncodedBuffer, "Returns the encoded buffer in a python buffer object. Do NOT use result with setEncodedBufferW."),
PYTHON_METHOD_NOARGS(ptGUIControlMultiLineEdit, getEncodedBufferW, "Unicode version of getEncodedBuffer. Do NOT use result with setEncodedBuffer."),
PYTHON_METHOD_NOARGS(ptGUIControlMultiLineEdit, getBufferSize, "Returns the size of the buffer"),
PYTHON_METHOD(ptGUIControlMultiLineEdit, insertChar, "Params: c\nInserts a character at the current cursor position."),
PYTHON_METHOD(ptGUIControlMultiLineEdit, insertCharW, "Params: c\nUnicode version of insertChar."),
PYTHON_METHOD(ptGUIControlMultiLineEdit, insertString, "Params: string\nInserts a string at the current cursor position."),
PYTHON_METHOD(ptGUIControlMultiLineEdit, insertStringW, "Params: string\nUnicode version of insertString"),
PYTHON_METHOD(ptGUIControlMultiLineEdit, insertColor, "Params: color\nInserts an encoded color object at the current cursor position.\n"
"'color' is a ptColor object."),
PYTHON_METHOD(ptGUIControlMultiLineEdit, insertStyle, "Params: style\nInserts an encoded font style at the current cursor position."),
PYTHON_BASIC_METHOD(ptGUIControlMultiLineEdit, deleteChar, "Deletes a character at the current cursor position."),
PYTHON_BASIC_METHOD(ptGUIControlMultiLineEdit, lock, "Locks the multi-line edit control so the user cannot make changes."),
PYTHON_BASIC_METHOD(ptGUIControlMultiLineEdit, unlock, "Unlocks the multi-line edit control so that the user can make changes."),
PYTHON_METHOD_NOARGS(ptGUIControlMultiLineEdit, isLocked, "Is the multi-line edit control locked? Returns 1 if true otherwise returns 0"),
PYTHON_METHOD(ptGUIControlMultiLineEdit, setBufferLimit, "Params: bufferLimit\nSets the buffer max for the editbox"),
PYTHON_METHOD_NOARGS(ptGUIControlMultiLineEdit, getBufferLimit, "Returns the current buffer limit"),
PYTHON_BASIC_METHOD(ptGUIControlMultiLineEdit, enableScrollControl, "Enables the scroll control if there is one"),
PYTHON_BASIC_METHOD(ptGUIControlMultiLineEdit, disableScrollControl, "Disables the scroll control if there is one"),
PYTHON_METHOD(ptGUIControlMultiLineEdit, deleteLinesFromTop, "Params: numLines\nDeletes the specified number of lines from the top of the text buffer"),
PYTHON_METHOD_NOARGS(ptGUIControlMultiLineEdit, getFontSize, "Returns the current default font size"),
PYTHON_METHOD(ptGUIControlMultiLineEdit, setFontSize, "Params: fontSize\nSets the default font size for the edit control"),
PYTHON_END_METHODS_TABLE;
// Type structure definition
PLASMA_DEFAULT_TYPE_WBASE(ptGUIControlMultiLineEdit, pyGUIControl, "Params: ctrlKey\nPlasma GUI Control Multi-line edit class");
// required functions for PyObject interoperability
PyObject *pyGUIControlMultiLineEdit::New(pyKey& gckey)
{
ptGUIControlMultiLineEdit *newObj = (ptGUIControlMultiLineEdit*)ptGUIControlMultiLineEdit_type.tp_new(&ptGUIControlMultiLineEdit_type, NULL, NULL);
newObj->fThis->fGCkey = gckey.getKey();
return (PyObject*)newObj;
}
PyObject *pyGUIControlMultiLineEdit::New(plKey objkey)
{
ptGUIControlMultiLineEdit *newObj = (ptGUIControlMultiLineEdit*)ptGUIControlMultiLineEdit_type.tp_new(&ptGUIControlMultiLineEdit_type, NULL, NULL);
newObj->fThis->fGCkey = objkey;
return (PyObject*)newObj;
}
PYTHON_CLASS_CHECK_IMPL(ptGUIControlMultiLineEdit, pyGUIControlMultiLineEdit)
PYTHON_CLASS_CONVERT_FROM_IMPL(ptGUIControlMultiLineEdit, pyGUIControlMultiLineEdit)
///////////////////////////////////////////////////////////////////////////
//
// AddPlasmaClasses - the python module definitions
//
void pyGUIControlMultiLineEdit::AddPlasmaClasses(PyObject *m)
{
PYTHON_CLASS_IMPORT_START(m);
PYTHON_CLASS_IMPORT(m, ptGUIControlMultiLineEdit);
PYTHON_CLASS_IMPORT_END(m);
}
void pyGUIControlMultiLineEdit::AddPlasmaConstantsClasses(PyObject *m)
{
PYTHON_ENUM_START(PtGUIMultiLineDirection);
PYTHON_ENUM_ELEMENT(PtGUIMultiLineDirection, kLineStart, pfGUIMultiLineEditCtrl::kLineStart);
PYTHON_ENUM_ELEMENT(PtGUIMultiLineDirection, kLineEnd, pfGUIMultiLineEditCtrl::kLineEnd);
PYTHON_ENUM_ELEMENT(PtGUIMultiLineDirection, kBufferStart, pfGUIMultiLineEditCtrl::kBufferStart);
PYTHON_ENUM_ELEMENT(PtGUIMultiLineDirection, kBufferEnd, pfGUIMultiLineEditCtrl::kBufferEnd);
PYTHON_ENUM_ELEMENT(PtGUIMultiLineDirection, kOneBack, pfGUIMultiLineEditCtrl::kOneBack);
PYTHON_ENUM_ELEMENT(PtGUIMultiLineDirection, kOneForward, pfGUIMultiLineEditCtrl::kOneForward);
PYTHON_ENUM_ELEMENT(PtGUIMultiLineDirection, kOneWordBack, pfGUIMultiLineEditCtrl::kOneWordBack);
PYTHON_ENUM_ELEMENT(PtGUIMultiLineDirection, kOneWordForward, pfGUIMultiLineEditCtrl::kOneWordForward);
PYTHON_ENUM_ELEMENT(PtGUIMultiLineDirection, kOneLineUp, pfGUIMultiLineEditCtrl::kOneLineUp);
PYTHON_ENUM_ELEMENT(PtGUIMultiLineDirection, kOneLineDown, pfGUIMultiLineEditCtrl::kOneLineDown);
PYTHON_ENUM_ELEMENT(PtGUIMultiLineDirection, kPageUp, pfGUIMultiLineEditCtrl::kPageUp);
PYTHON_ENUM_ELEMENT(PtGUIMultiLineDirection, kPageDown, pfGUIMultiLineEditCtrl::kPageDown);
PYTHON_ENUM_END(m, PtGUIMultiLineDirection);
}