2640 lines
74 KiB
C++
2640 lines
74 KiB
C++
/* -----------------------------------------------------------------------------
|
|
GSFramework
|
|
Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
|
|
----------------------------------------------------------------------------- */
|
|
|
|
|
|
#include "squirrel_binding.h"
|
|
#include "binding_helpers.h"
|
|
#include "script_squirrel/cobject/matrix_decl.h"
|
|
#include "ui/ui.h"
|
|
#include "ui/ui_ace_manager.h"
|
|
#include "ui/ui_cursor.h"
|
|
#include "ui/ui_camera.h"
|
|
#include "ui/widget_canvas.h"
|
|
#include "ui/widget_check.h"
|
|
#include "ui/widget_sizer.h"
|
|
#include "ui/widget_spacer.h"
|
|
#include "ui/widget_staticcontainer.h"
|
|
#include "ui/ui_window.h"
|
|
#include "scene3d/scene.h"
|
|
#include "core/renderer.h"
|
|
#include "script/scripted_object.h"
|
|
#include "script/script_unit.h"
|
|
|
|
#include "picture/pict_io.h"
|
|
using namespace GS;
|
|
using namespace GS::S2D;
|
|
using namespace GS::Script;
|
|
|
|
|
|
static CObjectType item_derived_types[] = { typetag_UIItem, typetag_UISprite, typetag_Window, typetag_Undefined };
|
|
static CObjectType sprite_derived_types[] = { typetag_UISprite, typetag_Window, typetag_Undefined };
|
|
|
|
Widget *GetWidget(HSQUIRRELVM vm , int idx);
|
|
#define __SQ_ASSERTSPRITEISWINDOW(__V__) if (__V__->GetItemType() != S2D::Item::Type_Window) return sq_throwerror(vm, "Sprite is not a window");
|
|
|
|
//
|
|
|
|
SQInteger WebcamTextureBlit(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTRALLOWNULL(t, Render::Texture, typetag_Texture)
|
|
__SQ_GETINT(i)
|
|
t->Blit((char*)(i), 640, 480, 0U, 0U, Render::Texture::FormatRGBA8);
|
|
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
SQInteger UIFromNML(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene2d)
|
|
__SQ_GETSTRING(path)
|
|
Group *group = NULL;
|
|
if (!scene->FromMetaFileStoreGroup(path, &group))
|
|
return sq_throwerror(vm, "Failed to load scene.");
|
|
// scene->InstanceSetup();
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(group, typetag_Group)
|
|
}
|
|
SQInteger UIFromNMLStoreGroup(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene2d)
|
|
__SQ_GETSTRING(path)
|
|
__SQ_GETINT(flag)
|
|
Group *group = NULL;
|
|
if (!scene->FromMetaFileStoreGroup(path, &group, flag))
|
|
return sq_throwerror(vm, "Failed to load scene.");
|
|
// scene->InstanceSetup();
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(group, typetag_Group)
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger WindowCompare(HSQUIRRELVM vm)
|
|
{
|
|
Sprite *wa, *wb;
|
|
if (!CObject::Get(vm, -2, (void **)&wa, typetag_Window))
|
|
return -1;
|
|
if (!CObject::Get(vm, -1, (void **)&wb, typetag_Window))
|
|
return -1;
|
|
sq_pop(vm, 2);
|
|
|
|
sq_pushbool(vm, wa == wb ? true : false);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger SceneGetUI(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(scene, S3D::Scene, typetag_Scene3d)
|
|
__SQ_RETURNSAFEPTR(scene->ui.c_ptr(), typetag_Scene2d)
|
|
}
|
|
|
|
SQInteger UIRenderSetup(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_GETSAFEPTR(f, Core::ResourceFactories, typetag_ResourceFactories)
|
|
__SQ_GETEND
|
|
ui->RenderSetup(f);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger UISetVirtualResolution(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETSAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_GETINT(w)
|
|
__SQ_GETINT(h)
|
|
__SQ_GETEND
|
|
ui->GetDefaultCamera()->resolution.Set((float)w, (float)h);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger UIGetVirtualResolution(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_RETURNVECTOR2(Vector2(ui->GetDefaultCamera()->resolution.x, ui->GetDefaultCamera()->resolution.y))
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger UIGetScreenToUIMatrix(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_RETURNMATRIX3(ui->GetScreenToUIMatrix())
|
|
}
|
|
SQInteger UIGetUIToScreenMatrix(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_RETURNMATRIX3(ui->GetUIToScreenMatrix())
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger UIItemCastToSprite(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(i, Item, typetag_UIItem)
|
|
if (i->GetItemType() != Item::Type_Sprite)
|
|
return sq_throwerror(vm, "UI item cannot be cast to sprite.");
|
|
__SQ_RETURNSAFEPTR((Sprite *)i, typetag_UISprite)
|
|
}
|
|
SQInteger UIItemCastToWindow(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(i, Item, typetag_UIItem)
|
|
if (i->GetItemType() != Item::Type_Window)
|
|
return sq_throwerror(vm, "UI item cannot be cast to window.");
|
|
__SQ_RETURNSAFEPTR((Window *)i, typetag_Window)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger UILockToSprite(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_GETSAFEPTR(sprite, Sprite, typetag_Window)
|
|
__SQ_GETEND
|
|
ui->Lock(sprite);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger UIUnlock(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(ui, Scene, typetag_Scene2d)
|
|
ui->Unlock();
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger UISetCommandList(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_GETSTRING(list)
|
|
ACEManager::Get()->LoadACECommandList(list, ui);
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger UIIsCommandListDone(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_RETURNBOOL(ui->IsCommandListDone())
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger UICursorGetWindowBelow(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(cursor, Cursor, typetag_UICursor)
|
|
Window *w = NULL;
|
|
if (Item *i = cursor->current_state.item)
|
|
w = i->GetItemType() == Item::Type_Window ? (Window *)i : NULL;
|
|
if (w == NULL)
|
|
__SQ_RETURNNULL
|
|
__SQ_RETURNSAFEPTR(w, typetag_Window)
|
|
}
|
|
SQInteger UICursorGetSpriteBelow(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(cursor, Cursor, typetag_UICursor)
|
|
Sprite *s = NULL;
|
|
if (Item *i = cursor->current_state.item)
|
|
s = i->GetItemType() == Item::Type_Sprite ? (Sprite *)i : NULL;
|
|
if (s == NULL)
|
|
__SQ_RETURNNULL
|
|
__SQ_RETURNSAFEPTR(s, typetag_UISprite)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger UISetGlobalFadeEffect(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_GETFLOAT(fade)
|
|
__SQ_GETEND
|
|
ui->SetGlobalFadeEffect(fade);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger UISetGlobalFadeColor(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(4)
|
|
__SQ_GETSAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_GETINT(r)
|
|
__SQ_GETINT(g)
|
|
__SQ_GETINT(b)
|
|
__SQ_GETEND
|
|
ui->global_fade_color.x = (float)r / 255.f;
|
|
ui->global_fade_color.y = (float)g / 255.f;
|
|
ui->global_fade_color.z = (float)b / 255.f;
|
|
__SQ_RETURN
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger UIWindowCentre(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_GETCOBJECTBASE(item, S2D::Item, item_derived_types)
|
|
__SQ_GETEND
|
|
Vector2 pos = (ui->GetCurrentCamera()->resolution - item->GetSize()) * 0.5f + item->GetPivot();
|
|
item->SetPosition(pos.x, pos.y);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger WindowSetParent(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(w, Sprite, typetag_Window)
|
|
__SQ_GETSAFEPTRALLOWNULL(p, Sprite, typetag_Window)
|
|
__SQ_GETEND
|
|
w->SetParent(p);
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger WindowSetCommandList(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(sprite, Sprite, sprite_derived_types)
|
|
__SQ_GETSTRING(list)
|
|
ACEManager::Get()->LoadACECommandList(list, sprite);
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger WindowIsCommandListDone(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(sprite, Sprite, sprite_derived_types))
|
|
__SQ_RETURNBOOL(sprite->IsCommandListDone())
|
|
}
|
|
SQInteger WindowResetCommandList(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(sprite, Sprite, sprite_derived_types))
|
|
sprite->ResetCommandList();
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger WindowSetPosition(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, S2D::Item, item_derived_types)
|
|
__SQ_GETFLOAT(x)
|
|
__SQ_GETFLOAT(y)
|
|
__SQ_GETEND
|
|
item->SetPosition(x, y);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger WindowSetRotation(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, S2D::Item, item_derived_types)
|
|
__SQ_GETFLOAT(a)
|
|
__SQ_GETEND
|
|
item->SetRotation(a);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger WindowSetScale(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, S2D::Item, item_derived_types)
|
|
__SQ_GETFLOAT(x)
|
|
__SQ_GETFLOAT(y)
|
|
__SQ_GETEND
|
|
item->SetScale(x, y);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger WindowSetPivot(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, S2D::Item, item_derived_types)
|
|
__SQ_GETFLOAT(x)
|
|
__SQ_GETFLOAT(y)
|
|
__SQ_GETEND
|
|
item->SetPivot(x, y);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger WindowSetSize(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(item, S2D::Item, item_derived_types)
|
|
__SQ_GETFLOAT(x)
|
|
__SQ_GETFLOAT(y)
|
|
__SQ_GETEND
|
|
item->SetSize(x, y);
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger WindowGetPosition(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, S2D::Item, item_derived_types))
|
|
__SQ_RETURNVECTOR2(item->GetPosition())
|
|
}
|
|
SQInteger WindowGetPivot(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, S2D::Item, item_derived_types))
|
|
__SQ_RETURNVECTOR2(item->GetPivot())
|
|
}
|
|
SQInteger WindowGetSize(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, S2D::Item, item_derived_types))
|
|
__SQ_RETURNVECTOR2(item->GetSize())
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger WindowGetRect(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, S2D::Item, item_derived_types))
|
|
__SQ_RETURNRECT(item->GetRect())
|
|
}
|
|
SQInteger WindowGetScreenRect(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, S2D::Item, item_derived_types))
|
|
__SQ_RETURNRECT(item->GetScreenRect())
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger WindowGetName(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, S2D::Item, item_derived_types))
|
|
__SQ_RETURNSTRING(item->name.c_str())
|
|
}
|
|
SQInteger WindowGetTitle(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(w, Sprite, typetag_Window)
|
|
__SQ_ASSERTSPRITEISWINDOW(w)
|
|
|
|
Widget *title = ((Window *)w)->GetTitleWidget();
|
|
if (title->GetType() != WidgetTypeText)
|
|
return sq_throwerror(vm, "Window title widget is not a text widget.");
|
|
|
|
TextWidget *text = (TextWidget *)title;
|
|
__SQ_RETURNSTRING(text->GetText())
|
|
}
|
|
SQInteger WindowSetTitle(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(w, Sprite, typetag_Window)
|
|
__SQ_GETSTRING(title_string)
|
|
|
|
__SQ_ASSERTSPRITEISWINDOW(w)
|
|
|
|
Widget *title = ((Window *)w)->GetTitleWidget();
|
|
if (title->GetType() != WidgetTypeText)
|
|
return sq_throwerror(vm, "Window title widget is not a text widget.");
|
|
|
|
TextWidget *text = (TextWidget *)title;
|
|
text->SetText(title_string);
|
|
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger WindowGetParent(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, S2D::Item, item_derived_types))
|
|
__SQ_RETURNSAFEPTR(item->GetParent(), typetag_UIItem)
|
|
}
|
|
|
|
SQInteger WindowGetChild(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(s, Sprite, typetag_Window)
|
|
__SQ_GETINT(id)
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(s->GetItemType() == S2D::Item::Type_Window ? ((Window *)s)->GetWidget(id) : NULL, typetag_Widget)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger WindowSetZOrder(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(item, S2D::Item, item_derived_types)
|
|
__SQ_GETFLOAT(z)
|
|
__SQ_GETEND
|
|
item->SetZOrder(z);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger WindowGetZOrder(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(item, S2D::Item, item_derived_types))
|
|
__SQ_RETURNFLOAT(item->GetZOrder())
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger WindowSetFlip(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETCOBJECTBASE(sprite, Sprite, sprite_derived_types)
|
|
__SQ_GETBOOL(u)
|
|
__SQ_GETBOOL(v)
|
|
__SQ_GETEND
|
|
sprite->sprite_flags.Raise(Sprite::FlagFlipU, asbool(u));
|
|
sprite->sprite_flags.Raise(Sprite::FlagFlipV, asbool(v));
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger WindowSetOpacity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(sprite, Sprite, sprite_derived_types)
|
|
__SQ_GETFLOAT(o)
|
|
__SQ_GETEND
|
|
sprite->opacity = o;
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger WindowGetOpacity(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(sprite, Sprite, sprite_derived_types))
|
|
__SQ_RETURNFLOAT(sprite->opacity)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger WindowGetStyle(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETCOBJECTBASE(sprite, Sprite, sprite_derived_types))
|
|
__SQ_RETURNINT(sprite->sprite_flags.Get())
|
|
}
|
|
SQInteger WindowSetStyle(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(sprite, Sprite, sprite_derived_types)
|
|
__SQ_GETINT(v)
|
|
__SQ_GETEND
|
|
sprite->sprite_flags = v;
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger WindowAddStyle(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(sprite, Sprite, sprite_derived_types)
|
|
__SQ_GETINT(v)
|
|
__SQ_GETEND
|
|
sprite->sprite_flags.Set(v);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger WindowRemoveStyle(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(sprite, Sprite, sprite_derived_types)
|
|
__SQ_GETINT(v)
|
|
__SQ_GETEND
|
|
sprite->sprite_flags.Remove(v);
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger WindowGetBackgroundPicture(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(w, Sprite, typetag_Window)
|
|
__SQ_ASSERTSPRITEISWINDOW(w)
|
|
__SQ_RETURNSAFEPTR(((Window *)w)->background_picture, typetag_Picture)
|
|
}
|
|
SQInteger WindowSetBackgroundPicture(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(w, Sprite, typetag_Window)
|
|
__SQ_ASSERTSPRITEISWINDOW(w)
|
|
__SQ_GETSAFEPTR(p, Picture, typetag_Picture)
|
|
__SQ_GETEND
|
|
((Window *)w)->background_picture = p;
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger WindowSetBackgroundColor(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(w, Sprite, typetag_Window)
|
|
__SQ_ASSERTSPRITEISWINDOW(w)
|
|
__SQ_GETINT(icolor)
|
|
__SQ_GETEND
|
|
((Window *)w)->background_color = Color(uint(icolor));
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger UIDeleteWindow(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_GETSAFEPTR(s, Sprite, typetag_Window)
|
|
__SQ_GETEND
|
|
ui->RemoveItem(s);
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger UIDeleteAllItems(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(ui, Scene, typetag_Scene2d)
|
|
ui->DeleteAllItems();
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger UIAddSprite(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(7)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene2d)
|
|
__SQ_GETINT(idx)
|
|
__SQ_GETSAFEPTRALLOWNULL(t, Render::Texture, typetag_Texture)
|
|
__SQ_GETFLOAT(px)
|
|
__SQ_GETFLOAT(py)
|
|
__SQ_GETFLOAT(sx)
|
|
__SQ_GETFLOAT(sy)
|
|
Sprite *s = new Sprite;
|
|
if (!s)
|
|
return sq_throwerror(vm, "Failed to allocate sprite.");
|
|
s->name = String::Format("%d", idx);
|
|
s->SetPosition(px, py);
|
|
s->SetSize(sx, sy);
|
|
s->RenderSetup();
|
|
s->render_data->texture = t;
|
|
scene->AddItem(s, true);
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(s, typetag_Window)
|
|
}
|
|
SQInteger UIAddNamedSprite(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(7)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene2d)
|
|
__SQ_GETSTRING(name)
|
|
__SQ_GETSAFEPTRALLOWNULL(t, Render::Texture, typetag_Texture)
|
|
__SQ_GETFLOAT(px)
|
|
__SQ_GETFLOAT(py)
|
|
__SQ_GETFLOAT(sx)
|
|
__SQ_GETFLOAT(sy)
|
|
Sprite *s = new Sprite;
|
|
s->name = name;
|
|
s->SetPosition(px, py);
|
|
s->SetSize(sx, sy);
|
|
scene->AddItem(s, true);
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(s, typetag_Window)
|
|
}
|
|
SQInteger SpriteSetTexture(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(s, Sprite, typetag_Window)
|
|
__SQ_GETSAFEPTRALLOWNULL(t, Render::Texture, typetag_Texture)
|
|
if (!s->render_data)
|
|
return sq_throwerror(vm, "Sprite not setup, please call SpriteRenderSetup() before changing its texture.");
|
|
s->render_data->texture = t;
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger SpriteSetUVOrigin(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETSAFEPTR(s, Sprite, typetag_Window)
|
|
__SQ_GETFLOAT(x)
|
|
__SQ_GETFLOAT(y)
|
|
__SQ_GETEND
|
|
s->uv_origin.Set(x, y);
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger SpriteRenderSetup(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(s, Sprite, sprite_derived_types)
|
|
__SQ_GETSAFEPTRALLOWNULL(f, Core::ResourceFactories, typetag_ResourceFactories)
|
|
__SQ_GETEND
|
|
s->RenderSetup(f);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SpriteSetTextureMatrix(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETCOBJECTBASE(s, Sprite, sprite_derived_types)
|
|
__SQ_GETMATRIX3(m)
|
|
__SQ_GETEND
|
|
s->uv_matrix = m;
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger UIAddNamedWindow(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(6)
|
|
__SQ_GETSAFEPTR(scene, Scene, typetag_Scene2d)
|
|
__SQ_GETSTRING(name)
|
|
__SQ_GETFLOAT(px)
|
|
__SQ_GETFLOAT(py)
|
|
__SQ_GETFLOAT(sx)
|
|
__SQ_GETFLOAT(sy)
|
|
Window *w = new Window;
|
|
w->name = name;
|
|
w->SetPosition(px, py);
|
|
w->SetSize(sx, sy);
|
|
scene->AddItem(w, true);
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(w, typetag_Window)
|
|
}
|
|
SQInteger UIAddNamedBitmapWindow(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(7)
|
|
__SQ_GETSAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_GETSTRING(name)
|
|
__SQ_GETSAFEPTRALLOWNULL(bitmap, Picture, typetag_Picture)
|
|
__SQ_GETFLOAT(px)
|
|
__SQ_GETFLOAT(py)
|
|
__SQ_GETFLOAT(sx)
|
|
__SQ_GETFLOAT(sy)
|
|
Window *w = new Window;
|
|
w->name = name;
|
|
w->SetPosition(px, py);
|
|
w->SetSize(sx, sy);
|
|
w->background_picture = bitmap;
|
|
ui->AddItem(w, true);
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(w, typetag_Window)
|
|
}
|
|
SQInteger WindowGetCacheTexture(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(w, Sprite, typetag_Window)
|
|
__SQ_ASSERTSPRITEISWINDOW(w)
|
|
__SQ_RETURNSAFEPTR(((Window *)w)->GetCache(), typetag_Texture);
|
|
}
|
|
|
|
SQInteger WindowSetBaseWidget(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(sprite, Sprite, typetag_Window)
|
|
Widget *widget = GetWidget(vm, __sq_stackpos);
|
|
__SQ_GETUPDATESTACK
|
|
__SQ_GETEND
|
|
|
|
if (sprite->GetItemType() == S2D::Item::Type_Window)
|
|
if (Window *window = (Window *)sprite)
|
|
window->SetBaseWidget(widget);
|
|
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger WindowForceLayout(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(w, Sprite, typetag_Window)
|
|
// wnd->Render(NULL);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger WindowInvalidate(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(wnd, Sprite, typetag_Window)
|
|
__SQ_ASSERTSPRITEISWINDOW(wnd)
|
|
((Window *)wnd)->Invalidate();
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger UISetSkin(HSQUIRRELVM vm)
|
|
{
|
|
Scene *sys;
|
|
if (!CObject::Get(vm, -16, (void **)&sys, typetag_Scene2d))
|
|
return sq_throwerror(vm, "Invalid UI");
|
|
|
|
Core::ResourceFactories *f;
|
|
if (!CObject::Get(vm, -15, (void **)&f, typetag_ResourceFactories))
|
|
return sq_throwerror(vm, "Invalid resource factory.");
|
|
|
|
const char *l, *r, *t, *b, *tl, *tr, *bl, *br;
|
|
sq_getstring(vm, -14, &t);
|
|
sq_getstring(vm, -13, &l);
|
|
sq_getstring(vm, -12, &r);
|
|
sq_getstring(vm, -11, &b);
|
|
sq_getstring(vm, -10, &tl);
|
|
sq_getstring(vm, -9, &tr);
|
|
sq_getstring(vm, -8, &bl);
|
|
sq_getstring(vm, -7, &br);
|
|
|
|
SQInteger skin_color;
|
|
sq_getinteger(vm, -6, &skin_color);
|
|
|
|
SQInteger skin_title_color, skin_title_top, skin_title_bottom, skin_title_size;
|
|
sq_getinteger(vm, -5, &skin_title_color);
|
|
sq_getinteger(vm, -4, &skin_title_top);
|
|
sq_getinteger(vm, -3, &skin_title_bottom);
|
|
sq_getinteger(vm, -2, &skin_title_size);
|
|
|
|
const char *skin_title_font;
|
|
sq_getstring(vm, -1, &skin_title_font);
|
|
|
|
sys->window_skin = new WindowSkin;
|
|
|
|
sys->window_skin->top = f->graphic->LoadPicture(t);
|
|
sys->window_skin->left = f->graphic->LoadPicture(l);
|
|
sys->window_skin->right = f->graphic->LoadPicture(r);
|
|
sys->window_skin->bottom = f->graphic->LoadPicture(b);
|
|
sys->window_skin->top_left = f->graphic->LoadPicture(tl);
|
|
sys->window_skin->top_right = f->graphic->LoadPicture(tr);
|
|
sys->window_skin->bottom_left = f->graphic->LoadPicture(bl);
|
|
sys->window_skin->bottom_right = f->graphic->LoadPicture(br);
|
|
|
|
sys->window_skin->color = skin_color;
|
|
sys->window_skin->title_color = skin_title_color;
|
|
sys->window_skin->title_top = skin_title_top;
|
|
sys->window_skin->title_bottom = skin_title_bottom;
|
|
sys->window_skin->title_size = skin_title_size;
|
|
// sys->window_skin->title_font = skin_title_font;
|
|
|
|
sq_pop(vm, 15);
|
|
|
|
sq_pushbool(vm, true);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger UIAddCanvasWidget(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(4)
|
|
__SQ_GETSAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_GETINT(id)
|
|
__SQ_GETINT(w)
|
|
__SQ_GETINT(h)
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(new CanvasWidget((int)id, (int)w, (int)h), typetag_CanvasWidget)
|
|
}
|
|
|
|
SQInteger CanvasWidgetLock(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(c, CanvasWidget, typetag_CanvasWidget)
|
|
__SQ_RETURNSAFEPTR(c->Lock(), typetag_Picture)
|
|
}
|
|
|
|
SQInteger CanvasWidgetUnlock(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(c, CanvasWidget, typetag_CanvasWidget)
|
|
c->Unlock();
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger UIAddSpacerWidget(HSQUIRRELVM vm)
|
|
{
|
|
Scene *ws;
|
|
if (!CObject::Get(vm, -2, (void **)&ws, typetag_Scene2d))
|
|
return -1;
|
|
SQInteger id;
|
|
sq_getinteger(vm, -1, &id);
|
|
sq_pop(vm, 2);
|
|
|
|
SpacerWidget *wd = NULL;
|
|
if (ws)
|
|
wd = new SpacerWidget((int)id);
|
|
CObject::Push(vm, wd, typetag_SpacerWidget);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger UIAddHorizontalSizerWidget(HSQUIRRELVM vm)
|
|
{
|
|
Scene *ws;
|
|
if (!CObject::Get(vm, -2, (void **)&ws, typetag_Scene2d))
|
|
return -1;
|
|
SQInteger id;
|
|
sq_getinteger(vm, -1, &id);
|
|
sq_pop(vm, 2);
|
|
|
|
SizerWidget *wd = NULL;
|
|
if (ws)
|
|
wd = new HSizerWidget((int)id);
|
|
CObject::Push(vm, wd, typetag_SizerWidget);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger UIAddVerticalSizerWidget(HSQUIRRELVM vm)
|
|
{
|
|
Scene *ws;
|
|
if (!CObject::Get(vm, -2, (void **)&ws, typetag_Scene2d))
|
|
return -1;
|
|
SQInteger id;
|
|
sq_getinteger(vm, -1, &id);
|
|
sq_pop(vm, 2);
|
|
|
|
SizerWidget *wd = NULL;
|
|
if (ws)
|
|
wd = new VSizerWidget((int)id);
|
|
CObject::Push(vm, wd, typetag_SizerWidget);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger UIAddContainerWidget(HSQUIRRELVM vm)
|
|
{
|
|
Scene *ws;
|
|
if (!CObject::Get(vm, -2, (void **)&ws, typetag_Scene2d))
|
|
return -1;
|
|
SQInteger id;
|
|
sq_getinteger(vm, -1, &id);
|
|
sq_pop(vm, 2);
|
|
|
|
ContainerWidget *wd = NULL;
|
|
if (ws)
|
|
wd = new ContainerWidget((int)id);
|
|
CObject::Push(vm, wd, typetag_ContainerWidget);
|
|
return 1;
|
|
}
|
|
|
|
Widget *GetWidget(HSQUIRRELVM vm , int idx)
|
|
{
|
|
Widget *wdg = NULL;
|
|
CObjectType type;
|
|
|
|
if (!CObject::GetType(vm, idx, type))
|
|
return NULL;
|
|
|
|
switch (type)
|
|
{
|
|
case typetag_Widget:
|
|
CObject::Get(vm, idx, (void **)&wdg, typetag_Widget);
|
|
break;
|
|
case typetag_SizerWidget:
|
|
CObject::Get(vm, idx, (void **)&wdg, typetag_SizerWidget);
|
|
break;
|
|
case typetag_CheckWidget:
|
|
CObject::Get(vm, idx, (void **)&wdg, typetag_CheckWidget);
|
|
break;
|
|
case typetag_ContainerWidget:
|
|
CObject::Get(vm, idx, (void **)&wdg, typetag_ContainerWidget);
|
|
break;
|
|
case typetag_SpacerWidget:
|
|
CObject::Get(vm, idx, (void **)&wdg, typetag_SpacerWidget);
|
|
break;
|
|
case typetag_TextWidget:
|
|
CObject::Get(vm, idx, (void **)&wdg, typetag_TextWidget);
|
|
break;
|
|
case typetag_CanvasWidget:
|
|
CObject::Get(vm, idx, (void **)&wdg, typetag_CanvasWidget);
|
|
break;
|
|
case typetag_BitmapWidget:
|
|
CObject::Get(vm, idx, (void **)&wdg, typetag_BitmapWidget);
|
|
break;
|
|
|
|
default:
|
|
sq_throwerror(vm, "Object is not a widget");
|
|
return NULL;
|
|
}
|
|
|
|
if (!wdg)
|
|
{
|
|
sq_throwerror(vm, "Widget is null");
|
|
return NULL;
|
|
}
|
|
return wdg;
|
|
}
|
|
|
|
#define __SQ_GETWIDGET(__VAR__) Widget *__VAR__ = GetWidget(vm, __sq_stackpos); __SQ_GETUPDATESTACK if (!__VAR__) return -1;
|
|
|
|
SQInteger CastToWidget(HSQUIRRELVM vm)
|
|
{
|
|
Widget *wdg = GetWidget(vm, -1);
|
|
if (!wdg)
|
|
return -1;
|
|
sq_pop(vm, 1);
|
|
__SQ_RETURNSAFEPTR(wdg, typetag_Widget)
|
|
}
|
|
|
|
SQInteger UIDeleteWidget(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_GETWIDGET(w)
|
|
__SQ_GETEND
|
|
if (ui && w) _safe_delete(w);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SizerAddWidget(HSQUIRRELVM vm)
|
|
{
|
|
SizerWidget *ws;
|
|
if (!CObject::Get(vm, -2, (void **)&ws, typetag_SizerWidget))
|
|
return -1;
|
|
CObjectType widget_type;
|
|
if (!CObject::GetType(vm, -1, widget_type))
|
|
return -1;
|
|
|
|
Widget *wdg = GetWidget(vm, -1);
|
|
if (!wdg)
|
|
return -1;
|
|
sq_pop(vm, 2);
|
|
|
|
if (ws && wdg)
|
|
ws->Add(wdg);
|
|
|
|
CObject::Push(vm, wdg, widget_type);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger ContainerAddWidget(HSQUIRRELVM vm)
|
|
{
|
|
ContainerWidget *ws;
|
|
if (!CObject::Get(vm, -6, (void **)&ws, typetag_ContainerWidget))
|
|
return -1;
|
|
|
|
CObjectType widget_type;
|
|
if (!CObject::GetType(vm, -5, widget_type))
|
|
return -1;
|
|
Widget *wdg = GetWidget(vm, -5);
|
|
if (!wdg)
|
|
return -1;
|
|
|
|
float sx, sy, w, h;
|
|
sq_getfloat(vm, -4, &sx);
|
|
sq_getfloat(vm, -3, &sy);
|
|
sq_getfloat(vm, -2, &w);
|
|
sq_getfloat(vm, -1, &h);
|
|
sq_pop(vm, 6);
|
|
|
|
if (ws && wdg)
|
|
{
|
|
iRect cell_rect((int)sx, (int)sy, (int)(sx + w), (int)(sy + h));
|
|
ws->Add(wdg, cell_rect);
|
|
}
|
|
CObject::Push(vm, wdg, widget_type);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger ContainerWidgetSetPosition(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(4)
|
|
__SQ_GETSAFEPTR(ws, ContainerWidget, typetag_ContainerWidget)
|
|
__SQ_GETWIDGET(wdg)
|
|
__SQ_GETFLOAT(x)
|
|
__SQ_GETFLOAT(y)
|
|
__SQ_GETEND
|
|
|
|
ContainerCell *cell = ws->GetCell(wdg);
|
|
if (!cell)
|
|
return sq_throwerror(vm, "Widget not in container");
|
|
|
|
cell->cell_rect.Offset(int(x - cell->cell_rect.sx), int(y - cell->cell_rect.sy));
|
|
ws->Invalidate();
|
|
|
|
__SQ_RETURN
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger WidgetSetEventHandler(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
Widget *widget = GetWidget(vm, __sq_stackpos);
|
|
__SQ_GETUPDATESTACK
|
|
if (!widget)
|
|
return sq_throwerror(vm, "Null widget");
|
|
__SQ_GETINT(event)
|
|
__SQ_GETOBJECT(handler)
|
|
__SQ_GETEND
|
|
widget->GetEventTable()->SetHandler((EventCode)event, new Script::SquirrelObject(*GetVMObject(vm), handler));
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger WidgetSetEventHandlerWithContext(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(4)
|
|
Widget *widget = GetWidget(vm, __sq_stackpos);
|
|
__SQ_GETUPDATESTACK
|
|
if (!widget)
|
|
return sq_throwerror(vm, "Null widget");
|
|
__SQ_GETINT(event)
|
|
__SQ_GETOBJECT(context)
|
|
__SQ_GETOBJECT(handler)
|
|
__SQ_GETEND
|
|
widget->GetEventTable()->SetHandler((EventCode)event, new Script::SquirrelObject(*GetVMObject(vm), handler), new Script::SquirrelObject(*GetVMObject(vm), context));
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger WindowSetEventHandler(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(3)
|
|
__SQ_GETSAFEPTR(window, Sprite, typetag_Window)
|
|
__SQ_GETINT(event)
|
|
__SQ_GETOBJECT(handler)
|
|
__SQ_GETEND
|
|
window->GetEventTable()->SetHandler((EventCode)event, new Script::SquirrelObject(*GetVMObject(vm), handler));
|
|
__SQ_RETURN
|
|
}
|
|
SQInteger WindowSetEventHandlerWithContext(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(4)
|
|
__SQ_GETSAFEPTR(window, Sprite, typetag_Window)
|
|
__SQ_GETINT(event)
|
|
__SQ_GETOBJECT(context)
|
|
__SQ_GETOBJECT(handler)
|
|
__SQ_GETEND
|
|
window->GetEventTable()->SetHandler((EventCode)event, new Script::SquirrelObject(*GetVMObject(vm), handler), new Script::SquirrelObject(*GetVMObject(vm), context));
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
SQInteger WidgetSetSensitive(HSQUIRRELVM vm)
|
|
{
|
|
Widget *w = GetWidget(vm, -2);
|
|
if (!w)
|
|
return -1;
|
|
SQBool bs;
|
|
sq_getbool(vm, -1, &bs);
|
|
|
|
w->GetEventTable()->Enable(bs ? true : false);
|
|
sq_pop(vm, 2);
|
|
return 0;
|
|
}
|
|
|
|
SQInteger WidgetSetHAlign(HSQUIRRELVM vm)
|
|
{
|
|
Widget *w = GetWidget(vm, -2);
|
|
if (!w)
|
|
return -1;
|
|
SQInteger a;
|
|
sq_getinteger(vm, -1, &a);
|
|
sq_pop(vm, 2);
|
|
|
|
w->SetHAlign((Widget::Align)a);
|
|
return 0;
|
|
}
|
|
|
|
SQInteger WidgetSetVAlign(HSQUIRRELVM vm)
|
|
{
|
|
Widget *wdg = GetWidget(vm, -2);
|
|
if (!wdg)
|
|
return -1;
|
|
SQInteger a;
|
|
sq_getinteger(vm, -1, &a);
|
|
sq_pop(vm, 2);
|
|
|
|
wdg->SetVAlign((Widget::Align)a);
|
|
return 0;
|
|
}
|
|
|
|
SQInteger WidgetSetHidden(HSQUIRRELVM vm)
|
|
{
|
|
Widget *wdg = GetWidget(vm, -2);
|
|
if (!wdg)
|
|
return -1;
|
|
SQBool hidden;
|
|
sq_getbool(vm, -1, &hidden);
|
|
sq_pop(vm, 2);
|
|
|
|
wdg->SetHidden(hidden ? true : false);
|
|
return 0;
|
|
}
|
|
|
|
SQInteger WidgetGetRect(HSQUIRRELVM vm)
|
|
{
|
|
Widget *wdg = GetWidget(vm, -1);
|
|
if (!wdg)
|
|
return -1;
|
|
sq_pop(vm, 1);
|
|
|
|
iRect rect(-1, -1, -1, -1);
|
|
rect = wdg->GetRect();
|
|
PushRect(vm, rect);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger WidgetIsHidden(HSQUIRRELVM vm)
|
|
{
|
|
Widget *wdg = GetWidget(vm, -1);
|
|
if (!wdg)
|
|
return -1;
|
|
sq_pop(vm, 1);
|
|
__SQ_RETURNBOOL(wdg->IsHidden())
|
|
}
|
|
|
|
SQInteger WidgetSetFormattingSize(HSQUIRRELVM vm)
|
|
{
|
|
Widget *wdg = GetWidget(vm, -3);
|
|
if (!wdg)
|
|
return -1;
|
|
SQFloat h, v;
|
|
sq_getfloat(vm, -2, &h);
|
|
sq_getfloat(vm, -1, &v);
|
|
sq_pop(vm, 3);
|
|
|
|
wdg->SetFormattingSize(Vector2(h, v));
|
|
return 0;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger UIAddBitmapWidget(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(ui, Sprite, typetag_Scene2d)
|
|
__SQ_GETINT(id)
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(new BitmapWidget((int)id), typetag_BitmapWidget)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
#define __SQ_CHECKWIDGETTYPE(__Type) if (w->GetType() != __Type) return sq_throwerror(vm, "Invalid widget cast.");
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger WidgetToBitmap(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(w, Widget, typetag_Widget)
|
|
__SQ_CHECKWIDGETTYPE(WidgetTypeBitmap)
|
|
__SQ_RETURNSAFEPTR((BitmapWidget *)w, typetag_BitmapWidget)
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger BitmapSetPicture(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(w, BitmapWidget, typetag_BitmapWidget)
|
|
__SQ_GETSAFEPTR(p, Picture, typetag_Picture)
|
|
__SQ_GETEND
|
|
w->SetPicture(p);
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
SQInteger UIAddTextWidget(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(4)
|
|
__SQ_GETSAFEPTR(ws, Scene, typetag_Scene2d)
|
|
__SQ_GETINT(id)
|
|
__SQ_GETSTRING(text)
|
|
__SQ_GETSAFEPTR(font, FontEx, typetag_Font)
|
|
TextWidget *wd = new TextWidget(id, text, font);
|
|
__SQ_GETEND
|
|
__SQ_RETURNSAFEPTR(wd, typetag_TextWidget)
|
|
}
|
|
|
|
SQInteger UIAddCheckWidget(HSQUIRRELVM vm)
|
|
{
|
|
Scene *ws;
|
|
if (!CObject::Get(vm, -5, (void **)&ws, typetag_Scene2d))
|
|
return -1;
|
|
SQInteger id;
|
|
sq_getinteger(vm, -4, &id);
|
|
const char *text;
|
|
sq_getstring(vm, -3, &text);
|
|
const char *font_name;
|
|
sq_getstring(vm, -2, &font_name);
|
|
SQBool initial_state;
|
|
sq_getbool(vm, -1, &initial_state);
|
|
|
|
CheckWidget *wd = NULL;
|
|
if (ws)
|
|
{
|
|
// wd = new CheckWidget(*ws, (int)id, text, Scene::GetFontCache().GetFont(font_name));
|
|
if (wd)
|
|
wd->SetState(initial_state ? true : false);
|
|
}
|
|
sq_pop(vm, 5); // Take care of the strings.
|
|
CObject::Push(vm, wd, typetag_CheckWidget);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger CheckWidgetSetState(HSQUIRRELVM vm)
|
|
{
|
|
CheckWidget *ws;
|
|
if (!CObject::Get(vm, -2, (void **)&ws, typetag_CheckWidget))
|
|
return -1;
|
|
SQBool state;
|
|
sq_getbool(vm, -1, &state);
|
|
sq_pop(vm, 2);
|
|
|
|
if (ws)
|
|
ws->SetState(state ? true : false);
|
|
return 0;
|
|
}
|
|
|
|
SQInteger CheckWidgetGetState(HSQUIRRELVM vm)
|
|
{
|
|
CheckWidget *ws;
|
|
if (!CObject::Get(vm, -1, (void **)&ws, typetag_CheckWidget))
|
|
return -1;
|
|
sq_pop(vm, 1);
|
|
|
|
bool state = false;
|
|
if (ws)
|
|
state = ws->GetState();
|
|
sq_pushbool(vm, state);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger CheckWidgetSetLabel(HSQUIRRELVM vm)
|
|
{
|
|
CheckWidget *ws;
|
|
if (!CObject::Get(vm, -2, (void **)&ws, typetag_CheckWidget))
|
|
return -1;
|
|
|
|
const char *label = NULL;
|
|
sq_getstring(vm, -1, &label);
|
|
if (ws)
|
|
ws->GetLabel().SetText(label);
|
|
sq_pop(vm, 2); // Take care of the string.
|
|
return 0;
|
|
}
|
|
|
|
SQInteger CheckWidgetSetLabelFont(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(ws, CheckWidget, typetag_CheckWidget)
|
|
__SQ_GETSAFEPTR(font, FontEx, typetag_Font)
|
|
__SQ_GETEND
|
|
ws->GetLabel().SetFont(font);
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger CheckWidgetSetLabelSize(HSQUIRRELVM vm)
|
|
{
|
|
CheckWidget *ws;
|
|
if (!CObject::Get(vm, -2, (void **)&ws, typetag_CheckWidget))
|
|
return -1;
|
|
SQInteger size;
|
|
sq_getinteger(vm, -1, &size);
|
|
sq_pop(vm, 2);
|
|
|
|
if (ws)
|
|
ws->GetLabel().SetFontSize((int)size);
|
|
return 0;
|
|
}
|
|
|
|
SQInteger CheckWidgetGetText(HSQUIRRELVM vm)
|
|
{
|
|
CheckWidget *ws;
|
|
if (!CObject::Get(vm, -1, (void **)&ws, typetag_CheckWidget))
|
|
return -1;
|
|
sq_pop(vm, 1);
|
|
|
|
TextWidget *wt = NULL;
|
|
if (ws)
|
|
wt = &ws->GetLabel();
|
|
CObject::Push(vm, wt, typetag_TextWidget);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger WidgetToText(HSQUIRRELVM vm)
|
|
{
|
|
Widget *ws;
|
|
if (!CObject::Get(vm, -1, (void **)&ws, typetag_Widget))
|
|
return -1;
|
|
sq_pop(vm, 1);
|
|
|
|
TextWidget *wt = NULL;
|
|
if (ws)
|
|
wt = (TextWidget *)ws;
|
|
CObject::Push(vm, wt, typetag_TextWidget);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger WidgetToCheck(HSQUIRRELVM vm)
|
|
{
|
|
Widget *ws;
|
|
if (!CObject::Get(vm, -1, (void **)&ws, typetag_Widget))
|
|
return -1;
|
|
sq_pop(vm, 1);
|
|
|
|
CheckWidget *wt = NULL;
|
|
if (ws)
|
|
wt = (CheckWidget *)ws;
|
|
CObject::Push(vm, wt, typetag_CheckWidget);
|
|
return 1;
|
|
}
|
|
|
|
SQInteger TextSetAlignment(HSQUIRRELVM vm)
|
|
{
|
|
TextWidget *ws;
|
|
if (!CObject::Get(vm, -2, (void **)&ws, typetag_TextWidget))
|
|
return -1;
|
|
SQInteger a;
|
|
sq_getinteger(vm, -1, &a);
|
|
sq_pop(vm, 2);
|
|
|
|
if (ws)
|
|
ws->SetTextAlignment((TextState::Alignment)a);
|
|
return 0;
|
|
}
|
|
|
|
SQInteger TextSetFormat(HSQUIRRELVM vm)
|
|
{
|
|
TextWidget *ws;
|
|
if (!CObject::Get(vm, -2, (void **)&ws, typetag_TextWidget))
|
|
return -1;
|
|
SQInteger f;
|
|
sq_getinteger(vm, -1, &f);
|
|
sq_pop(vm, 2);
|
|
|
|
if (ws)
|
|
ws->SetTextFormat((TextState::Format)f);
|
|
return 0;
|
|
}
|
|
|
|
SQInteger TextSetSize(HSQUIRRELVM vm)
|
|
{
|
|
TextWidget *ws;
|
|
if (!CObject::Get(vm, -2, (void **)&ws, typetag_TextWidget))
|
|
return -1;
|
|
SQInteger s;
|
|
sq_getinteger(vm, -1, &s);
|
|
sq_pop(vm, 2);
|
|
|
|
if (ws)
|
|
ws->SetFontSize((int)s);
|
|
return 0;
|
|
}
|
|
|
|
SQInteger TextSetColor(HSQUIRRELVM vm)
|
|
{
|
|
TextWidget *ws;
|
|
if (!CObject::Get(vm, -5, (void **)&ws, typetag_TextWidget))
|
|
return -1;
|
|
SQInteger r, g, b, a;
|
|
sq_getinteger(vm, -4, &r);
|
|
sq_getinteger(vm, -3, &g);
|
|
sq_getinteger(vm, -2, &b);
|
|
sq_getinteger(vm, -1, &a);
|
|
sq_pop(vm, 5);
|
|
|
|
if (ws)
|
|
ws->SetFontColor((float)r / 255.f, (float)g / 255.f, (float)b / 255.f, (float)a / 255.f);
|
|
return 0;
|
|
}
|
|
|
|
SQInteger TextSetText(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(ws, TextWidget, typetag_TextWidget)
|
|
__SQ_GETSTRING(txt)
|
|
ws->SetText(txt);
|
|
__SQ_GETEND
|
|
__SQ_RETURN
|
|
}
|
|
|
|
SQInteger SizerSetDrawDelimiter(HSQUIRRELVM vm)
|
|
{
|
|
sq_pop(vm, 2);
|
|
return 0;
|
|
}
|
|
|
|
SQInteger SizerSetBorderSize(HSQUIRRELVM vm)
|
|
{
|
|
SizerWidget *ws;
|
|
if (!CObject::Get(vm, -5, (void **)&ws, typetag_SizerWidget))
|
|
return -1;
|
|
|
|
SQInteger t, b, l, r;
|
|
sq_getinteger(vm, -4, &l);
|
|
sq_getinteger(vm, -3, &t);
|
|
sq_getinteger(vm, -2, &r);
|
|
sq_getinteger(vm, -1, &b);
|
|
sq_pop(vm, 5);
|
|
|
|
if (ws)
|
|
ws->SetBorderSize((float)t, (float)b, (float)l, (float)r);
|
|
return 0;
|
|
}
|
|
|
|
void IterateTextParameters(HSQUIRRELVM vm, int idx, TextState &state)
|
|
{
|
|
sq_pushnull(vm);
|
|
while (sq_next(vm, idx - 1) != SQ_ERROR)
|
|
{
|
|
const char *key;
|
|
if (sq_getstring(vm, -2, &key) != SQ_ERROR)
|
|
{
|
|
if (!strcmp(key, "size"))
|
|
{
|
|
SQInteger size;
|
|
sq_getinteger(vm, -1, &size);
|
|
state.SetSize(size);
|
|
}
|
|
else if (!strcmp(key, "color"))
|
|
{
|
|
SQInteger icolor;
|
|
if (sq_getinteger(vm, -1, &icolor) != SQ_ERROR)
|
|
{
|
|
Color color((uint)icolor);
|
|
state.color.x = uint(color.w * 255.f);
|
|
state.color.y = uint(color.z * 255.f);
|
|
state.color.z = uint(color.y * 255.f);
|
|
state.color.w = uint(color.x * 255.f);
|
|
}
|
|
}
|
|
else if (!strcmp(key, "align"))
|
|
{
|
|
const char *v;
|
|
if (sq_getstring(vm, -1, &v) != SQ_ERROR)
|
|
{
|
|
if (!strcmp(v, "left"))
|
|
state.alignment = TextState::Left;
|
|
else if (!strcmp(v, "right"))
|
|
state.alignment = TextState::Right;
|
|
else if (!strcmp(v, "center"))
|
|
state.alignment = TextState::Center;
|
|
else if (!strcmp(v, "justify"))
|
|
state.alignment = TextState::Justify;
|
|
else
|
|
__LOG_W__ << "unknown text alignment command '" << v << "'.\n";
|
|
}
|
|
}
|
|
else if (!strcmp(key, "format"))
|
|
{
|
|
const char *v;
|
|
if (sq_getstring(vm, -1, &v) != SQ_ERROR)
|
|
{
|
|
if (!strcmp(v, "standard"))
|
|
state.format = TextState::Line;
|
|
else if (!strcmp(v, "paragraph"))
|
|
state.format = TextState::Paragraph;
|
|
else if (!strcmp(v, "column"))
|
|
state.format = TextState::Column;
|
|
else
|
|
__LOG_W__ << "unknown text format command '" << v << "'.\n";
|
|
}
|
|
}
|
|
else if (!strcmp(key, "tracking"))
|
|
{
|
|
SQFloat tracking;
|
|
sq_getfloat(vm, -1, &tracking);
|
|
state.SetTracking(tracking);
|
|
}
|
|
else if (!strcmp(key, "leading"))
|
|
{
|
|
SQFloat leading;
|
|
sq_getfloat(vm, -1, &leading);
|
|
state.SetLeading(leading);
|
|
}
|
|
else
|
|
__LOG_W__ << "unknown text attribute '" << key << "'.\n";
|
|
}
|
|
sq_pop(vm, 2); // pop key/value.
|
|
}
|
|
sq_pop(vm, 1); // pop iterator.
|
|
}
|
|
|
|
SQInteger TextSetParameters(HSQUIRRELVM vm)
|
|
{
|
|
TextWidget *ws;
|
|
if (!CObject::Get(vm, -2, (void **)&ws, typetag_TextWidget))
|
|
return -1;
|
|
|
|
TextState state;
|
|
ws->GetTextState(state);
|
|
IterateTextParameters(vm, -1, state);
|
|
ws->SetTextState(state);
|
|
|
|
sq_pop(vm, 2);
|
|
return 0;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
#define __SQ_GETUISCENESCRIPTOBJECT(__SRC) Script::ScriptedObject *scripted_object = __SRC->scripted_object; if (!scripted_object) return sq_throwerror(vm, "No script system in scene!");
|
|
|
|
SQInteger UIGetScriptInstance(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLESAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_GETUISCENESCRIPTOBJECT(ui)
|
|
if (!scripted_object->GetUnitList().GetCount())
|
|
return sq_throwerror(vm, "No script unit");
|
|
Script::SquirrelObject *o = (Script::SquirrelObject *)scripted_object->GetUnitList()[0]->Self();
|
|
__SQ_RETURNOBJECT(o->object);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger UICreateCursor(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSINGLE(__SQ_GETINT(cursor_id))
|
|
Cursor *cursor = new Cursor;
|
|
if (!cursor)
|
|
return sq_throwerror(vm, "Failed to create a new UI cursor");
|
|
cursor->id = cursor_id;
|
|
__SQ_RETURNMANAGEDSAFEPTR(cursor, typetag_UICursor)
|
|
}
|
|
SQInteger UISetCursorState(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(5)
|
|
__SQ_GETSAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_GETSAFEPTR(cursor, Cursor, typetag_UICursor)
|
|
__SQ_GETFLOAT(x)
|
|
__SQ_GETFLOAT(y)
|
|
__SQ_GETBOOL(down)
|
|
__SQ_GETEND
|
|
cursor->current_state.x = x;
|
|
cursor->current_state.y = y;
|
|
cursor->current_state.down = asbool(down);
|
|
ui->UpdateCursor(cursor);
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//------------------------------------------------------------------------------
|
|
SQInteger UISetGlobalMatrix(HSQUIRRELVM vm)
|
|
{
|
|
__SQ_GETSTART(2)
|
|
__SQ_GETSAFEPTR(ui, Scene, typetag_Scene2d)
|
|
__SQ_GETMATRIX3(mtx)
|
|
__SQ_GETEND
|
|
ui->offset_matrix = mtx;
|
|
__SQ_RETURN
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
|
|
//---------------------------------------------------
|
|
void RegisterUIBinding(HSQUIRRELVM vm)
|
|
//---------------------------------------------------
|
|
{
|
|
/*#
|
|
Topic: UI
|
|
Type: Sprite
|
|
Type: Window
|
|
Type: Widget
|
|
Type: Check
|
|
Type: Container
|
|
Type: UI
|
|
Type: Canvas
|
|
Type: Sizer
|
|
Type: TextWidget
|
|
Type: Bitmap
|
|
#*/
|
|
|
|
/*#
|
|
Section: SceneIO
|
|
Desc: I/O
|
|
#*/
|
|
/*#
|
|
Func: UILoad
|
|
Proto: bool:UI,string
|
|
Desc: Append a scene to this scene, returns true on success, false otherwise.
|
|
See: UILoadAndStoreGroup
|
|
#*/
|
|
sq_register(vm, UIFromNML, "UILoad", _SC(".xs"));
|
|
/*#
|
|
Func: UILoadAndStoreGroup
|
|
Proto: UIGroup:UI scene_to_import_to,string path,ImportFlag import_flag
|
|
Desc: Append a scene to this scene, store all appended content in a group.
|
|
|
|
Example:
|
|
class LevelScene
|
|
{
|
|
diablo_ai = 0
|
|
diablo_fist = 0
|
|
|
|
function OnSetup(scene)
|
|
{
|
|
// Import the Diablo AI character into this scene.
|
|
diablo_ai = SceneLoadAndStoreGroup(scene, "enemy/ai/diablo.nms")
|
|
}
|
|
}
|
|
#*/
|
|
sq_register(vm, UIFromNMLStoreGroup, "UILoadAndStoreGroup", _SC(".xsi"));
|
|
|
|
/*#
|
|
Section: UIManagement
|
|
Desc: UI Management
|
|
#*/
|
|
/*#
|
|
Func: UIRenderSetup
|
|
Proto: void:UI,ResourceFactory
|
|
Desc: Setup UI render resources.
|
|
#*/
|
|
sq_register(vm, UIRenderSetup, "UIRenderSetup", _SC(".xx"));
|
|
/*#
|
|
Func: UISetGlobalMatrix
|
|
Proto: void:UI,Matrix3
|
|
Desc: Set the UI global transformation matrix.
|
|
#*/
|
|
sq_register(vm, UISetGlobalMatrix, "UISetGlobalMatrix", _SC(".xx"));
|
|
sq_register(vm, UISetGlobalMatrix, "UISetOffsetMatrix", _SC(".xx"));
|
|
/*#
|
|
Func: UIGetScriptInstance
|
|
Proto: Instance:UI
|
|
Desc: Return the UI script instance.
|
|
#*/
|
|
sq_register(vm, UIGetScriptInstance, "UIGetScriptInstance", _SC(".x"));
|
|
/*#
|
|
Func: SceneGetUI
|
|
Proto: UI:Scene
|
|
Desc: Return the scene UI interface.
|
|
#*/
|
|
sq_register(vm, SceneGetUI, "SceneGetUI", _SC(".x"));
|
|
/*#
|
|
Func: UISetVirtualResolution
|
|
Proto: void:UI,int width,int height
|
|
Desc: Set the UI system virtual resolution in pixels.
|
|
#*/
|
|
sq_register(vm, UISetVirtualResolution, "UISetInternalResolution", _SC(".xnn")); // compat
|
|
sq_register(vm, UISetVirtualResolution, "UISetVirtualResolution", _SC(".xnn"));
|
|
/*#
|
|
Func: UIGetVirtualResolution
|
|
Proto: Vector2:UI
|
|
Desc: Get the UI system virtual resolution in pixels.
|
|
#*/
|
|
sq_register(vm, UIGetVirtualResolution, "UIGetInternalResolution", _SC(".x")); // compat
|
|
sq_register(vm, UIGetVirtualResolution, "UIGetVirtualResolution", _SC(".x"));
|
|
|
|
/*#
|
|
Func: UIGetScreenToUIMatrix
|
|
Proto: Matrix3:UI
|
|
Desc: Return the UI to normalized screen coordinates transformation matrix.<br>
|
|
This matrix can be used to transform a normalized screen coordinate to a scene coordinate expressed in pixels.
|
|
See: UIGetVirtualResolution
|
|
Example:
|
|
// With a virtual resolution of 1920x1080 pixels.
|
|
local scene_coord = Vector2(0.5, 1) * UIGetScreenToUIMatrix(ui)
|
|
|
|
// scene_coord now contains Vector2(960.0, 1080.0)
|
|
#*/
|
|
sq_register(vm, UIGetScreenToUIMatrix, "UIGetScreenToUIMatrix", _SC(".x"));
|
|
/*#
|
|
Func: UIGetUIToScreenMatrix
|
|
Proto: Matrix3:UI
|
|
Desc: Return the normalized screen to UI coordinates transformation matrix.<br>
|
|
This matrix can be used to transform a scene coordinate expressed in pixels to a normalized screen coordinate between 0 and 1.
|
|
See: UIGetVirtualResolution
|
|
Example:
|
|
// With a virtual resolution of 1920x1080 pixels.
|
|
local norm_screen = Vector2(1920, 1080) * UIGetUIToScreenMatrix(ui)
|
|
|
|
// norm_screen now contains Vector2(1.0, 1.0)
|
|
#*/
|
|
sq_register(vm, UIGetUIToScreenMatrix, "UIGetUIToScreenMatrix", _SC(".x"));
|
|
|
|
/*#
|
|
Section: UISkin
|
|
Desc: UI Skin and Appearance
|
|
#*/
|
|
/*#
|
|
Func: UISetSkin
|
|
Proto: void:UI,GraphicResourceFactory,string bmp_top,string bmp_left,string bmp_right,string bmp_bottom,string bmp_top_left,string bmp_top_right,string bmp_bottom_left,string bmp_bottom_right,int hex_font_color,int hex_title_color,int space_title_top,int space_title_bottom,int title_font_size,string title_font
|
|
Desc: Set the UI window system skin.
|
|
#*/
|
|
sq_register(vm, UISetSkin, "UISetSkin", _SC(".xxssssssssnnnnns"));
|
|
|
|
/*#
|
|
Section: UIIO
|
|
Desc: UI Cursor
|
|
#*/
|
|
/*#
|
|
Func: UICreateCursor
|
|
Proto: UICursor:int cursor_id
|
|
Desc: Create a new UI system cursor.
|
|
#*/
|
|
sq_register(vm, UICreateCursor, "UICreateCursor", _SC(".i"));
|
|
/*#
|
|
Func: UISetCursorState
|
|
Proto: void:UI,UICursor,float x,float y,bool down
|
|
Desc: Set the current cursor state, the UI system will process cursor events and perform calls to the corresponding handlers. <b>Note:</b> This call will trigger cursor related events immediately.
|
|
#*/
|
|
sq_register(vm, UISetCursorState, "UISetCursorState", _SC(".xxnnb"));
|
|
/*#
|
|
Func: UICursorGetWindowBelow
|
|
Proto: Window:UICursor cursor
|
|
Desc: Return the window under the cursor, returns null is there is no such window.
|
|
#*/
|
|
sq_register(vm, UICursorGetWindowBelow, "UICursorGetWindowBelow", _SC(".x"));
|
|
/*#
|
|
Func: UICursorGetSpriteBelow
|
|
Proto: Sprite:UICursor cursor
|
|
Desc: Return the sprite under the cursor, returns null is there is no such sprite.
|
|
#*/
|
|
sq_register(vm, UICursorGetSpriteBelow, "UICursorGetSpriteBelow", _SC(".x"));
|
|
/*#
|
|
Func: UILock
|
|
Proto: void:UI,Sprite|Window
|
|
Desc: Lock UI to a given sprite/window. All UI cursor events are sent to this sprite/window exclusively until the lock is released.
|
|
#*/
|
|
sq_register(vm, UILockToSprite, "UILock", _SC(".xx"));
|
|
sq_register(vm, UILockToSprite, "UILockToSprite", _SC(".xx"));
|
|
/*#
|
|
Func: UIUnlock
|
|
Proto: void:UI
|
|
Desc: Release the UI sprite/window lock.
|
|
#*/
|
|
sq_register(vm, UIUnlock, "UIUnlock", _SC(".x"));
|
|
|
|
/*#
|
|
Section: UIGlobal
|
|
Desc: UI Global Effects
|
|
#*/
|
|
/*#
|
|
Func: UISetCommandList
|
|
Proto: void:UI,string command_list
|
|
Desc: Set the UI system ACE command list.
|
|
#*/
|
|
sq_register(vm, UISetCommandList, "UISetCommandList", _SC(".xs"));
|
|
/*#
|
|
Func: UIIsCommandListDone
|
|
Proto: bool:UI
|
|
Desc: Returns true if the UI system command list unit is not executing, false otherwise.
|
|
#*/
|
|
sq_register(vm, UIIsCommandListDone, "UIIsCommandListDone", _SC(".x"));
|
|
/*#
|
|
Func: UISetGlobalFadeEffect
|
|
Proto: void:UI,float fade
|
|
Desc: Set the global fade effect intensity (0.0 is fully faded, 1.0 is no effect).
|
|
#*/
|
|
sq_register(vm, UISetGlobalFadeEffect, "UISetGlobalFadeEffect", _SC(".xn"));
|
|
/*#
|
|
Func: UISetGlobalFadeColor
|
|
Proto: void:UI,float r,float g,float b
|
|
Desc: Set the global fade effect color.
|
|
#*/
|
|
sq_register(vm, UISetGlobalFadeColor, "UISetGlobalFadeColor", _SC(".xnnn"));
|
|
/*#
|
|
Func: UIDeleteAllItems
|
|
Proto: void:UI
|
|
Desc: Delete all window and sprite in scene.
|
|
#*/
|
|
sq_register(vm, UIDeleteAllItems, "UIDeleteAllItems", _SC(".x"));
|
|
|
|
/*#
|
|
Section: UIItem
|
|
Desc: UI Item
|
|
#*/
|
|
/*#
|
|
Func: UIItemCastToSprite
|
|
Proto: Sprite:UIItem item
|
|
Desc: Cast an UI item to a UI sprite.
|
|
#*/
|
|
sq_register(vm, UIItemCastToSprite, "UIItemCastToSprite", _SC(".x"));
|
|
/*#
|
|
Func: UIItemCastToWindow
|
|
Proto: Window:UIItem item
|
|
Desc: Cast an UI item to a UI window.
|
|
#*/
|
|
sq_register(vm, UIItemCastToWindow, "UIItemCastToWindow", _SC(".x"));
|
|
|
|
/*#
|
|
Section: UISprite
|
|
Desc: UI Sprite
|
|
#*/
|
|
/*#
|
|
Func: UIAddSprite
|
|
Proto: Window:UI,int id,Texture,float origin_x,float origin_y,float width,float height
|
|
Desc: Create a new sprite. Note: This a legacy wrapper where the id integer is converted to a string and used as the sprite name.
|
|
#*/
|
|
sq_register(vm, UIAddSprite, "UIAddSprite", _SC(".xixnnnn"));
|
|
/*#
|
|
Func: UIAddNamedSprite
|
|
Proto: Window:UI,string name,Texture,float origin_x,float origin_y,float width,float height
|
|
Desc: Create a new sprite.
|
|
#*/
|
|
sq_register(vm, UIAddNamedSprite, "UIAddNamedSprite", _SC(".xsxnnnn"));
|
|
/*#
|
|
Func: UIDeleteSprite
|
|
Proto: void:UI,Sprite
|
|
Desc: Delete a sprite.
|
|
#*/
|
|
sq_register(vm, UIDeleteWindow, "UIDeleteSprite", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: SpriteGetZOrder
|
|
Proto: float:Sprite
|
|
Desc: Get the sprite Z-order.
|
|
#*/
|
|
sq_register(vm, WindowGetZOrder, "SpriteGetZOrder", _SC(".x"));
|
|
/*#
|
|
Func: SpriteSetZOrder
|
|
Proto: void:Sprite,float
|
|
Desc: Set the sprite Z-order.
|
|
#*/
|
|
sq_register(vm, WindowSetZOrder, "SpriteSetZOrder", _SC(".xn"));
|
|
/*#
|
|
Func: SpriteSetUVOrigin
|
|
Proto: void:Sprite,float u,float v
|
|
Desc: Set the sprite UV origin in pixels.
|
|
#*/
|
|
sq_register(vm, SpriteSetUVOrigin, "SpriteSetUVOrigin", _SC(".xnn"));
|
|
/*#
|
|
Func: SpriteSetTexture
|
|
Proto: void:Window,Texture
|
|
Desc: Set the sprite texture.
|
|
#*/
|
|
sq_register(vm, SpriteSetTexture, "SpriteSetTexture", _SC(".xx"));
|
|
/*#
|
|
Func: WebcamTextureBlit
|
|
Proto: void:Texture, pointer with a int
|
|
Desc: blit the webcam texture to the texture.
|
|
#*/
|
|
sq_register(vm, WebcamTextureBlit, "WebcamTextureBlit", _SC(".xi"));
|
|
/*#
|
|
Func: SpriteSetTextureMatrix
|
|
Proto: void:Window,Matrix3
|
|
Desc: Set the sprite texture matrix. Note: Do not forget to enable the transform UV style on the sprite for the matrix to be used.
|
|
#*/
|
|
sq_register(vm, SpriteSetTextureMatrix, "SpriteSetTextureMatrix", _SC(".xx"));
|
|
/*#
|
|
Func: SpriteRenderSetup
|
|
Proto: void:Sprite,ResourceFactory
|
|
Desc: Setup the sprite render data.
|
|
#*/
|
|
sq_register(vm, SpriteRenderSetup, "SpriteRenderSetup", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: SpriteGetRect
|
|
Proto: Rect:Sprite
|
|
Desc: Return the sprite rect.
|
|
#*/
|
|
sq_register(vm, WindowGetRect, "SpriteGetRect", _SC(".x"));
|
|
/*#
|
|
Func: SpriteGetScreenRect
|
|
Proto: Rect:Sprite
|
|
Desc: Return the sprite rect in the virtual screen coordinate system.
|
|
#*/
|
|
sq_register(vm, WindowGetScreenRect, "SpriteGetScreenRect", _SC(".x"));
|
|
|
|
/*#
|
|
Func: SpriteSetCommandList
|
|
Proto: void:Sprite,string command_list
|
|
Desc: Set the sprite command list.
|
|
#*/
|
|
sq_register(vm, WindowSetCommandList, "SpriteSetCommandList", _SC(".xs"));
|
|
/*#
|
|
Func: SpriteResetCommandList
|
|
Proto: void:Sprite
|
|
Desc: Reset the sprite ACE unit.
|
|
#*/
|
|
sq_register(vm, WindowResetCommandList, "SpriteResetCommandList", _SC(".x"));
|
|
/*#
|
|
Func: SpriteIsCommandListDone
|
|
Proto: bool:Sprite
|
|
Desc: Returns true if the sprite ACE unit is idle, false otherwise.
|
|
#*/
|
|
sq_register(vm, WindowIsCommandListDone, "SpriteIsCommandListDone", _SC(".x"));
|
|
|
|
/*#
|
|
Func: SpriteGetName
|
|
Proto: string:Sprite
|
|
Desc: Get the sprite name.
|
|
#*/
|
|
sq_register(vm, WindowGetName, "SpriteGetName", _SC(".x"));
|
|
|
|
/*#
|
|
Func: SpriteGetParent
|
|
Proto: Window|Sprite:Sprite
|
|
Desc: Get the sprite parent.
|
|
#*/
|
|
sq_register(vm, WindowGetParent, "SpriteGetParent", _SC(".x"));
|
|
/*#
|
|
Func: SpriteSetParent
|
|
Proto: void:Sprite,Window|Sprite
|
|
Desc: Set the sprite parent window or sprite.
|
|
#*/
|
|
sq_register(vm, WindowSetParent, "SpriteSetParent", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: SpriteGetPosition
|
|
Proto: Vector2:Sprite
|
|
Desc: Get the sprite position as a vector.
|
|
#*/
|
|
sq_register(vm, WindowGetPosition, "SpriteGetPosition", _SC(".x"));
|
|
/*#
|
|
Func: SpriteSetPosition
|
|
Proto: void:Sprite,float x,float y
|
|
Desc: Set the sprite position.
|
|
#*/
|
|
sq_register(vm, WindowSetPosition, "SpriteSetPosition", _SC(".xnn"));
|
|
/*#
|
|
Func: SpriteSetRotation
|
|
Proto: void:Sprite,float angle
|
|
Desc: Set the sprite rotation (use the Deg() or Rad() macros to specify the unit).
|
|
#*/
|
|
sq_register(vm, WindowSetRotation, "SpriteSetRotation", _SC(".xn"));
|
|
/*#
|
|
Func: SpriteGetSize
|
|
Proto: Vector2:Sprite
|
|
Desc: Get the sprite size as a vector.
|
|
#*/
|
|
sq_register(vm, WindowGetSize, "SpriteGetSize", _SC(".x"));
|
|
/*#
|
|
Func: SpriteSetSize
|
|
Proto: void:sprite,float width,float height
|
|
Desc: Set the sprite size.
|
|
#*/
|
|
sq_register(vm, WindowSetSize, "SpriteSetSize", _SC(".xnn"));
|
|
/*#
|
|
Func: SpriteGetPivot
|
|
Proto: Vector2:Sprite
|
|
Desc: Get the sprite pivot.
|
|
#*/
|
|
sq_register(vm, WindowGetPivot, "SpriteGetPivot", _SC(".x"));
|
|
/*#
|
|
Func: SpriteSetPivot
|
|
Proto: void:Sprite,float pivot_x,float pivot_y
|
|
Desc: Set the sprite pivot.
|
|
#*/
|
|
sq_register(vm, WindowSetPivot, "SpriteSetPivot", _SC(".xnn"));
|
|
/*#
|
|
Func: SpriteSetScale
|
|
Proto: void:Sprite,float scale_x,float scale_y
|
|
Desc: Set the sprite scale.
|
|
#*/
|
|
sq_register(vm, WindowSetScale, "SpriteSetScale", _SC(".xnn"));
|
|
/*#
|
|
Func: SpriteGetOpacity
|
|
Proto: float:sprite
|
|
Desc: Get the sprite opacity.
|
|
#*/
|
|
sq_register(vm, WindowGetOpacity, "SpriteGetOpacity", _SC(".x"));
|
|
/*#
|
|
Func: SpriteSetOpacity
|
|
Proto: void:Sprite,float opacity
|
|
Desc: Set the sprite opacity.
|
|
#*/
|
|
sq_register(vm, WindowSetOpacity, "SpriteSetOpacity", _SC(".xn"));
|
|
/*#
|
|
Func: SpriteSetFlip
|
|
Proto: void:Sprite,bool flip_horizontal,bool flip_vertical
|
|
Desc: Flip the sprite on one or both axises.
|
|
#*/
|
|
sq_register(vm, WindowSetFlip, "SpriteSetFlip", _SC(".xbb"));
|
|
/*#
|
|
Func: SpriteGetStyle
|
|
Proto: SpriteStyle:Sprite
|
|
Desc: Get the sprite style bitflag.
|
|
#*/
|
|
sq_register(vm, WindowGetStyle, "SpriteGetStyle", _SC(".x"));
|
|
/*#
|
|
Func: SpriteSetStyle
|
|
Proto: void:Sprite,SpriteStyle style
|
|
Desc: Set the sprite style bitflag.
|
|
#*/
|
|
sq_register(vm, WindowSetStyle, "SpriteSetStyle", _SC(".xi"));
|
|
/*#
|
|
Func: SpriteAddStyle
|
|
Proto: void:Sprite,SpriteStyle style
|
|
Desc: Add a style to the sprite style bitflag.
|
|
#*/
|
|
sq_register(vm, WindowAddStyle, "SpriteAddStyle", _SC(".xi"));
|
|
/*#
|
|
Func: SpriteRemoveStyle
|
|
Proto: void:Sprite,SpriteStyle style
|
|
Desc: Remove a style from the sprite style bitflag.
|
|
#*/
|
|
sq_register(vm, WindowRemoveStyle, "SpriteRemoveStyle", _SC(".xi"));
|
|
|
|
/*#
|
|
Func: UISpriteCentre
|
|
Proto: void:UI,Sprite
|
|
Desc: Centre a sprite on screen.
|
|
#*/
|
|
sq_register(vm, UIWindowCentre, "UISpriteCentre", _SC(".x"));
|
|
|
|
/*#
|
|
Func: SpriteSetEventHandler
|
|
Proto: void:Sprite,UIEvent event,function callback
|
|
Desc: Set a native Squirrel function as the callback function to a specific UI event.
|
|
#*/
|
|
sq_register(vm, WindowSetEventHandler, "SpriteSetEventHandler", _SC(".xnc"));
|
|
/*#
|
|
Func: SpriteSetEventHandlerWithContext
|
|
Proto: void:Sprite,UIEvent event,instance context,function callback
|
|
Desc: Set a native Squirrel function as the callback function to a specific UI event, the calling context can be specified (eg. a class instance to callback to one of its member function).
|
|
#*/
|
|
sq_register(vm, WindowSetEventHandlerWithContext, "SpriteSetEventHandlerWithContext", _SC(".xn.c"));
|
|
|
|
/*#
|
|
Section: UIWindow
|
|
Desc: UI Window
|
|
#*/
|
|
/*#
|
|
Func: UIAddNamedWindow
|
|
Proto: Window:UI,string name,float origin_x,float origin_y,float width,float height
|
|
Desc: Create a new named window.
|
|
#*/
|
|
sq_register(vm, UIAddNamedWindow, "UIAddNamedWindow", _SC(".xsnnnn"));
|
|
/*#
|
|
Func: UIAddNamedBitmapWindow
|
|
Proto: Window:UI,String name,Picture,float origin_x,float origin_y,float width,float height
|
|
Desc: Create a new named bitmap window.
|
|
#*/
|
|
sq_register(vm, UIAddNamedBitmapWindow, "UIAddNamedBitmapWindow", _SC(".xsxnnnn"));
|
|
/*#
|
|
Func: UIDeleteWindow
|
|
Proto: void:UI,Window
|
|
Desc: Delete a window.
|
|
#*/
|
|
sq_register(vm, UIDeleteWindow, "UIDeleteWindow", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: WindowGetZOrder
|
|
Proto: float:Window
|
|
Desc: Get the window Z-order.
|
|
#*/
|
|
sq_register(vm, WindowGetZOrder, "WindowGetZOrder", _SC(".x"));
|
|
/*#
|
|
Func: WindowSetZOrder
|
|
Proto: void:Window,float
|
|
Desc: Set the window Z-order.
|
|
#*/
|
|
sq_register(vm, WindowSetZOrder, "WindowSetZOrder", _SC(".xn"));
|
|
/*#
|
|
Func: WindowSetTitle
|
|
Proto: void:window,string title
|
|
Desc: Set the window title.
|
|
#*/
|
|
sq_register(vm, WindowSetTitle, "WindowSetTitle", _SC(".xs"));
|
|
/*#
|
|
Func: WindowGetTitle
|
|
Proto: string:window
|
|
Desc: Get the window title.
|
|
#*/
|
|
sq_register(vm, WindowGetTitle, "WindowGetTitle", _SC(".x"));
|
|
/*#
|
|
Func: WindowSetBaseWidget
|
|
Proto: void:window,widget
|
|
Desc: Set the window base widget.
|
|
#*/
|
|
sq_register(vm, WindowSetBaseWidget, "WindowSetBaseWidget", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: WindowGetRect
|
|
Proto: Rect:Window
|
|
Desc: Return the window rect.
|
|
#*/
|
|
sq_register(vm, WindowGetRect, "WindowGetRect", _SC(".x"));
|
|
/*#
|
|
Func: WindowGetScreenRect
|
|
Proto: Rect:Window
|
|
Desc: Return the window rect in the virtual screen coordinate system.
|
|
#*/
|
|
sq_register(vm, WindowGetScreenRect, "WindowGetScreenRect", _SC(".x"));
|
|
|
|
/*#
|
|
Func: WindowSetCommandList
|
|
Proto: void:window,string command_list
|
|
Desc: Set the window command list.
|
|
#*/
|
|
sq_register(vm, WindowSetCommandList, "WindowSetCommandList", _SC(".xs"));
|
|
/*#
|
|
Func: WindowResetCommandList
|
|
Proto: void:window
|
|
Desc: Reset the window ACE unit.
|
|
#*/
|
|
sq_register(vm, WindowResetCommandList, "WindowResetCommandList", _SC(".x"));
|
|
/*#
|
|
Func: WindowIsCommandListDone
|
|
Proto: bool:window
|
|
Desc: Returns true if the window ACE unit is idle, false otherwise.
|
|
#*/
|
|
sq_register(vm, WindowIsCommandListDone, "WindowIsCommandListDone", _SC(".x"));
|
|
|
|
/*#
|
|
Func: WindowGetName
|
|
Proto: string:window
|
|
Desc: Get the window name.
|
|
#*/
|
|
sq_register(vm, WindowGetName, "WindowGetName", _SC(".x"));
|
|
|
|
/*#
|
|
Func: WindowGetChild
|
|
Proto: widget:window,int id
|
|
Desc: Get a window widget from its id.
|
|
#*/
|
|
sq_register(vm, WindowGetChild, "WindowGetChild", _SC(".xn"));
|
|
/*#
|
|
Func: WindowGetParent
|
|
Proto: Window|Sprite:Window
|
|
Desc: Get the window parent.
|
|
#*/
|
|
sq_register(vm, WindowGetParent, "WindowGetParent", _SC(".x"));
|
|
/*#
|
|
Func: WindowSetParent
|
|
Proto: void:Window,Window|Sprite
|
|
Desc: Set the window parent window or sprite.
|
|
#*/
|
|
sq_register(vm, WindowSetParent, "WindowSetParent", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: WindowGetPosition
|
|
Proto: Vector2:Window
|
|
Desc: Get the window position as a vector.
|
|
#*/
|
|
sq_register(vm, WindowGetPosition, "WindowGetPosition", _SC(".x"));
|
|
/*#
|
|
Func: WindowSetPosition
|
|
Proto: void:Window,float x,float y
|
|
Desc: Set the window position.
|
|
#*/
|
|
sq_register(vm, WindowSetPosition, "WindowSetPosition", _SC(".xnn"));
|
|
/*#
|
|
Func: WindowSetRotation
|
|
Proto: void:Window,float angle
|
|
Desc: Set the window rotation (use the Deg() or Rad() macros to specify the unit).
|
|
#*/
|
|
sq_register(vm, WindowSetRotation, "WindowSetRotation", _SC(".xn"));
|
|
/*#
|
|
Func: WindowGetSize
|
|
Proto: Vector2:Window
|
|
Desc: Get the window size as a vector.
|
|
#*/
|
|
sq_register(vm, WindowGetSize, "WindowGetSize", _SC(".x"));
|
|
/*#
|
|
Func: WindowSetSize
|
|
Proto: void:Window,float width,float height
|
|
Desc: Set the window size.
|
|
#*/
|
|
sq_register(vm, WindowSetSize, "WindowSetSize", _SC(".xnn"));
|
|
/*#
|
|
Func: WindowGetPivot
|
|
Proto: Vector2:Window
|
|
Desc: Get the window pivot.
|
|
#*/
|
|
sq_register(vm, WindowGetPivot, "WindowGetPivot", _SC(".x"));
|
|
/*#
|
|
Func: WindowSetPivot
|
|
Proto: void:Window,float pivot_x,float pivot_y
|
|
Desc: Set the window pivot.
|
|
#*/
|
|
sq_register(vm, WindowSetPivot, "WindowSetPivot", _SC(".xnn"));
|
|
/*#
|
|
Func: WindowSetScale
|
|
Proto: void:Window,float scale_x,float scale_y
|
|
Desc: Set the window scale.
|
|
#*/
|
|
sq_register(vm, WindowSetScale, "WindowSetScale", _SC(".xnn"));
|
|
/*#
|
|
Func: WindowGetOpacity
|
|
Proto: float:Window
|
|
Desc: Get the window opacity.
|
|
#*/
|
|
sq_register(vm, WindowGetOpacity, "WindowGetOpacity", _SC(".x"));
|
|
/*#
|
|
Func: WindowSetOpacity
|
|
Proto: void:Window,float opacity
|
|
Desc: Set the window opacity.
|
|
#*/
|
|
sq_register(vm, WindowSetOpacity, "WindowSetOpacity", _SC(".xn"));
|
|
/*#
|
|
Func: WindowSetFlip
|
|
Proto: void:Window,bool flip_horizontal,bool flip_vertical
|
|
Desc: Flip the window on one or both axises.
|
|
#*/
|
|
sq_register(vm, WindowSetFlip, "WindowSetFlip", _SC(".xbb"));
|
|
/*#
|
|
Func: WindowGetStyle
|
|
Proto: SpriteStyle:Window
|
|
Desc: Get the window style bitflag.
|
|
#*/
|
|
sq_register(vm, WindowGetStyle, "WindowGetStyle", _SC(".x"));
|
|
/*#
|
|
Func: WindowSetStyle
|
|
Proto: void:Window,SpriteStyle style
|
|
Desc: Set the window style bitflag.
|
|
#*/
|
|
sq_register(vm, WindowSetStyle, "WindowSetStyle", _SC(".xn"));
|
|
/*#
|
|
Func: WindowAddStyle
|
|
Proto: void:Window,SpriteStyle style
|
|
Desc: Add a style to the window style bitflag.
|
|
#*/
|
|
sq_register(vm, WindowAddStyle, "WindowAddStyle", _SC(".xn"));
|
|
/*#
|
|
Func: WindowRemoveStyle
|
|
Proto: void:Window,SpriteStyle style
|
|
Desc: Remove a style from the window style bitflag.
|
|
#*/
|
|
sq_register(vm, WindowRemoveStyle, "WindowRemoveStyle", _SC(".xn"));
|
|
|
|
/*#
|
|
Func: WindowGetBackgroundPicture
|
|
Proto: Picture:Window
|
|
Desc: Get the window background picture.
|
|
#*/
|
|
sq_register(vm, WindowGetBackgroundPicture, "WindowGetBackgroundPicture", _SC(".x"));
|
|
/*#
|
|
Func: WindowSetBackgroundPicture
|
|
Proto: void:Window,Picture
|
|
Desc: Set the window background picture.
|
|
#*/
|
|
sq_register(vm, WindowSetBackgroundPicture, "WindowSetBackgroundPicture", _SC(".xx"));
|
|
/*#
|
|
Func: WindowSetBackgroundColor
|
|
Proto: void:Window,int hex_color
|
|
Desc: Set the window background color.
|
|
#*/
|
|
sq_register(vm, WindowSetBackgroundColor, "WindowSetBackgroundColor", _SC(".xn"));
|
|
|
|
/*#
|
|
Func: UIWindowCentre
|
|
Proto: void:UI,Window
|
|
Desc: Centre the window on screen.
|
|
#*/
|
|
sq_register(vm, UIWindowCentre, "UIWindowCentre", _SC(".xx"));
|
|
|
|
/*#
|
|
Func: WindowForceLayout
|
|
Proto: void:Window
|
|
Desc: Force a complete update of the window layout.
|
|
#*/
|
|
sq_register(vm, WindowForceLayout, "WindowForceLayout", _SC(".x"));
|
|
/*#
|
|
Func: WindowInvalidate
|
|
Proto: void:Window
|
|
Desc: Force a complete update of the window layout and content.
|
|
#*/
|
|
sq_register(vm, WindowInvalidate, "WindowInvalidate", _SC(".x"));
|
|
/*#
|
|
Func: WindowGetCacheTexture
|
|
Proto: texture:Window
|
|
Desc: Returns the texture object that is used to display the window via the engine renderer.
|
|
#*/
|
|
sq_register(vm, WindowGetCacheTexture, "WindowGetCacheTexture", _SC(".x"));
|
|
|
|
/*#
|
|
Func: WindowSetEventHandler
|
|
Proto: void:Window,UIEvent event,function callback
|
|
Desc: Set a native Squirrel function as the callback function to a specific UI event.
|
|
#*/
|
|
sq_register(vm, WindowSetEventHandler, "WindowSetEventHandler", _SC(".xnc"));
|
|
/*#
|
|
Func: WindowSetEventHandlerWithContext
|
|
Proto: void:Window,UIEvent event,instance context,function callback
|
|
Desc: Set a native Squirrel function as the callback function to a specific UI event, the calling context can be specified (eg. a class instance to callback to one of its member function).
|
|
#*/
|
|
sq_register(vm, WindowSetEventHandlerWithContext, "WindowSetEventHandlerWithContext", _SC(".xn.c"));
|
|
|
|
/*#
|
|
Func: WindowRenderSetup
|
|
Proto: void:Window,ResourceFactory
|
|
Desc: Setup the window render data.
|
|
#*/
|
|
sq_register(vm, SpriteRenderSetup, "WindowRenderSetup", _SC(".xx"));
|
|
|
|
/*#
|
|
Section: UIWidget
|
|
Desc: UI Widget
|
|
#*/
|
|
/*#
|
|
Func: UIDeleteWidget
|
|
Proto: void:UI,Widget
|
|
Desc: Delete a widget.
|
|
#*/
|
|
sq_register(vm, UIDeleteWidget, "UIDeleteWidget", _SC(".xx"));
|
|
/*#
|
|
Func: UIAddCanvasWidget
|
|
Proto: Widget:UI,int id,int width,int height
|
|
Desc: Create a new canvas widget.
|
|
#*/
|
|
sq_register(vm, UIAddCanvasWidget, "UIAddCanvasWidget", _SC(".xnnn"));
|
|
/*#
|
|
Func: UIAddHorizontalSizerWidget
|
|
Proto: Widget:UI,int id
|
|
Desc: Create a new horizontal sizer widget.
|
|
#*/
|
|
sq_register(vm, UIAddHorizontalSizerWidget, "UIAddHorizontalSizerWidget", _SC(".xn"));
|
|
/*#
|
|
Func: UIAddVerticalSizerWidget
|
|
Proto: Widget:UI,int id
|
|
Desc: Create a new vertical sizer widget.
|
|
#*/
|
|
sq_register(vm, UIAddVerticalSizerWidget, "UIAddVerticalSizerWidget", _SC(".xn"));
|
|
/*#
|
|
Func: UIAddContainerWidget
|
|
Proto: Widget:UI,int id
|
|
Desc: Create a new container widget.
|
|
#*/
|
|
sq_register(vm, UIAddContainerWidget, "UIAddContainerWidget", _SC(".xn"));
|
|
/*#
|
|
Func: UIAddSpacerWidget
|
|
Proto: Widget:UI,int id
|
|
Desc: Create a new spacer widget.
|
|
#*/
|
|
sq_register(vm, UIAddSpacerWidget, "UIAddSpacerWidget", _SC(".xn"));
|
|
/*#
|
|
Func: UIAddBitmapWidget
|
|
Proto: Widget:UI,int id
|
|
Desc: Create a new bitmap widget.
|
|
#*/
|
|
sq_register(vm, UIAddBitmapWidget, "UIAddBitmapWidget", _SC(".xn"));
|
|
/*#
|
|
Func: UIAddTextWidget
|
|
Proto: TextWidget:UI,int id,string text,Font font
|
|
Desc: Create a new static text widget.
|
|
#*/
|
|
sq_register(vm, UIAddTextWidget, "UIAddTextWidget", _SC(".xnsx"));
|
|
/*#
|
|
Func: UIAddCheckWidget
|
|
Proto: Widget:UI,int id,string text,string font,bool initial_state
|
|
Desc: Create a new checkbox widget.
|
|
#*/
|
|
sq_register(vm, UIAddCheckWidget, "UIAddCheckWidget", _SC(".xnssb"));
|
|
|
|
/*#
|
|
Section: CanvasWidget
|
|
Desc: Widget Canvas, a freely drawable widget
|
|
#*/
|
|
/*#
|
|
Func: CanvasWidgetLock
|
|
Proto: picture:canvas
|
|
Desc: Lock the widget returning a user drawable picture object.
|
|
#*/
|
|
sq_register(vm, CanvasWidgetLock, "CanvasWidgetLock", _SC(".x"));
|
|
/*#
|
|
Func: CanvasWidgetUnlock
|
|
Proto: void:canvas
|
|
Desc: Unlock this widget canvas.<br><b>Note:</b> The picture object obtained through CanvasWidgetLock is not valid after calling this function.
|
|
#*/
|
|
sq_register(vm, CanvasWidgetUnlock, "CanvasWidgetUnlock", _SC(".x"));
|
|
|
|
/*#
|
|
Section: SizerWidget
|
|
Desc: Widget Sizer
|
|
#*/
|
|
/*#
|
|
Func: SizerSetDrawDelimiter
|
|
Proto: void:sizer,bool draw
|
|
Desc: Draw/hide sizer delimiter.
|
|
#*/
|
|
sq_register(vm, SizerSetDrawDelimiter, "SizerSetDrawDelimiter", _SC(".xb"));
|
|
/*#
|
|
Func: SizerSetBorderSize
|
|
Proto: void:sizer,int left,int top,int right,int bottom
|
|
Desc: Set sizer border size.
|
|
#*/
|
|
sq_register(vm, SizerSetBorderSize, "SizerSetBorderSize", _SC(".xnnnn"));
|
|
/*#
|
|
Func: SizerAddWidget
|
|
Proto: void:sizer,widget
|
|
Desc: Add a widget to a sizer.
|
|
#*/
|
|
sq_register(vm, SizerAddWidget, "SizerAddWidget", _SC(".xx"));
|
|
|
|
/*#
|
|
Section: ContainerWidget
|
|
Desc: Widget Container
|
|
#*/
|
|
/*#
|
|
Func: ContainerAddWidget
|
|
Proto: void:container,widget,float origin_x,float origin_y,float width,float height
|
|
Desc: Add a widget at specified position to the container.
|
|
#*/
|
|
sq_register(vm, ContainerAddWidget, "ContainerAddWidget", _SC(".xxnnnn"));
|
|
/*#
|
|
Func: ContainerWidgetSetPosition
|
|
Proto: void:container,widget,float origin_x,float origin_y
|
|
Desc: Set a widget position in its container.
|
|
#*/
|
|
sq_register(vm, ContainerWidgetSetPosition, "ContainerWidgetSetPosition", _SC(".xxnn"));
|
|
|
|
/*#
|
|
Section: BitmapWidget
|
|
Desc: Widget Bitmap
|
|
#*/
|
|
/*#
|
|
Func: BitmapSetPicture
|
|
Proto: void:bitmap,string bitmap
|
|
Desc: Set bitmap widget bitmap from resource.
|
|
#*/
|
|
sq_register(vm, BitmapSetPicture, "BitmapSetPicture", _SC(".xs"));
|
|
|
|
/*#
|
|
Section: TextWidget
|
|
Desc: Widget Text
|
|
#*/
|
|
/*#
|
|
Func: TextSetAlignment
|
|
Proto: void:TextWidget,TextAlign align
|
|
Desc: Set widget text alignment method.
|
|
#*/
|
|
sq_register(vm, TextSetAlignment, "TextSetAlignment", _SC(".xn"));
|
|
/*#
|
|
Func: TextSetFormat
|
|
Proto: void:TextWidget,TextFormat format
|
|
Desc: Set widget text formatting method.
|
|
#*/
|
|
sq_register(vm, TextSetFormat, "TextSetFormat", _SC(".xn"));
|
|
/*#
|
|
Func: TextSetSize
|
|
Proto: void:TextWidget,int size
|
|
Desc: Set widget text font size.
|
|
#*/
|
|
sq_register(vm, TextSetSize, "TextSetSize", _SC(".xn"));
|
|
/*#
|
|
Func: TextSetColor
|
|
Proto: void:TextWidget,int r,int g,int b,int a
|
|
Desc: Set widget text color.
|
|
#*/
|
|
sq_register(vm, TextSetColor, "TextSetColor", _SC(".xnnnn"));
|
|
/*#
|
|
Func: TextSetText
|
|
Proto: void:TextWidget,string text
|
|
Desc: Set widget text.
|
|
#*/
|
|
sq_register(vm, TextSetText, "TextSetText", _SC(".xs"));
|
|
/*#
|
|
Func: TextSetParameters
|
|
Proto: void:TextWidget,table param
|
|
Desc: Set widget text parameters.<br>
|
|
The following table keys are available:<br>
|
|
<ul>
|
|
<li><b>'color'</b>: Hexadecimal RGBA (eg. Red: xff0000ff)
|
|
<li><b>'align'</b>: TextAlign
|
|
<li><b>'format'</b>: TextFormat
|
|
<li><b>'tracking'</b>: Integer value specifying an extra space between glyphs.
|
|
<li><b>'heading'</b>: Integer value specifying an extra space between lines.
|
|
</ul>
|
|
#*/
|
|
sq_register(vm, TextSetParameters, "TextSetParameters", _SC(".xt"));
|
|
|
|
/*#
|
|
Section: CheckWidget
|
|
Desc: Widget Check
|
|
#*/
|
|
/*#
|
|
Func: CheckWidgetSetLabel
|
|
Proto: void:check,string text
|
|
Desc: Set check widget text label.
|
|
#*/
|
|
sq_register(vm, CheckWidgetSetLabel, "CheckWidgetSetLabel", _SC(".xs"));
|
|
/*#
|
|
Func: CheckWidgetSetLabelFont
|
|
Proto: void:Check,Font font
|
|
Desc: Set check widget text font.
|
|
#*/
|
|
sq_register(vm, CheckWidgetSetLabelFont, "CheckWidgetSetLabelFont", _SC(".xx"));
|
|
/*#
|
|
Func: CheckWidgetSetLabelSize
|
|
Proto: void:check,int size
|
|
Desc: Set check widget font size.
|
|
#*/
|
|
sq_register(vm, CheckWidgetSetLabelSize, "CheckWidgetSetLabelSize", _SC(".xn"));
|
|
/*#
|
|
Func: CheckWidgetSetState
|
|
Proto: void:check,bool state
|
|
Desc: Set check widget state.
|
|
#*/
|
|
sq_register(vm, CheckWidgetSetState, "CheckWidgetSetState", _SC(".xb"));
|
|
/*#
|
|
Func: CheckWidgetGetState
|
|
Proto: bool:check
|
|
Desc: Get check widget state.
|
|
#*/
|
|
sq_register(vm, CheckWidgetGetState, "CheckWidgetGetState", _SC(".x"));
|
|
/*#
|
|
Func: CheckWidgetGetText
|
|
Proto: string:check
|
|
Desc: Get check widget text label.
|
|
#*/
|
|
sq_register(vm, CheckWidgetGetText, "CheckWidgetGetText", _SC(".x"));
|
|
|
|
/*#
|
|
Section: MiscWidget
|
|
Desc: Widget
|
|
#*/
|
|
/*#
|
|
Func: WidgetToBitmap
|
|
Proto: bitmap:widget
|
|
Desc: Cast widget to bitmap widget.
|
|
#*/
|
|
sq_register(vm, WidgetToBitmap, "WidgetToBitmap", _SC(".x"));
|
|
/*#
|
|
Func: WidgetToText
|
|
Proto: text:widget
|
|
Desc: Cast widget to static text widget.
|
|
#*/
|
|
sq_register(vm, WidgetToText, "WidgetToText", _SC(".x"));
|
|
/*#
|
|
Func: WidgetToCheck
|
|
Proto: check:widget
|
|
Desc: Cast widget to check widget.
|
|
#*/
|
|
sq_register(vm, WidgetToCheck, "WidgetToCheck", _SC(".x"));
|
|
|
|
/*#
|
|
Func: WidgetSetEventHandler
|
|
Proto: void:widget,UIEvent event,function callback
|
|
Desc: Set a native Squirrel function as the widget event callback.
|
|
#*/
|
|
sq_register(vm, WidgetSetEventHandler, "WidgetSetEventHandler", _SC(".xnc"));
|
|
/*#
|
|
Func: WidgetSetEventHandlerWithContext
|
|
Proto: void:widget,UIEvent event,instance context,function callback
|
|
Desc: Set a native Squirrel function in a specific context (ie. a class) as a widget event callback.
|
|
#*/
|
|
sq_register(vm, WidgetSetEventHandlerWithContext, "WidgetSetEventHandlerWithContext", _SC(".xn.c"));
|
|
/*#
|
|
Func: WidgetSetSensitive
|
|
Proto: void:widget,bool sensitive
|
|
Desc: Enable/disable mouse/keyboard event on a widget.
|
|
#*/
|
|
sq_register(vm, WidgetSetSensitive, "WidgetSetSensitive", _SC(".xb"));
|
|
/*#
|
|
Func: WidgetGetRect
|
|
Proto: rect:widget
|
|
Desc: Return widget rect in window space.
|
|
#*/
|
|
sq_register(vm, WidgetGetRect, "WidgetGetRect", _SC(".x"));
|
|
/*#
|
|
Func: WidgetSetHAlign
|
|
Proto: void:widget,WidgetAlign alignment
|
|
Desc: Set widget horizontal alignment.
|
|
#*/
|
|
sq_register(vm, WidgetSetHAlign, "WidgetSetHAlign", _SC(".xn"));
|
|
/*#
|
|
Func: WidgetSetVAlign
|
|
Proto: void:widget,WidgetAlign alignment
|
|
Desc: Set widget vertical alignment.
|
|
#*/
|
|
sq_register(vm, WidgetSetVAlign, "WidgetSetVAlign", _SC(".xn"));
|
|
/*#
|
|
Func: WidgetSetHidden
|
|
Proto: void:widget,bool hidden
|
|
Desc: Show/hide widget.
|
|
#*/
|
|
sq_register(vm, WidgetSetHidden, "WidgetSetHidden", _SC(".xb"));
|
|
/*#
|
|
Func: WidgetIsHidden
|
|
Proto: bool:widget
|
|
Desc: Return true if the widget is hidden, false otherwise.
|
|
#*/
|
|
sq_register(vm, WidgetIsHidden, "WidgetIsHidden", _SC(".x"));
|
|
/*#
|
|
Func: WidgetSetFormattingSize
|
|
Proto: void:widget,float ratio_x,float ratio_y
|
|
Desc: Set widget formatting size ratio.
|
|
#*/
|
|
sq_register(vm, WidgetSetFormattingSize, "WidgetSetFormattingSize", _SC(".xnn"));
|
|
/*#
|
|
Func: CastToWidget
|
|
Proto: Widget:WidgetDerived
|
|
Desc: Cast any complex widget (such as containers, sizer, etc...) to its base widget.
|
|
#*/
|
|
sq_register(vm, CastToWidget, "CastToWidget", _SC(".x"));
|
|
|
|
// Push defines.
|
|
sq_pushroottable(vm);
|
|
|
|
sq_pushstring(vm, "NullWindow", -1); CObject::Push(vm, NULL, typetag_Window); sq_newslot(vm, -3, true);
|
|
|
|
/*#
|
|
Enum: SpriteStyle
|
|
Values: StyleBlendAdditive,StyleBlendOpaque,StyleNonSensitive,StyleResolutionInvariant,
|
|
StyleNoDecoration,StyleTransformUV,StyleNoTitleBar,StyleMovable,StyleSnapToPixel
|
|
#*/
|
|
sq_pushstring(vm, "StyleBlendAdditive", -1); sq_pushinteger(vm, Sprite::FlagBlendAdditive); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "StyleNonSensitive", -1); sq_pushinteger(vm, Sprite::FlagNonSensitive); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "StyleResolutionInvariant", -1); sq_pushinteger(vm, Sprite::FlagResolutionInvariant); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "StyleTransformUV", -1); sq_pushinteger(vm, Sprite::FlagTransformUV); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "StyleSnapToPixel", -1); sq_pushinteger(vm, Sprite::FlagSnapToPixel); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "StyleBlendOpaque", -1); sq_pushinteger(vm, Sprite::FlagBlendOpaque); sq_newslot(vm, -3, true);
|
|
#if 1
|
|
sq_pushstring(vm, "StyleNoBlend", -1); sq_pushinteger(vm, Sprite::FlagBlendOpaque); sq_newslot(vm, -3, true); // COMPAT
|
|
#endif
|
|
|
|
/*#
|
|
Enum: WindowStyle
|
|
Values: StyleNoDecoration,StyleNoTitleBar
|
|
#*/
|
|
sq_pushstring(vm, "StyleNoDecoration", -1); sq_pushinteger(vm, Window::FlagNoDecoration); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "StyleNoTitleBar", -1); sq_pushinteger(vm, Window::FlagNoTitleBar); sq_newslot(vm, -3, true);
|
|
|
|
/*#
|
|
Enum: WidgetAlign
|
|
Values: WidgetAlignDefault,WidgetAlignLeft,WidgetAlignTop,WidgetAlignMiddle,WidgetAlignRight,WidgetAlignBottom
|
|
#*/
|
|
sq_pushstring(vm, "WidgetAlignDefault", -1); sq_pushinteger(vm, Widget::AlignNone); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "WidgetAlignLeft", -1); sq_pushinteger(vm, Widget::AlignLeft); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "WidgetAlignTop", -1); sq_pushinteger(vm, Widget::AlignTop); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "WidgetAlignMiddle", -1); sq_pushinteger(vm, Widget::AlignMiddle); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "WidgetAlignRight", -1); sq_pushinteger(vm, Widget::AlignRight); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "WidgetAlignBottom", -1); sq_pushinteger(vm, Widget::AlignBottom); sq_newslot(vm, -3, true);
|
|
|
|
/*#
|
|
Enum: TextAlign
|
|
Desc: Text alignment.
|
|
Values: TextAlignLeft,TextAlignRight,TextAlignCenter,TextAlignJustify
|
|
#*/
|
|
sq_pushstring(vm, "TextAlignLeft", -1); sq_pushinteger(vm, TextState::Left); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "TextAlignRight", -1); sq_pushinteger(vm, TextState::Right); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "TextAlignCenter", -1); sq_pushinteger(vm, TextState::Center); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "TextAlignJustify", -1); sq_pushinteger(vm, TextState::Justify); sq_newslot(vm, -3, true);
|
|
|
|
/*#
|
|
Enum: TextFormat
|
|
Desc: Text formatting.
|
|
Values: TextFormatStandard,TextFormatParagraph,TextFormatLine,TextFormatColumn
|
|
#*/
|
|
sq_pushstring(vm, "TextFormatStandard", -1); sq_pushinteger(vm, TextState::Line); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "TextFormatLine", -1); sq_pushinteger(vm, TextState::Line); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "TextFormatParagraph", -1); sq_pushinteger(vm, TextState::Paragraph); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "TextFormatColumn", -1); sq_pushinteger(vm, TextState::Column); sq_newslot(vm, -3, true);
|
|
|
|
/*#
|
|
Enum: UIEvent
|
|
Values: EventCursorDown,EventCursorHit,EventCursorUp,
|
|
EventCursorEnter,EventCursorLeave,EventCursorMove
|
|
#*/
|
|
sq_pushstring(vm, "EventCursorDown", -1); sq_pushinteger(vm, Event_CursorDown); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "EventCursorHit", -1); sq_pushinteger(vm, Event_CursorHit); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "EventCursorUp", -1); sq_pushinteger(vm, Event_CursorUp); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "EventCursorEnter", -1); sq_pushinteger(vm, Event_CursorEnter); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "EventCursorLeave", -1); sq_pushinteger(vm, Event_CursorLeave); sq_newslot(vm, -3, true);
|
|
sq_pushstring(vm, "EventCursorMove", -1); sq_pushinteger(vm, Event_CursorMove); sq_newslot(vm, -3, true);
|
|
|
|
sq_pop(vm, 1);
|
|
}
|