CWE-ou-minkata/Sources/Plasma/FeatureLib/pfPython/pyGUIControlListBoxGlue.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 "pyGUIControlListBox.h"
#include "pyImage.h"

#include <python.h>

// glue functions
PYTHON_CLASS_DEFINITION(ptGUIControlListBox, pyGUIControlListBox);

PYTHON_DEFAULT_NEW_DEFINITION(ptGUIControlListBox, pyGUIControlListBox)
PYTHON_DEFAULT_DEALLOC_DEFINITION(ptGUIControlListBox)

PYTHON_INIT_DEFINITION(ptGUIControlListBox, 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(ptGUIControlListBox, clickable, Clickable)
PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlListBox, unclickable, Unclickable)

PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlListBox, getSelection)
{
    return PyLong_FromLong(self->fThis->GetSelection());
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, setSelection, args)
{
    long selectionIndex;
    if (!PyArg_ParseTuple(args, "l", &selectionIndex))
    {
        PyErr_SetString(PyExc_TypeError, "setSelection expects a long");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->SetSelection(selectionIndex);
    PYTHON_RETURN_NONE;
}

PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlListBox, refresh, Refresh)

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, removeElement, args)
{
    unsigned short index;
    if (!PyArg_ParseTuple(args, "h", &index))
    {
        PyErr_SetString(PyExc_TypeError, "removeElement expects an unsigned short");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->RemoveElement(index);
    PYTHON_RETURN_NONE;
}

PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlListBox, clearAllElements, ClearAllElements)

PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlListBox, getNumElements)
{
    return PyInt_FromLong(self->fThis->GetNumElements());
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, setElement, args)
{
    unsigned short index;
    char* text;
    if (!PyArg_ParseTuple(args, "hs", &index, &text))
    {
        PyErr_SetString(PyExc_TypeError, "setElement expects an unsigned short and a string");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->SetElement(index, text);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, setElementW, args)
{
    unsigned short index;
    wchar_t* text;
    if (!PyArg_ParseTuple(args, "hu", &index, &text))
    {
        PyErr_SetString(PyExc_TypeError, "setElementW expects an unsigned short and a unicode string");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->SetElementW(index, text);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, getElement, args)
{
    unsigned short index;
    if (!PyArg_ParseTuple(args, "h", &index))
    {
        PyErr_SetString(PyExc_TypeError, "getElement expects an unsigned short");
        PYTHON_RETURN_ERROR;
    }
    return PyString_FromString(self->fThis->GetElement(index).c_str());
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, getElementW, args)
{
    unsigned short index;
    if (!PyArg_ParseTuple(args, "h", &index))
    {
        PyErr_SetString(PyExc_TypeError, "getElementW expects an unsigned short");
        PYTHON_RETURN_ERROR;
    }
    std::wstring retVal = self->fThis->GetElementW(index);
    return PyUnicode_FromWideChar(retVal.c_str(), retVal.length());
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, setStringJustify, args)
{
    unsigned short index;
    unsigned long justify;
    if (!PyArg_ParseTuple(args, "hl", &index, &justify))
    {
        PyErr_SetString(PyExc_TypeError, "setStringJustify expects an unsigned short and an unsigned long");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->SetStringJustify(index, justify);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, addString, args)
{
    char* text;
    if (!PyArg_ParseTuple(args, "s", &text))
    {
        PyErr_SetString(PyExc_TypeError, "addString expects a string");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->AddString(text));
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, addStringW, args)
{
    wchar_t* text;
    if (!PyArg_ParseTuple(args, "u", &text))
    {
        PyErr_SetString(PyExc_TypeError, "addStringW expects a unicode string");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->AddStringW(text));
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, findString, args)
{
    char* text;
    if (!PyArg_ParseTuple(args, "s", &text))
    {
        PyErr_SetString(PyExc_TypeError, "findString expects a string");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->FindString(text));
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, findStringW, args)
{
    wchar_t* text;
    if (!PyArg_ParseTuple(args, "u", &text))
    {
        PyErr_SetString(PyExc_TypeError, "findStringW expects a unicode string");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->FindStringW(text));
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, addImage, args)
{
    PyObject* imageObj = NULL;
    char respectAlphaFlag;
    if (!PyArg_ParseTuple(args, "Ob", &imageObj, &respectAlphaFlag))
    {
        PyErr_SetString(PyExc_TypeError, "addImage expects a ptImage and a boolean");
        PYTHON_RETURN_ERROR;
    }
    if (!pyImage::Check(imageObj))
    {
        PyErr_SetString(PyExc_TypeError, "addImage expects a ptImage and a boolean");
        PYTHON_RETURN_ERROR;
    }
    pyImage* image = pyImage::ConvertFrom(imageObj);
    return PyInt_FromLong(self->fThis->AddImage(*image, respectAlphaFlag != 0));
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, addImageInBox, args)
{
    PyObject* imageObj = NULL;
    unsigned long x, y, width, height;
    char respectAlphaFlag;
    if (!PyArg_ParseTuple(args, "Ollllb", &imageObj, &x, &y, &width, &height, &respectAlphaFlag))
    {
        PyErr_SetString(PyExc_TypeError, "addImageInBox expects a ptImage, four unsigned longs, and a boolean");
        PYTHON_RETURN_ERROR;
    }
    if (!pyImage::Check(imageObj))
    {
        PyErr_SetString(PyExc_TypeError, "addImageInBox expects a ptImage, four unsigned longs, and a boolean");
        PYTHON_RETURN_ERROR;
    }
    pyImage* image = pyImage::ConvertFrom(imageObj);
    return PyInt_FromLong(self->fThis->AddImageInBox(*image, x, y, width, height, respectAlphaFlag != 0));
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, addStringWithColor, args)
{
    char* text;
    PyObject* colorObj = NULL;
    unsigned long inheritAlpha;
    if (!PyArg_ParseTuple(args, "sOl", &text, &colorObj, &inheritAlpha))
    {
        PyErr_SetString(PyExc_TypeError, "addStringWithColor expects a string, ptColor, and an unsigned long");
        PYTHON_RETURN_ERROR;
    }
    if (!pyColor::Check(colorObj))
    {
        PyErr_SetString(PyExc_TypeError, "addStringWithColor expects a string, ptColor, and an unsigned long");
        PYTHON_RETURN_ERROR;
    }
    pyColor* color = pyColor::ConvertFrom(colorObj);
    return PyInt_FromLong(self->fThis->AddTextWColor(text, *color, inheritAlpha));
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, addStringWithColorWithSize, args)
{
    char* text;
    PyObject* colorObj = NULL;
    unsigned long inheritAlpha;
    long textSize;
    if (!PyArg_ParseTuple(args, "sOll", &text, &colorObj, &inheritAlpha, &textSize))
    {
        PyErr_SetString(PyExc_TypeError, "addStringWithColorWithSize expects a string, ptColor, an unsigned long, and a long");
        PYTHON_RETURN_ERROR;
    }
    if (!pyColor::Check(colorObj))
    {
        PyErr_SetString(PyExc_TypeError, "addStringWithColorWithSize expects a string, ptColor, an unsigned long, and a long");
        PYTHON_RETURN_ERROR;
    }
    pyColor* color = pyColor::ConvertFrom(colorObj);
    return PyInt_FromLong(self->fThis->AddTextWColorWSize(text, *color, inheritAlpha, textSize));
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, add2StringsWithColors, args)
{
    char* text1;
    PyObject* color1Obj = NULL;
    char* text2;
    PyObject* color2Obj = NULL;
    unsigned long inheritAlpha;
    if (!PyArg_ParseTuple(args, "sOsOl", &text1, &color1Obj, &text2, &color2Obj, &inheritAlpha))
    {
        PyErr_SetString(PyExc_TypeError, "addStringWithColor expects a string, ptColor, string, ptColor, and an unsigned long");
        PYTHON_RETURN_ERROR;
    }
    if ((!pyColor::Check(color2Obj)) || (!pyColor::Check(color2Obj)))
    {
        PyErr_SetString(PyExc_TypeError, "addStringWithColor expects a string, ptColor, string, ptColor, and an unsigned long");
        PYTHON_RETURN_ERROR;
    }
    pyColor* color1 = pyColor::ConvertFrom(color1Obj);
    pyColor* color2 = pyColor::ConvertFrom(color2Obj);
    self->fThis->Add2TextWColor(text1, *color1, text2, *color2, inheritAlpha);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, addStringInBox, args)
{
    char* text;
    unsigned long minWidth, minHeight;
    if (!PyArg_ParseTuple(args, "sll", &text, &minWidth, &minHeight))
    {
        PyErr_SetString(PyExc_TypeError, "addStringInBox expects a string and two unsigned longs");
        PYTHON_RETURN_ERROR;
    }
    return PyInt_FromLong(self->fThis->AddStringInBox(text, minWidth, minHeight));
}

PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlListBox, scrollToBegin, ScrollToBegin)
PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlListBox, scrollToEnd, ScrollToEnd)

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, setScrollPos, args)
{
    short pos;
    if (!PyArg_ParseTuple(args, "h", &pos))
    {
        PyErr_SetString(PyExc_TypeError, "setScrollPos expects a short");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->SetScrollPos(pos);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlListBox, getScrollPos)
{
    return PyLong_FromLong(self->fThis->GetScrollPos());
}

PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlListBox, getScrollRange)
{
    return PyLong_FromLong(self->fThis->GetScrollRange());
}

PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlListBox, lock, LockList)
PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlListBox, unlock, UnlockList)

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, addBranch, args)
{
    char* name;
    char initiallyOpen;
    if (!PyArg_ParseTuple(args, "sb", &name, &initiallyOpen))
    {
        PyErr_SetString(PyExc_TypeError, "addBranch expects a string and a boolean");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->AddBranch(name, initiallyOpen != 0);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, addBranchW, args)
{
    PyObject* textObj;
    char initiallyOpen;
    if (!PyArg_ParseTuple(args, "Ob", &textObj, &initiallyOpen))
    {
        PyErr_SetString(PyExc_TypeError, "addBranchW expects a unicode string and a boolean");
        PYTHON_RETURN_ERROR;
    }
    if (PyUnicode_Check(textObj))
    {
        int strLen = PyUnicode_GetSize(textObj);
        wchar_t* name = TRACKED_NEW wchar_t[strLen + 1];
        PyUnicode_AsWideChar((PyUnicodeObject*)textObj, name, strLen);
        name[strLen] = L'\0';
        self->fThis->AddBranchW(name, initiallyOpen != 0);
        delete [] name;
        PYTHON_RETURN_NONE;
    }
    else if (PyString_Check(textObj))
    {
        // we'll allow this, just in case something goes weird
        char* name = PyString_AsString(textObj);
        self->fThis->AddBranch(name, initiallyOpen != 0);
        PYTHON_RETURN_NONE;
    }
    else
    {
        PyErr_SetString(PyExc_TypeError, "addBranchW expects a unicode string and a boolean");
        PYTHON_RETURN_ERROR;
    }
}

PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlListBox, closeBranch, CloseBranch)

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, removeSelection, args)
{
    long itemIdx;
    if (!PyArg_ParseTuple(args, "l", &itemIdx))
    {
        PyErr_SetString(PyExc_TypeError, "removeSelection expects a long");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->RemoveSelection(itemIdx);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, addSelection, args)
{
    long itemIdx;
    if (!PyArg_ParseTuple(args, "l", &itemIdx))
    {
        PyErr_SetString(PyExc_TypeError, "addSelection expects a long");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->AddSelection(itemIdx);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlListBox, getSelectionList)
{
    return self->fThis->GetSelectionList();
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, addImageAndSwatchesInBox, args)
{
    PyObject* imageObj = NULL;
    unsigned long x, y, width, height;
    char respectAlpha;
    PyObject* primaryObj = NULL;
    PyObject* secondaryObj = NULL;
    if (!PyArg_ParseTuple(args, "OllllbOO", &imageObj, &x, &y, &width, &height, &respectAlpha, &primaryObj, &secondaryObj))
    {
        PyErr_SetString(PyExc_TypeError, "addImageAndSwatchesInBox expects a ptImage, four unsigned longs, a boolean, and two ptColor objects");
        PYTHON_RETURN_ERROR;
    }
    if ((!pyImage::Check(imageObj)) || (!pyColor::Check(primaryObj)) || (!pyColor::Check(secondaryObj)))
    {
        PyErr_SetString(PyExc_TypeError, "addImageAndSwatchesInBox expects a ptImage, four unsigned longs, a boolean, and two ptColor objects");
        PYTHON_RETURN_ERROR;
    }
    pyImage* image = pyImage::ConvertFrom(imageObj);
    pyColor* primary = pyColor::ConvertFrom(primaryObj);
    pyColor* secondary = pyColor::ConvertFrom(secondaryObj);
    return PyInt_FromLong(self->fThis->AddImageAndSwatchesInBox(*image, x, y, width, height, respectAlpha != 0, *primary, *secondary));
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, setGlobalSwatchSize, args)
{
    unsigned long swatchSize;
    if (!PyArg_ParseTuple(args, "l", &swatchSize))
    {
        PyErr_SetString(PyExc_TypeError, "setGlobalSwatchSize expects an unsigned long");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->SetSwatchSize(swatchSize);
    PYTHON_RETURN_NONE;
}

PYTHON_METHOD_DEFINITION(ptGUIControlListBox, setGlobalSwatchEdgeOffset, args)
{
    unsigned long offset;
    if (!PyArg_ParseTuple(args, "l", &offset))
    {
        PyErr_SetString(PyExc_TypeError, "setGlobalSwatchEdgeOffset expects an unsigned long");
        PYTHON_RETURN_ERROR;
    }
    self->fThis->SetSwatchEdgeOffset(offset);
    PYTHON_RETURN_NONE;
}

PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlListBox, allowNoSelect, AllowNoSelect)
PYTHON_BASIC_METHOD_DEFINITION(ptGUIControlListBox, disallowNoSelect, DisallowNoSelect)

PYTHON_METHOD_DEFINITION_NOARGS(ptGUIControlListBox, getBranchList)
{
    return self->fThis->GetBranchList();
}

PYTHON_START_METHODS_TABLE(ptGUIControlListBox)
    PYTHON_BASIC_METHOD(ptGUIControlListBox, clickable, "Sets this listbox to be clickable by the user."),
    PYTHON_BASIC_METHOD(ptGUIControlListBox, unclickable, "Makes this listbox not clickable by the user.\n"
                "Useful when just displaying a list that is not really selectable."),
    PYTHON_METHOD_NOARGS(ptGUIControlListBox, getSelection, "Returns the currently selected list item in the listbox."),
    PYTHON_METHOD(ptGUIControlListBox, setSelection, "Params: selectionIndex\nSets the current selection in the listbox."),
    PYTHON_BASIC_METHOD(ptGUIControlListBox, refresh, "Refresh the display of the listbox (after updating contents)."),
    PYTHON_METHOD(ptGUIControlListBox, removeElement, "Params: index\nRemoves element at 'index' in the listbox."),
    PYTHON_BASIC_METHOD(ptGUIControlListBox, clearAllElements, "Removes all the items from the listbox, making it empty."),
    PYTHON_METHOD_NOARGS(ptGUIControlListBox, getNumElements, "Return the number of items in the listbox."),
    PYTHON_METHOD(ptGUIControlListBox, setElement, "Params: index,text\nSet a particular item in the listbox to a string."),
    PYTHON_METHOD(ptGUIControlListBox, setElementW, "Params: index,text\nUnicode version of setElement."),
    PYTHON_METHOD(ptGUIControlListBox, getElement, "Params: index\nGet the string of the item at 'index' in the listbox."),
    PYTHON_METHOD(ptGUIControlListBox, getElementW, "Params: index\nUnicode version of getElement."),
    PYTHON_METHOD(ptGUIControlListBox, setStringJustify, "Params: index,justify\nSets the text justification"),
    PYTHON_METHOD(ptGUIControlListBox, addString, "Params: text\nAppends a list item 'text' to the listbox."),
    PYTHON_METHOD(ptGUIControlListBox, addStringW, "Params: text\nUnicode version of addString."),
    PYTHON_METHOD(ptGUIControlListBox, findString, "Params: text\nFinds and returns the index of the item that matches 'text' in the listbox."),
    PYTHON_METHOD(ptGUIControlListBox, findStringW, "Params: text\nUnicode version of findString."),
    PYTHON_METHOD(ptGUIControlListBox, addImage, "Params: image,respectAlphaFlag\nAppends an image item to the listbox"),
    PYTHON_METHOD(ptGUIControlListBox, addImageInBox, "Params: image,x,y,width,height,respectAlpha\nAppends an image item to the listbox, centering within the box dimension."),
    PYTHON_METHOD(ptGUIControlListBox, addStringWithColor, "Params: text,color,inheritAlpha\nAdds a colored string to the list box"),
    PYTHON_METHOD(ptGUIControlListBox, addStringWithColorWithSize, "Params: text,color,inheritAlpha,fontsize\nAdds a text list item with a color and different font size"),
    PYTHON_METHOD(ptGUIControlListBox, add2StringsWithColors, "Params: text1,color1,text2,color2,respectAlpha\nDoesn't work right - DONT USE"),
    PYTHON_METHOD(ptGUIControlListBox, addStringInBox, "Params: text,min_width,min_height\nAdds a text list item that has a minimum width and height"),
    PYTHON_BASIC_METHOD(ptGUIControlListBox, scrollToBegin, "Scrolls the listbox to the beginning of the list"),
    PYTHON_BASIC_METHOD(ptGUIControlListBox, scrollToEnd, "Scrolls the listbox to the end of the list"),
    PYTHON_METHOD(ptGUIControlListBox, setScrollPos, "Params: pos\nSets the scroll position of the listbox to 'pos'"),
    PYTHON_METHOD_NOARGS(ptGUIControlListBox, getScrollPos, "Returns the current scroll position in the listbox."),
    PYTHON_METHOD_NOARGS(ptGUIControlListBox, getScrollRange, "Returns the max scroll position"),
    PYTHON_BASIC_METHOD(ptGUIControlListBox, lock, "Locks the updates to a listbox, so a number of operations can be performed\n"
                "NOTE: an unlock() call must be made before the next lock() can be."),
    PYTHON_BASIC_METHOD(ptGUIControlListBox, unlock, "Unlocks updates to a listbox and does any saved up changes"),
    PYTHON_METHOD(ptGUIControlListBox, addBranch, "Params: name,initiallyOpen\nUNKNOWN"),
    PYTHON_METHOD(ptGUIControlListBox, addBranchW, "Params: name,initiallyOpen\nUnicode version of addBranch"),
    PYTHON_BASIC_METHOD(ptGUIControlListBox, closeBranch, "UNKNOWN"),
    PYTHON_METHOD(ptGUIControlListBox, removeSelection, "Params: item\nRemoves item from selection list"),
    PYTHON_METHOD(ptGUIControlListBox, addSelection, "Params: item\nAdds item to selection list"),
    PYTHON_METHOD(ptGUIControlListBox, getSelectionList, "Returns the current selection list"),
    PYTHON_METHOD(ptGUIControlListBox, addImageAndSwatchesInBox, "Params: image,x,y,width,height,respectAlpha,primary,secondary\nAdd the image and color swatches to the list"),
    PYTHON_METHOD(ptGUIControlListBox, setGlobalSwatchSize, "Params: size\nSets the size of the color swatches"),
    PYTHON_METHOD(ptGUIControlListBox, setGlobalSwatchEdgeOffset, "Params: offset\nSets the edge offset of the color swatches"),
    PYTHON_BASIC_METHOD(ptGUIControlListBox, allowNoSelect, "Allows the listbox to have no selection"),
    PYTHON_BASIC_METHOD(ptGUIControlListBox, disallowNoSelect, "The listbox must always have a selection"),
    PYTHON_METHOD_NOARGS(ptGUIControlListBox, getBranchList, "get a list of branches in this list (index,isShowingChildren)"),
PYTHON_END_METHODS_TABLE;

// Type structure definition
PLASMA_DEFAULT_TYPE_WBASE(ptGUIControlListBox, pyGUIControl, "Params: ctrlKey\nPlasma GUI Control List Box class");

// required functions for PyObject interoperability
PyObject *pyGUIControlListBox::New(pyKey& gckey)
{
    ptGUIControlListBox *newObj = (ptGUIControlListBox*)ptGUIControlListBox_type.tp_new(&ptGUIControlListBox_type, NULL, NULL);
    newObj->fThis->fGCkey = gckey.getKey();
    return (PyObject*)newObj;
}

PyObject *pyGUIControlListBox::New(plKey objkey)
{
    ptGUIControlListBox *newObj = (ptGUIControlListBox*)ptGUIControlListBox_type.tp_new(&ptGUIControlListBox_type, NULL, NULL);
    newObj->fThis->fGCkey = objkey;
    return (PyObject*)newObj;
}

PYTHON_CLASS_CHECK_IMPL(ptGUIControlListBox, pyGUIControlListBox)
PYTHON_CLASS_CONVERT_FROM_IMPL(ptGUIControlListBox, pyGUIControlListBox)

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