1205 lines
57 KiB
C++
Executable File
1205 lines
57 KiB
C++
Executable File
/** \file
|
|
* \brief Name space for C++ high level API
|
|
*
|
|
* See Copyright Notice in iup.h
|
|
*/
|
|
|
|
#ifndef __IUP_PLUS_H
|
|
#define __IUP_PLUS_H
|
|
|
|
|
|
#include "iup.h"
|
|
#include "iupkey.h"
|
|
#include "iupdraw.h"
|
|
#include "iup_class_cbs.hpp"
|
|
#include "iupcontrols.h"
|
|
#include "iupgl.h"
|
|
#include "iupglcontrols.h"
|
|
#include "iupim.h"
|
|
#include "iup_config.h"
|
|
#include "iup_mglplot.h"
|
|
#include "iup_plot.h"
|
|
#include "iupole.h"
|
|
#include "iupweb.h"
|
|
#include "iup_scintilla.h"
|
|
#include "iuptuio.h"
|
|
|
|
|
|
|
|
/** \brief Name space for C++ high level API
|
|
*
|
|
* \par
|
|
* Defines wrapper classes for all C structures.
|
|
*
|
|
* See \ref iup_plus.h
|
|
*/
|
|
namespace Iup
|
|
{
|
|
inline char* Version() { return IupVersion(); }
|
|
inline char* VersionDate() { return IupVersionDate(); }
|
|
inline int VersionNumber() { return IupVersionNumber(); }
|
|
|
|
inline int Open(int &argc, char **&argv) { return IupOpen(&argc, &argv); }
|
|
inline void Close() { IupClose(); }
|
|
inline void ImageLibOpen() { IupImageLibOpen(); }
|
|
|
|
inline int MainLoop() { return IupMainLoop(); }
|
|
inline int LoopStep() { return IupLoopStep(); }
|
|
inline int LoopStepWait() { return IupLoopStepWait(); }
|
|
inline int MainLoopLevel() { return IupMainLoopLevel(); }
|
|
inline void Flush() { IupFlush(); }
|
|
inline void ExitLoop() { IupExitLoop(); }
|
|
|
|
inline int RecordInput(const char* filename, int mode) { return IupRecordInput(filename, mode); }
|
|
inline int PlayInput(const char* filename) { return IupPlayInput(filename); }
|
|
|
|
inline int Help(const char* url) { return IupHelp(url); }
|
|
inline void Log(const char* type, const char* str) { IupLog(type, "%s", str); }
|
|
inline const char* Load(const char *filename) { return IupLoad(filename); }
|
|
inline const char* LoadBuffer(const char *buffer) { return IupLoadBuffer(buffer); }
|
|
|
|
inline void SetLanguage(const char *lng) { IupSetLanguage(lng); }
|
|
inline const char* GetLanguage() { return IupGetLanguage(); }
|
|
inline void SetLanguageString(const char* name, const char* str) { IupSetLanguageString(name, str); }
|
|
inline void StoreLanguageString(const char* name, const char* str) { IupStoreLanguageString(name, str); }
|
|
inline const char* GetLanguageString(const char* name) { return IupGetLanguageString(name); }
|
|
|
|
inline int GetAllClasses(char** names, int n) { return IupGetAllClasses(names, n); }
|
|
inline int GetClassAttributes(const char* classname, char** names, int n) { return IupGetClassAttributes(classname, names, n); }
|
|
inline int GetClassCallbacks(const char* classname, char** names, int n) { return IupGetClassCallbacks(classname, names, n); }
|
|
inline void SetClassDefaultAttribute(const char* classname, const char *name, const char* value) { IupSetClassDefaultAttribute(classname, name, value); }
|
|
|
|
inline void SetGlobal(const char* name, const char* value) { IupSetGlobal(name, value); }
|
|
inline void SetStringGlobal(const char* name, const char* value) { IupSetStrGlobal(name, value); }
|
|
inline char* GetGlobal(const char* name) { return IupGetGlobal(name); }
|
|
|
|
inline int GetFile(char* filename) { return IupGetFile(filename); }
|
|
inline void Message(const char *title, const char *msg) { IupMessage(title, msg); }
|
|
inline int Alarm(const char *title, const char *msg, const char *b1, const char *b2, const char *b3) { return IupAlarm(title, msg, b1, b2, b3); }
|
|
inline int ListDialog(int type, const char *title, int size, const char** list, int op, int max_col, int max_lin, int* marks) { return IupListDialog(type, title, size, list, op, max_col, max_lin, marks); }
|
|
inline int GetText(const char* title, char* text, int maxsize = 10240) { return IupGetText(title, text, maxsize); }
|
|
inline int GetColor(int x, int y, unsigned char &r, unsigned char &g, unsigned char &b) { return IupGetColor(x, y, &r, &g, &b); }
|
|
inline int GetParamv(const char* title, Iparamcb action, void* user_data, const char* format, int param_count, int param_extra, void** param_data)
|
|
{ return IupGetParamv(title, action, user_data, format, param_count, param_extra, param_data); }
|
|
|
|
inline int GetAllNames(char** names, int n) { return IupGetAllNames(names, n); }
|
|
inline int GetAllDialogs(char** names, int n) { return IupGetAllDialogs(names, n); }
|
|
|
|
|
|
class Element
|
|
{
|
|
protected:
|
|
Ihandle* ih;
|
|
|
|
/* forbidden */
|
|
Element() { ih = 0; };
|
|
|
|
public:
|
|
Element(Ihandle* ref_ih) { ih = ref_ih; }
|
|
Element(const Element& elem) : Element(elem.ih) {}
|
|
|
|
virtual ~Element()
|
|
{
|
|
// The destructor does not destroy the element because all Iup::Element are just a reference to the Ihandle*,
|
|
// since several IUP elements are automatically destroyed when the dialog is destroyed.
|
|
// So to force an element to be destroyed explicitly call the Destroy method.
|
|
}
|
|
|
|
Ihandle* GetHandle() const { return ih; }
|
|
|
|
bool Failed() const {
|
|
return ih == 0;
|
|
}
|
|
|
|
void SetAttribute(const char* name, const char* value) { IupSetAttribute(ih, name, value); }
|
|
char* GetAttribute(const char* name) { return IupGetAttribute(ih, name); }
|
|
void SetUserData(const char* name, void* data) { IupSetAttribute(ih, name, (char*)data); }
|
|
void* GetUserData(const char* name) { return (void*)IupGetAttribute(ih, name); }
|
|
void SetString(const char* name, const char* value) { IupSetStrAttribute(ih, name, value); }
|
|
const char* GetString(const char* name) { return IupGetAttribute(ih, name); }
|
|
void SetInteger(const char* name, int value) { IupSetInt(ih, name, value); }
|
|
int GetInteger(const char* name) { return IupGetInt(ih, name); }
|
|
void GetIntegerInteger(const char* name, int &i1, int &i2) { IupGetIntInt(ih, name, &i1, &i2); }
|
|
void SetNumber(const char* name, double value) { IupSetDouble(ih, name, value); }
|
|
double GetNumber(const char* name) { return IupGetDouble(ih, name); }
|
|
void SetRGB(const char* name, unsigned char r, unsigned char g, unsigned char b) { IupSetRGB(ih, name, r, g, b); }
|
|
void GetRGB(const char* name, unsigned char &r, unsigned char &g, unsigned char &b) { IupGetRGB(ih, name, &r, &g, &b); }
|
|
void SetRGBA(const char* name, unsigned char r, unsigned char g, unsigned char b, unsigned char a) { IupSetRGBA(ih, name, r, g, b, a); }
|
|
void GetRGBA(const char* name, unsigned char &r, unsigned char &g, unsigned char &b, unsigned char &a) { IupGetRGBA(ih, name, &r, &g, &b, &a); }
|
|
|
|
void SetAttributeId(const char* name, int id, const char* value) { IupSetAttributeId(ih, name, id, value); }
|
|
char* GetAttributeId(const char* name, int id) { return IupGetAttributeId(ih, name, id); }
|
|
void SetUserDataId(const char* name, int id, void* data) { IupSetAttributeId(ih, name, id, (char*)data); }
|
|
void* GetUserDataId(const char* name, int id) { return (void*)IupGetAttributeId(ih, name, id); }
|
|
void SetStringId(const char* name, int id, const char* value) { IupSetStrAttributeId(ih, name, id, value); }
|
|
const char* GetStringId(const char* name, int id) { return IupGetAttributeId(ih, name, id); }
|
|
void SetIntegerId(const char* name, int id, int value) { IupSetIntId(ih, name, id, value); }
|
|
int GetIntegerId(const char* name, int id) { return IupGetIntId(ih, name, id); }
|
|
void SetNumberId(const char* name, int id, double value) { IupSetDoubleId(ih, name, id, value); }
|
|
double GetNumberId(const char* name, int id) { return IupGetDoubleId(ih, name, id); }
|
|
void SetRGBId(const char* name, int id, unsigned char r, unsigned char g, unsigned char b) { IupSetRGBId(ih, name, id, r, g, b); }
|
|
void GetRGBId(const char* name, int id, unsigned char &r, unsigned char &g, unsigned char &b) { IupGetRGBId(ih, name, id, &r, &g, &b); }
|
|
|
|
void SetAttributeId2(const char* name, int lin, int col, const char* value) { IupSetAttributeId2(ih, name, lin, col, value); }
|
|
char* GetAttributeId2(const char* name, int lin, int col) { return IupGetAttributeId2(ih, name, lin, col); }
|
|
void SetUserDataId2(const char* name, int lin, int col, void* data) { IupSetAttributeId2(ih, name, lin, col, (char*)data); }
|
|
void* GetUserDataId2(const char* name, int lin, int col) { return (void*)IupGetAttributeId2(ih, name, lin, col); }
|
|
void SetStringId2(const char* name, int lin, int col, const char* value) { IupSetStrAttributeId2(ih, name, lin, col, value); }
|
|
const char* GetStringId2(const char* name, int lin, int col) { return IupGetAttributeId2(ih, name, lin, col); }
|
|
void SetIntegerId2(const char* name, int lin, int col, int value) { IupSetIntId2(ih, name, lin, col, value); }
|
|
int GetIntegerId2(const char* name, int lin, int col) { return IupGetIntId2(ih, name, lin, col); }
|
|
void SetNumberId2(const char* name, int lin, int col, double value) { IupSetDoubleId2(ih, name, lin, col, value); }
|
|
double GetNumberId2(const char* name, int lin, int col) { return IupGetDoubleId2(ih, name, lin, col); }
|
|
void SetRGBId2(const char* name, int lin, int col, unsigned char r, unsigned char g, unsigned char b) { IupSetRGBId2(ih, name, lin, col, r, g, b); }
|
|
void GetRGBId2(const char* name, int lin, int col, unsigned char &r, unsigned char &g, unsigned char &b) { IupGetRGBId2(ih, name, lin, col, &r, &g, &b); }
|
|
|
|
Element SetAttributes(const char* str) { return IupSetAttributes(ih, str); }
|
|
void ResetAttribute(const char* name) { IupResetAttribute(ih, name); }
|
|
int GetAllAttributes(char** names, int n) { return IupGetAllAttributes(ih, names, n); }
|
|
void CopyAttributes(Ihandle* dst_ih) { IupCopyAttributes(ih, dst_ih); }
|
|
void SetAttributeHandle(const char* name, const Element& elem) { IupSetAttributeHandle(ih, name, elem.GetHandle()); }
|
|
Element GetAttributeHandle(const char* name) { return IupGetAttributeHandle(ih, name); }
|
|
void SetAttributeHandleId(const char* name, int id, const Element& elem) { IupSetAttributeHandleId(ih, name, id, elem.GetHandle()); }
|
|
Element GetAttributeHandleId(const char* name, int id) { return IupGetAttributeHandleId(ih, name, id); }
|
|
void SetAttributeHandleId2(const char* name, int lin, int col, const Element& elem) { IupSetAttributeHandleId2(ih, name, lin, col, elem.GetHandle()); }
|
|
Element GetAttributeHandleId2(const char* name, int lin, int col) { return IupGetAttributeHandleId2(ih, name, lin, col); }
|
|
|
|
Icallback GetCallback(const char *name) { return IupGetCallback(ih, name); }
|
|
Icallback SetCallback(const char *name, Icallback func) { return IupSetCallback(ih, name, func); }
|
|
|
|
void Destroy() { IupDestroy(ih); }
|
|
|
|
int Map() { return IupMap(ih); }
|
|
void Unmap() { IupUnmap(ih); }
|
|
|
|
char* GetName() { return IupGetName(ih); }
|
|
|
|
char* GetClassName() { return IupGetClassName(ih); }
|
|
char* GetClassType() { return IupGetClassType(ih); }
|
|
void SaveClassAttributes() { IupSaveClassAttributes(ih); }
|
|
void CopyClassAttributesTo(const Element& dst) { IupCopyClassAttributes(ih, dst.ih); }
|
|
int ClassMatch(const char* classname) { return IupClassMatch(ih, classname); }
|
|
|
|
};
|
|
|
|
inline Icallback GetFunction(const char *name) { return IupGetFunction(name); }
|
|
inline Icallback SetFunction(const char *name, Icallback func) { return IupSetFunction(name, func); }
|
|
inline Element GetHandle(const char *name) { return Element(IupGetHandle(name)); }
|
|
inline Element SetHandle(const char *name, const Element& elem) { return Element(IupSetHandle(name, elem.GetHandle())); }
|
|
inline void SetLanguagePack(const Element& elem) { IupSetLanguagePack(elem.GetHandle()); }
|
|
|
|
class Dialog;
|
|
class Container;
|
|
|
|
class Control : public Element
|
|
{
|
|
public:
|
|
Control(Ihandle* _ih) : Element(_ih) {}
|
|
Control(const Control& control) : Element(control.ih) {}
|
|
Control(const Element& elem) : Element(elem.GetHandle()) {}
|
|
|
|
Control SetAttributes(const char* str) { IupSetAttributes(ih, str); return *this; }
|
|
|
|
void Update() { IupUpdate(ih); }
|
|
void Redraw() { IupRedraw(ih, 0); }
|
|
void Refresh() { IupRefresh(ih); }
|
|
|
|
void Detach(const Control& child) { IupDetach(child.ih); }
|
|
|
|
Control GetBrother() { return Control(IupGetBrother(ih)); }
|
|
Container GetParent();
|
|
Dialog GetDialog();
|
|
Control GetDialogChild(const char* name) { return Control(IupGetDialogChild(ih, name)); }
|
|
int Reparent(const Container& new_parent, const Control& ref_child);
|
|
|
|
Control SetFocus() { return Control(IupSetFocus(ih)); }
|
|
Control PreviousField() { return Control(IupPreviousField(ih)); }
|
|
Control NextField() { return Control(IupNextField(ih)); }
|
|
|
|
void ConvertLinColToPos(int lin, int col, int &pos) { IupTextConvertLinColToPos(ih, lin, col, &pos); }
|
|
void ConvertPosToLinCol(int pos, int &lin, int &col) { IupTextConvertPosToLinCol(ih, pos, &lin, &col); }
|
|
int ConvertXYToPos(int x, int y) { return IupConvertXYToPos(ih, x, y); }
|
|
};
|
|
|
|
inline Control GetFocus() { return Control(IupGetFocus()); }
|
|
|
|
class Container : public Control
|
|
{
|
|
public:
|
|
Container(Ihandle* _ih) : Control(_ih) {}
|
|
Container(const Container& container) : Control(container.ih) {}
|
|
Container(const Control& control) : Control(control.GetHandle()) {}
|
|
Container(const Element& elem) : Control(elem.GetHandle()) {}
|
|
|
|
Container(Ihandle* _ih, const Control* child_array, int count) : Control(_ih) {
|
|
for (int i = 0; i < count; i++)
|
|
IupAppend(ih, child_array[i].GetHandle());
|
|
}
|
|
Container(Ihandle* _ih, Control child0, Control child1 = (Ihandle*)0, Control child2 = (Ihandle*)0, Control child3 = (Ihandle*)0, Control child4 = (Ihandle*)0, Control child5 = (Ihandle*)0, Control child6 = (Ihandle*)0, Control child7 = (Ihandle*)0, Control child8 = (Ihandle*)0, Control child9 = (Ihandle*)0)
|
|
: Control(_ih) {
|
|
if (!child0.Failed()) IupAppend(ih, child0.GetHandle());
|
|
if (!child1.Failed()) IupAppend(ih, child1.GetHandle());
|
|
if (!child2.Failed()) IupAppend(ih, child2.GetHandle());
|
|
if (!child3.Failed()) IupAppend(ih, child3.GetHandle());
|
|
if (!child4.Failed()) IupAppend(ih, child4.GetHandle());
|
|
if (!child5.Failed()) IupAppend(ih, child5.GetHandle());
|
|
if (!child6.Failed()) IupAppend(ih, child6.GetHandle());
|
|
if (!child7.Failed()) IupAppend(ih, child7.GetHandle());
|
|
if (!child8.Failed()) IupAppend(ih, child8.GetHandle());
|
|
if (!child9.Failed()) IupAppend(ih, child9.GetHandle());
|
|
}
|
|
|
|
Control Append(const Control& child) { return IupAppend(ih, child.GetHandle()); }
|
|
Control Insert(const Control& ref_child, const Control& child) { return IupInsert(ih, ref_child.GetHandle(), child.GetHandle()); }
|
|
Control GetChild(int pos) { return IupGetChild(ih, pos); }
|
|
int GetChildPos(const Control& child) { return IupGetChildPos(ih, child.GetHandle()); }
|
|
int GetChildCount() { return IupGetChildCount(ih); }
|
|
|
|
Control GetFirstChild() { return Control(IupGetNextChild(ih, 0)); }
|
|
Control GetNextChild(const Control& ref_child) { return Control(IupGetNextChild(ih, ref_child.GetHandle())); }
|
|
|
|
void UpdateChildren() { IupUpdateChildren(ih); }
|
|
void RedrawChildren() { IupRedraw(ih, 1); }
|
|
void RefreshChildren() { IupRefreshChildren(ih); }
|
|
};
|
|
|
|
class Dialog : public Container
|
|
{
|
|
public:
|
|
Dialog(const Dialog& dialog) : Container(dialog.GetHandle()) {}
|
|
Dialog(const Element& elem) : Container(elem.GetHandle()) {}
|
|
Dialog(Control child) : Container(IupDialog(child.GetHandle())) { }
|
|
Dialog(Container child) : Container(IupDialog(child.GetHandle())) { }
|
|
Dialog(Ihandle* _ih) : Container(_ih) {}
|
|
|
|
int Popup(int x, int y) { return IupPopup(ih, x, y); }
|
|
int Show() { return IupShow(ih); }
|
|
int ShowXY(int x, int y) { return IupShowXY(ih, x, y); }
|
|
int Hide() { return IupHide(ih); }
|
|
};
|
|
|
|
inline Dialog Control::GetDialog() { return Dialog(IupGetDialog(ih)); }
|
|
inline Dialog LayoutDialog(const Dialog& dialog) { return Dialog(IupLayoutDialog(dialog.GetHandle())); }
|
|
inline Dialog GlobalsDialog() { return Dialog(IupGlobalsDialog()); }
|
|
inline Dialog ElementPropertiesDialog(const Dialog& parent, const Control& control) { return Dialog(IupElementPropertiesDialog(parent.GetHandle(), control.GetHandle())); }
|
|
inline Dialog ElementPropertiesDialog(const Control& control) { return Dialog(IupElementPropertiesDialog(0, control.GetHandle())); }
|
|
inline Dialog ClassInfoDialog(const Dialog& parent) { return Dialog(IupClassInfoDialog(parent.GetHandle())); }
|
|
inline Container Control::GetParent() { return Container(IupGetParent(ih)); }
|
|
inline int Control::Reparent(const Container& new_parent, const Control& ref_child) { return IupReparent(ih, new_parent.GetHandle(), ref_child.GetHandle()); }
|
|
|
|
void MessageError(const Dialog& parent, const char* message)
|
|
{ IupMessageError(parent.GetHandle(), message); }
|
|
int MessageAlarm(const Dialog& parent, const char* title, const char* message, const char* buttons)
|
|
{ return IupMessageAlarm(parent.GetHandle(), title, message, buttons); }
|
|
|
|
class Menu : public Container
|
|
{
|
|
public:
|
|
Menu() : Container(IupMenu(0)) {}
|
|
Menu(Control child0, Control child1 = (Ihandle*)0, Control child2 = (Ihandle*)0, Control child3 = (Ihandle*)0, Control child4 = (Ihandle*)0, Control child5 = (Ihandle*)0, Control child6 = (Ihandle*)0, Control child7 = (Ihandle*)0, Control child8 = (Ihandle*)0, Control child9 = (Ihandle*)0)
|
|
: Container(IupMenu(0), child0, child1, child2, child3, child4, child5, child6, child7, child8, child9) {}
|
|
Menu(const Control *child_array, int count) : Container(IupMenu(0), child_array, count) {}
|
|
Menu(const Menu& menu) : Container(menu.GetHandle()) {}
|
|
Menu(Ihandle* _ih) : Container(_ih) {}
|
|
|
|
int Popup(int x, int y) { return IupPopup(ih, x, y); }
|
|
};
|
|
|
|
class Image : public Element
|
|
{
|
|
public:
|
|
Image(Ihandle* _ih) : Element(_ih) {}
|
|
Image(const Element& elem) : Element(elem.GetHandle()) {}
|
|
Image(const char* name) : Element(IupImageGetHandle(name)) {}
|
|
|
|
int SaveAsText(const char* filename, const char* iup_format, const char* name) { return IupSaveImageAsText(ih, filename, iup_format, name); }
|
|
|
|
#ifdef __IM_PLUS_H
|
|
Image(const im::Image& image) : Element(IupImageFromImImage(image.GetHandle())) {}
|
|
Image Load(const char* filename) { return Image(IupLoadImage(filename)); }
|
|
int Save(const char* filename, const char* im_format) { return IupSaveImage(ih, filename, im_format); }
|
|
im::Image ToImImage() { return im::Image(IupImageToImImage(GetHandle())); }
|
|
#endif
|
|
};
|
|
class Clipboard : public Element
|
|
{
|
|
public:
|
|
Clipboard() : Element(IupClipboard()) {}
|
|
Clipboard(Ihandle* _ih) : Element(_ih) {}
|
|
Clipboard(const Element& elem) : Element(elem.GetHandle()) {}
|
|
|
|
#ifdef __IM_PLUS_H
|
|
void SetImage(const im::Image& image) { SetUserData("NATIVEIMAGE", IupGetImageNativeHandle(image.GetHandle())); }
|
|
im::Image GetImage(void) { return im::Image(IupGetNativeHandleImage(GetUserData("NATIVEIMAGE"))); }
|
|
#endif
|
|
};
|
|
class User : public Element
|
|
{
|
|
public:
|
|
User() : Element(IupUser()) {}
|
|
User(Ihandle* _ih) : Element(_ih) {}
|
|
User(const Element& elem) : Element(elem.GetHandle()) {}
|
|
};
|
|
class Thread : public Element
|
|
{
|
|
public:
|
|
Thread() : Element(IupThread()) {}
|
|
Thread(Ihandle* _ih) : Element(_ih) {}
|
|
Thread(const Element& elem) : Element(elem.GetHandle()) {}
|
|
};
|
|
class Param : public Element
|
|
{
|
|
public:
|
|
Param(const char* format) : Element(IupParam(format)) {}
|
|
Param(Ihandle* _ih) : Element(_ih) {}
|
|
Param(const Element& elem) : Element(elem.GetHandle()) {}
|
|
};
|
|
class Timer : public Element
|
|
{
|
|
public:
|
|
Timer() : Element(IupTimer()) {}
|
|
Timer(Ihandle* _ih) : Element(_ih) {}
|
|
Timer(const Element& elem) : Element(elem.GetHandle()) {}
|
|
};
|
|
class Separator : public Control
|
|
{
|
|
public:
|
|
Separator() : Control(IupSeparator()) {}
|
|
Separator(Ihandle* _ih) : Control(_ih) {}
|
|
Separator(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class Item : public Control
|
|
{
|
|
public:
|
|
Item(const char* title = 0) : Control(IupItem(title, 0)) {}
|
|
Item(Ihandle* _ih) : Control(_ih) {}
|
|
Item(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class Canvas : public Control
|
|
{
|
|
public:
|
|
Canvas() : Control(IupCanvas(0)) {}
|
|
Canvas(Ihandle* _ih) : Control(_ih) {}
|
|
Canvas(const Element& elem) : Control(elem.GetHandle()) {}
|
|
|
|
void DrawBegin() { IupDrawBegin(ih); }
|
|
void DrawEnd() { IupDrawEnd(ih); }
|
|
void DrawSetClipRect(int x1, int y1, int x2, int y2) { IupDrawSetClipRect(ih, x1, y1, x2, y2); }
|
|
void DrawGetClipRect(int *x1, int *y1, int *x2, int *y2) { IupDrawGetClipRect(ih, x1, y1, x2, y2); }
|
|
void DrawResetClip() { IupDrawResetClip(ih); }
|
|
void DrawParentBackground() { IupDrawParentBackground(ih); }
|
|
void DrawLine(int x1, int y1, int x2, int y2) { IupDrawLine(ih, x1, y1, x2, y2); }
|
|
void DrawRectangle(int x1, int y1, int x2, int y2) { IupDrawRectangle(ih, x1, y1, x2, y2); }
|
|
void DrawArc(int x1, int y1, int x2, int y2, double a1, double a2) { IupDrawArc(ih, x1, y1, x2, y2, a1, a2); }
|
|
void DrawPolygon(int* points, int count) { IupDrawPolygon(ih, points, count); }
|
|
void DrawText(const char* text, int len, int x, int y, int w, int h) { IupDrawText(ih, text, len, x, y, w, h); }
|
|
void DrawImage(const char* name, int x, int y, int w, int h) { IupDrawImage(ih, name, x, y, w, h); }
|
|
void DrawSelectRect(int x1, int y1, int x2, int y2) { IupDrawSelectRect(ih, x1, y1, x2, y2); }
|
|
void DrawFocusRect(int x1, int y1, int x2, int y2) { IupDrawFocusRect(ih, x1, y1, x2, y2); }
|
|
void DrawGetSize(int &w, int &h) { IupDrawGetSize(ih, &w, &h); }
|
|
void DrawGetTextSize(const char* str, int len, int &w, int &h) { IupDrawGetTextSize(ih, str, len, &w, &h); }
|
|
void DrawGetImageInfo(const char* name, int &w, int &h, int &bpp) { IupDrawGetImageInfo(name, &w, &h, &bpp); }
|
|
};
|
|
class Link : public Control
|
|
{
|
|
public:
|
|
Link(const char* url = 0, const char* title = 0) : Control(IupLink(url, title)) {}
|
|
Link(Ihandle* _ih) : Control(_ih) {}
|
|
Link(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class Label : public Control
|
|
{
|
|
public:
|
|
Label(const char* title = 0) : Control(IupLabel(title)) {}
|
|
Label(Ihandle* _ih) : Control(_ih) {}
|
|
Label(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
|
|
class Button : public Control
|
|
{
|
|
public:
|
|
Button(const char* title = 0) : Control(IupButton(title, 0)) {}
|
|
Button(Ihandle* _ih) : Control(_ih) {}
|
|
Button(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class FlatButton : public Control
|
|
{
|
|
public:
|
|
FlatButton(const char* title = 0) : Control(IupFlatButton(title)) {}
|
|
FlatButton(Ihandle* _ih) : Control(_ih) {}
|
|
FlatButton(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class FlatToggle : public Control
|
|
{
|
|
public:
|
|
FlatToggle(const char* title = 0) : Control(IupFlatToggle(title)) {}
|
|
FlatToggle(Ihandle* _ih) : Control(_ih) {}
|
|
FlatToggle(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class FlatSeparator : public Control
|
|
{
|
|
public:
|
|
FlatSeparator() : Control(IupFlatSeparator()) {}
|
|
FlatSeparator(Ihandle* _ih) : Control(_ih) {}
|
|
FlatSeparator(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class Space : public Control
|
|
{
|
|
public:
|
|
Space() : Control(IupSpace()) {}
|
|
Space(Ihandle* _ih) : Control(_ih) {}
|
|
Space(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class DropButton : public Control
|
|
{
|
|
public:
|
|
DropButton() : Control(IupDropButton(0)) {}
|
|
DropButton(Control child) : Control(IupDropButton(child.GetHandle())) {}
|
|
DropButton(Ihandle* _ih) : Control(_ih) {}
|
|
DropButton(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class FlatLabel : public Control
|
|
{
|
|
public:
|
|
FlatLabel(const char* title = 0) : Control(IupFlatLabel(title)) {}
|
|
FlatLabel(Ihandle* _ih) : Control(_ih) {}
|
|
FlatLabel(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class AnimatedLabel : public Control
|
|
{
|
|
public:
|
|
AnimatedLabel(Element animation = (Ihandle*)0) : Control(IupAnimatedLabel(animation.GetHandle())) {}
|
|
AnimatedLabel(Ihandle* _ih) : Control(_ih) {}
|
|
AnimatedLabel(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class Toggle : public Control
|
|
{
|
|
public:
|
|
Toggle(const char* title = 0) : Control(IupToggle(title, 0)) {}
|
|
Toggle(Ihandle* _ih) : Control(_ih) {}
|
|
Toggle(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class Fill: public Control
|
|
{
|
|
public:
|
|
Fill() : Control(IupFill()) {}
|
|
Fill(Ihandle* _ih) : Control(_ih) {}
|
|
Fill(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class Spin: public Control
|
|
{
|
|
public:
|
|
Spin() : Control(IupSpin()) {}
|
|
Spin(Ihandle* _ih) : Control(_ih) {}
|
|
Spin(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class Tree: public Control
|
|
{
|
|
public:
|
|
Tree() : Control(IupTree()) {}
|
|
Tree(Ihandle* _ih) : Control(_ih) {}
|
|
Tree(const Element& elem) : Control(elem.GetHandle()) {}
|
|
|
|
int SetUserId(int id, void* userid) { return IupTreeSetUserId(ih, id, userid); }
|
|
void* GetUserId(int id) { return IupTreeGetUserId(ih, id); }
|
|
int GetId(void *userid) { return IupTreeGetId(ih, userid); }
|
|
};
|
|
class Val : public Control
|
|
{
|
|
public:
|
|
Val(const char* orientation = 0) : Control(IupVal(orientation)) {}
|
|
Val(Ihandle* _ih) : Control(_ih) {}
|
|
Val(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class FlatVal : public Control
|
|
{
|
|
public:
|
|
FlatVal(const char* orientation = 0) : Control(IupFlatVal(orientation)) {}
|
|
FlatVal(Ihandle* _ih) : Control(_ih) {}
|
|
FlatVal(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class FlatTree : public Control
|
|
{
|
|
public:
|
|
FlatTree() : Control(IupFlatTree()) {}
|
|
FlatTree(Ihandle* _ih) : Control(_ih) {}
|
|
FlatTree(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class ProgressBar : public Control
|
|
{
|
|
public:
|
|
ProgressBar() : Control(IupProgressBar()) {}
|
|
ProgressBar(Ihandle* _ih) : Control(_ih) {}
|
|
ProgressBar(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class List: public Control
|
|
{
|
|
public:
|
|
List() : Control(IupList(0)) {}
|
|
List(Ihandle* _ih) : Control(_ih) {}
|
|
List(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class FlatList : public Control
|
|
{
|
|
public:
|
|
FlatList() : Control(IupFlatList()) {}
|
|
FlatList(Ihandle* _ih) : Control(_ih) {}
|
|
FlatList(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class Text : public Control
|
|
{
|
|
public:
|
|
Text() : Control(IupText(0)) {}
|
|
Text(Ihandle* _ih) : Control(_ih) {}
|
|
Text(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
|
|
class Split : public Container
|
|
{
|
|
public:
|
|
Split() : Container(IupSplit(0, 0)) {}
|
|
Split(Control child) : Container(IupSplit(child.GetHandle(), 0)) {}
|
|
Split(Control child1, Control child2) : Container(IupSplit(child1.GetHandle(), child2.GetHandle())) {}
|
|
Split(const Split& split) : Container(split.GetHandle()) {}
|
|
Split(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class Submenu : public Container
|
|
{
|
|
public:
|
|
Submenu(const char* title = 0) : Container(IupSubmenu(title, 0)) {}
|
|
Submenu(const char* title, Control child) : Container(IupSubmenu(title, child.GetHandle())) {}
|
|
Submenu(const Submenu& container) : Container(container.GetHandle()) {}
|
|
Submenu(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class Radio : public Container
|
|
{
|
|
public:
|
|
Radio() : Container(IupRadio(0)) {}
|
|
Radio(Control child) : Container(IupRadio(child.GetHandle())) {}
|
|
Radio(const Radio& container) : Container(container.GetHandle()) {}
|
|
Radio(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class Sbox : public Container
|
|
{
|
|
public:
|
|
Sbox() : Container(IupSbox(0)) {}
|
|
Sbox(Control child) : Container(IupSbox(child.GetHandle())) {}
|
|
Sbox(const Sbox& container) : Container(container.GetHandle()) {}
|
|
Sbox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class ScrollBox : public Container
|
|
{
|
|
public:
|
|
ScrollBox() : Container(IupScrollBox(0)) {}
|
|
ScrollBox(Control child) : Container(IupScrollBox(child.GetHandle())) {}
|
|
ScrollBox(const ScrollBox& container) : Container(container.GetHandle()) {}
|
|
ScrollBox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class FlatScrollBox : public Container
|
|
{
|
|
public:
|
|
FlatScrollBox() : Container(IupFlatScrollBox(0)) {}
|
|
FlatScrollBox(Control child) : Container(IupFlatScrollBox(child.GetHandle())) {}
|
|
FlatScrollBox(const FlatScrollBox& container) : Container(container.GetHandle()) {}
|
|
FlatScrollBox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class Expander : public Container
|
|
{
|
|
public:
|
|
Expander(const Expander& container) : Container(container.GetHandle()) {}
|
|
Expander() : Container(IupExpander(0)) {}
|
|
Expander(Control child) : Container(IupExpander(child.GetHandle())) {}
|
|
Expander(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class DetachBox : public Container
|
|
{
|
|
public:
|
|
DetachBox(const DetachBox& container) : Container(container.GetHandle()) {}
|
|
DetachBox() : Container(IupDetachBox(0)) {}
|
|
DetachBox(Control child) : Container(IupDetachBox(child.GetHandle())) {}
|
|
DetachBox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class BackgroundBox : public Container
|
|
{
|
|
public:
|
|
BackgroundBox() : Container(IupBackgroundBox(0)) {}
|
|
BackgroundBox(Control child) : Container(IupBackgroundBox(child.GetHandle())) {}
|
|
BackgroundBox(const BackgroundBox& container) : Container(container.GetHandle()) {}
|
|
BackgroundBox(Ihandle* _ih) : Container(_ih) {}
|
|
|
|
void DrawBegin() { IupDrawBegin(ih); }
|
|
void DrawEnd() { IupDrawEnd(ih); }
|
|
void DrawSetClipRect(int x1, int y1, int x2, int y2) { IupDrawSetClipRect(ih, x1, y1, x2, y2); }
|
|
void DrawGetClipRect(int *x1, int *y1, int *x2, int *y2) { IupDrawGetClipRect(ih, x1, y1, x2, y2); }
|
|
void DrawResetClip() { IupDrawResetClip(ih); }
|
|
void DrawParentBackground() { IupDrawParentBackground(ih); }
|
|
void DrawLine(int x1, int y1, int x2, int y2) { IupDrawLine(ih, x1, y1, x2, y2); }
|
|
void DrawRectangle(int x1, int y1, int x2, int y2) { IupDrawRectangle(ih, x1, y1, x2, y2); }
|
|
void DrawArc(int x1, int y1, int x2, int y2, double a1, double a2) { IupDrawArc(ih, x1, y1, x2, y2, a1, a2); }
|
|
void DrawPolygon(int* points, int count) { IupDrawPolygon(ih, points, count); }
|
|
void DrawText(const char* text, int len, int x, int y, int w, int h) { IupDrawText(ih, text, len, x, y, w, h); }
|
|
void DrawImage(const char* name, int x, int y, int w, int h) { IupDrawImage(ih, name, x, y, w, h); }
|
|
void DrawSelectRect(int x1, int y1, int x2, int y2) { IupDrawSelectRect(ih, x1, y1, x2, y2); }
|
|
void DrawFocusRect(int x1, int y1, int x2, int y2) { IupDrawFocusRect(ih, x1, y1, x2, y2); }
|
|
void DrawGetSize(int &w, int &h) { IupDrawGetSize(ih, &w, &h); }
|
|
void DrawGetTextSize(const char* str, int len, int &w, int &h) { IupDrawGetTextSize(ih, str, len, &w, &h); }
|
|
void DrawGetImageInfo(const char* name, int &w, int &h, int &bpp) { IupDrawGetImageInfo(name, &w, &h, &bpp); }
|
|
};
|
|
|
|
class Frame : public Container
|
|
{
|
|
public:
|
|
Frame() : Container(IupFrame(0)) {}
|
|
Frame(Control child) : Container(IupFrame(child.GetHandle())) {}
|
|
Frame(const Frame& container) : Container(container.GetHandle()) {}
|
|
Frame(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class FlatFrame : public Container
|
|
{
|
|
public:
|
|
FlatFrame() : Container(IupFlatFrame(0)) {}
|
|
FlatFrame(Control child) : Container(IupFlatFrame(child.GetHandle())) {}
|
|
FlatFrame(const FlatFrame& container) : Container(container.GetHandle()) {}
|
|
FlatFrame(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class Spinbox : public Container
|
|
{
|
|
public:
|
|
Spinbox() : Container(IupSpinbox(0)) {}
|
|
Spinbox(Control child) : Container(IupSpinbox(child.GetHandle())) {}
|
|
Spinbox(const Spinbox& container) : Container(container.GetHandle()) {}
|
|
Spinbox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
|
|
class Vbox : public Container
|
|
{
|
|
Vbox(const Vbox& box) : Container(box.GetHandle()) {} /* to avoid hierarchy construction problems */
|
|
public:
|
|
Vbox() : Container(IupVbox(0)) {}
|
|
Vbox(Control child0, Control child1 = (Ihandle*)0, Control child2 = (Ihandle*)0, Control child3 = (Ihandle*)0, Control child4 = (Ihandle*)0, Control child5 = (Ihandle*)0, Control child6 = (Ihandle*)0, Control child7 = (Ihandle*)0, Control child8 = (Ihandle*)0, Control child9 = (Ihandle*)0)
|
|
: Container(IupVbox(0), child0, child1, child2, child3, child4, child5, child6, child7, child8, child9) {}
|
|
Vbox(const Control *child_array, int count) : Container(IupVbox(0), child_array, count) {}
|
|
Vbox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class Hbox : public Container
|
|
{
|
|
Hbox(const Hbox& box) : Container(box.GetHandle()) {} /* to avoid hierarchy construction problems */
|
|
public:
|
|
Hbox() : Container(IupHbox(0)) {}
|
|
Hbox(Control child0, Control child1 = (Ihandle*)0, Control child2 = (Ihandle*)0, Control child3 = (Ihandle*)0, Control child4 = (Ihandle*)0, Control child5 = (Ihandle*)0, Control child6 = (Ihandle*)0, Control child7 = (Ihandle*)0, Control child8 = (Ihandle*)0, Control child9 = (Ihandle*)0)
|
|
: Container(IupHbox(0), child0, child1, child2, child3, child4, child5, child6, child7, child8, child9) {}
|
|
Hbox(const Control *child_array, int count) : Container(IupHbox(0), child_array, count) {}
|
|
Hbox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class Zbox : public Container
|
|
{
|
|
public:
|
|
Zbox() : Container(IupZbox(0)) {}
|
|
Zbox(Control child0, Control child1 = (Ihandle*)0, Control child2 = (Ihandle*)0, Control child3 = (Ihandle*)0, Control child4 = (Ihandle*)0, Control child5 = (Ihandle*)0, Control child6 = (Ihandle*)0, Control child7 = (Ihandle*)0, Control child8 = (Ihandle*)0, Control child9 = (Ihandle*)0)
|
|
: Container(IupZbox(0), child0, child1, child2, child3, child4, child5, child6, child7, child8, child9) {}
|
|
Zbox(const Control *child_array, int count) : Container(IupZbox(0), child_array, count) {}
|
|
Zbox(const Zbox& box) : Container(box.GetHandle()) {}
|
|
Zbox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class Cbox : public Container
|
|
{
|
|
public:
|
|
Cbox() : Container(IupCbox(0)) {}
|
|
Cbox(Control child0, Control child1 = (Ihandle*)0, Control child2 = (Ihandle*)0, Control child3 = (Ihandle*)0, Control child4 = (Ihandle*)0, Control child5 = (Ihandle*)0, Control child6 = (Ihandle*)0, Control child7 = (Ihandle*)0, Control child8 = (Ihandle*)0, Control child9 = (Ihandle*)0)
|
|
: Container(IupCbox(0), child0, child1, child2, child3, child4, child5, child6, child7, child8, child9) {}
|
|
Cbox(const Control *child_array, int count) : Container(IupCbox(0), child_array, count) {}
|
|
Cbox(const Cbox& box) : Container(box.GetHandle()) {}
|
|
Cbox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class Tabs : public Container
|
|
{
|
|
public:
|
|
Tabs() : Container(IupTabs(0)) {}
|
|
Tabs(Control child0, Control child1 = (Ihandle*)0, Control child2 = (Ihandle*)0, Control child3 = (Ihandle*)0, Control child4 = (Ihandle*)0, Control child5 = (Ihandle*)0, Control child6 = (Ihandle*)0, Control child7 = (Ihandle*)0, Control child8 = (Ihandle*)0, Control child9 = (Ihandle*)0)
|
|
: Container(IupTabs(0), child0, child1, child2, child3, child4, child5, child6, child7, child8, child9) {}
|
|
Tabs(const Control *child_array, int count) : Container(IupTabs(0), child_array, count) {}
|
|
Tabs(const Tabs& tabs) : Container(tabs.GetHandle()) {}
|
|
Tabs(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class FlatTabs : public Container
|
|
{
|
|
public:
|
|
FlatTabs() : Container(IupFlatTabs(0)) {}
|
|
FlatTabs(Control child0, Control child1 = (Ihandle*)0, Control child2 = (Ihandle*)0, Control child3 = (Ihandle*)0, Control child4 = (Ihandle*)0, Control child5 = (Ihandle*)0, Control child6 = (Ihandle*)0, Control child7 = (Ihandle*)0, Control child8 = (Ihandle*)0, Control child9 = (Ihandle*)0)
|
|
: Container(IupFlatTabs(0), child0, child1, child2, child3, child4, child5, child6, child7, child8, child9) {}
|
|
FlatTabs(const Control *child_array, int count) : Container(IupFlatTabs(0), child_array, count) {}
|
|
FlatTabs(const FlatTabs& tabs) : Container(tabs.GetHandle()) {}
|
|
FlatTabs(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class GridBox : public Container
|
|
{
|
|
public:
|
|
GridBox() : Container(IupGridBox(0)) {}
|
|
GridBox(Control child0, Control child1 = (Ihandle*)0, Control child2 = (Ihandle*)0, Control child3 = (Ihandle*)0, Control child4 = (Ihandle*)0, Control child5 = (Ihandle*)0, Control child6 = (Ihandle*)0, Control child7 = (Ihandle*)0, Control child8 = (Ihandle*)0, Control child9 = (Ihandle*)0)
|
|
: Container(IupGridBox(0), child0, child1, child2, child3, child4, child5, child6, child7, child8, child9) {}
|
|
GridBox(const Control *child_array, int count) : Container(IupGridBox(0), child_array, count) {}
|
|
GridBox(const GridBox& box) : Container(box.GetHandle()) {}
|
|
GridBox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class MultiBox : public Container
|
|
{
|
|
public:
|
|
MultiBox() : Container(IupMultiBox(0)) {}
|
|
MultiBox(Control child0, Control child1 = (Ihandle*)0, Control child2 = (Ihandle*)0, Control child3 = (Ihandle*)0, Control child4 = (Ihandle*)0, Control child5 = (Ihandle*)0, Control child6 = (Ihandle*)0, Control child7 = (Ihandle*)0, Control child8 = (Ihandle*)0, Control child9 = (Ihandle*)0)
|
|
: Container(IupMultiBox(0), child0, child1, child2, child3, child4, child5, child6, child7, child8, child9) {}
|
|
MultiBox(const Control *child_array, int count) : Container(IupMultiBox(0), child_array, count) {}
|
|
MultiBox(const MultiBox& box) : Container(box.GetHandle()) {}
|
|
MultiBox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class ParamBox : public Container
|
|
{
|
|
public:
|
|
ParamBox() : Container(IupParamBox(0)) {}
|
|
ParamBox(Control child0, Control child1 = (Ihandle*)0, Control child2 = (Ihandle*)0, Control child3 = (Ihandle*)0, Control child4 = (Ihandle*)0, Control child5 = (Ihandle*)0, Control child6 = (Ihandle*)0, Control child7 = (Ihandle*)0, Control child8 = (Ihandle*)0, Control child9 = (Ihandle*)0)
|
|
: Container(IupParamBox(child0.GetHandle(), child1.GetHandle(), child2.GetHandle(), child3.GetHandle(), child4.GetHandle(), child5.GetHandle(), child6.GetHandle(), child7.GetHandle(), child8.GetHandle(), child9.GetHandle(), 0)) {}
|
|
ParamBox(const Control *child_array, int count) : Container(IupParamBox(0), child_array, count) {}
|
|
ParamBox(const ParamBox& box) : Container(box.GetHandle()) {}
|
|
ParamBox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class Normalizer : public Container
|
|
{
|
|
public:
|
|
Normalizer() : Container(IupNormalizer(0)) {}
|
|
Normalizer(Control child0, Control child1 = (Ihandle*)0, Control child2 = (Ihandle*)0, Control child3 = (Ihandle*)0, Control child4 = (Ihandle*)0, Control child5 = (Ihandle*)0, Control child6 = (Ihandle*)0, Control child7 = (Ihandle*)0, Control child8 = (Ihandle*)0, Control child9 = (Ihandle*)0)
|
|
: Container(IupNormalizer(0), child0, child1, child2, child3, child4, child5, child6, child7, child8, child9) {}
|
|
Normalizer(const Control *child_array, int count) : Container(IupNormalizer(0), child_array, count) {}
|
|
Normalizer(const Normalizer& elem) : Container(elem.GetHandle()) {}
|
|
Normalizer(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
|
|
|
|
class FileDlg : public Dialog
|
|
{
|
|
public:
|
|
FileDlg() : Dialog(IupFileDlg()) {}
|
|
};
|
|
class MessageDlg : public Dialog
|
|
{
|
|
public:
|
|
MessageDlg() : Dialog(IupMessageDlg()) {}
|
|
};
|
|
class ColorDlg : public Dialog
|
|
{
|
|
public:
|
|
ColorDlg() : Dialog(IupColorDlg()) {}
|
|
};
|
|
class FontDlg : public Dialog
|
|
{
|
|
public:
|
|
FontDlg() : Dialog(IupFontDlg()) {}
|
|
};
|
|
class ProgressDlg : public Dialog
|
|
{
|
|
public:
|
|
ProgressDlg() : Dialog(IupProgressDlg()) {}
|
|
};
|
|
class ScintillaDlg : public Dialog
|
|
{
|
|
public:
|
|
ScintillaDlg() : Dialog(IupScintillaDlg()) {}
|
|
};
|
|
#ifdef LUA_VERSION
|
|
public:
|
|
LuaScripterDlg(lua_State *L) : Dialog(IupLuaScripterDlg(L)) {}
|
|
};
|
|
#endif
|
|
|
|
class GLCanvas : public Control
|
|
{
|
|
public:
|
|
GLCanvas() : Control(IupGLCanvas(0)) {}
|
|
GLCanvas(Ihandle* _ih) : Control(_ih) {}
|
|
GLCanvas(const Element& elem) : Control(elem.GetHandle()) {}
|
|
|
|
static void Open() { IupGLCanvasOpen(); }
|
|
|
|
void MakeCurrent() { IupGLMakeCurrent(ih); }
|
|
int IsCurrent() { return IupGLIsCurrent(ih); }
|
|
void SwapBuffers() { IupGLSwapBuffers(ih); }
|
|
void Palette(int index, float r, float g, float b) { IupGLPalette(ih, index, r, g, b); }
|
|
void UseFont(int first, int count, int list_base) { IupGLUseFont(ih, first, count, list_base); }
|
|
|
|
static void Wait(int gl) { IupGLWait(gl); }
|
|
};
|
|
class GLBackgroundBox : public Container
|
|
{
|
|
public:
|
|
GLBackgroundBox() : Container(IupGLBackgroundBox(0)) {}
|
|
GLBackgroundBox(Control child) : Container(IupGLBackgroundBox(child.GetHandle())) {}
|
|
GLBackgroundBox(const GLBackgroundBox& container) : Container(container.GetHandle()) {}
|
|
GLBackgroundBox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
|
|
class Controls
|
|
{
|
|
public:
|
|
static void Open() { IupControlsOpen(); }
|
|
};
|
|
class Dial : public Control
|
|
{
|
|
public:
|
|
Dial(const char* orientation = 0) : Control(IupDial(orientation)) {}
|
|
Dial(Ihandle* _ih) : Control(_ih) {}
|
|
Dial(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class Gauge : public Control
|
|
{
|
|
public:
|
|
Gauge() : Control(IupGauge()) {}
|
|
Gauge(Ihandle* _ih) : Control(_ih) {}
|
|
Gauge(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class ColorBrowser : public Control
|
|
{
|
|
public:
|
|
ColorBrowser() : Control(IupColorBrowser()) {}
|
|
ColorBrowser(Ihandle* _ih) : Control(_ih) {}
|
|
ColorBrowser(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class Cells : public Control
|
|
{
|
|
public:
|
|
Cells() : Control(IupCells()) {}
|
|
Cells(Ihandle* _ih) : Control(_ih) {}
|
|
Cells(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class Colorbar : public Control
|
|
{
|
|
public:
|
|
Colorbar() : Control(IupColorbar()) {}
|
|
Colorbar(Ihandle* _ih) : Control(_ih) {}
|
|
Colorbar(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class Matrix : public Control
|
|
{
|
|
public:
|
|
Matrix() : Control(IupMatrix(0)) {}
|
|
Matrix(Ihandle* _ih) : Control(_ih) {}
|
|
Matrix(const Element& elem) : Control(elem.GetHandle()) {}
|
|
|
|
void SetFormula(int col, const char* formula, const char* init = 0) { IupMatrixSetFormula(ih, col, formula, init); }
|
|
void SetDynamic(const char* init = 0) { IupMatrixSetDynamic(ih, init); }
|
|
};
|
|
class MatrixList : public Control
|
|
{
|
|
public:
|
|
MatrixList() : Control(IupMatrixList()) {}
|
|
MatrixList(Ihandle* _ih) : Control(_ih) {}
|
|
MatrixList(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class MatrixEx : public Control
|
|
{
|
|
public:
|
|
MatrixEx() : Control(IupMatrixEx()) {}
|
|
MatrixEx(Ihandle* _ih) : Control(_ih) {}
|
|
MatrixEx(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class GLControls
|
|
{
|
|
public:
|
|
static void Open() { IupGLControlsOpen(); }
|
|
};
|
|
class GLSubCanvas : public Control
|
|
{
|
|
public:
|
|
GLSubCanvas() : Control(IupGLSubCanvas()) {}
|
|
GLSubCanvas(Ihandle* _ih) : Control(_ih) {}
|
|
GLSubCanvas(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class GLSeparator : public Control
|
|
{
|
|
public:
|
|
GLSeparator() : Control(IupGLSeparator()) {}
|
|
GLSeparator(Ihandle* _ih) : Control(_ih) {}
|
|
GLSeparator(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class GLProgressBar : public Control
|
|
{
|
|
public:
|
|
GLProgressBar() : Control(IupGLProgressBar()) {}
|
|
GLProgressBar(Ihandle* _ih) : Control(_ih) {}
|
|
GLProgressBar(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class GLVal : public Control
|
|
{
|
|
public:
|
|
GLVal() : Control(IupGLVal()) {}
|
|
GLVal(Ihandle* _ih) : Control(_ih) {}
|
|
GLVal(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class GLLabel : public Control
|
|
{
|
|
public:
|
|
GLLabel(const char* title = 0) : Control(IupGLLabel(title)) {}
|
|
GLLabel(Ihandle* _ih) : Control(_ih) {}
|
|
GLLabel(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class GLButton : public Control
|
|
{
|
|
public:
|
|
GLButton(const char* title = 0) : Control(IupGLButton(title)) {}
|
|
GLButton(Ihandle* _ih) : Control(_ih) {}
|
|
GLButton(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class GLToggle : public Control
|
|
{
|
|
public:
|
|
GLToggle(const char* title = 0) : Control(IupGLToggle(title)) {}
|
|
GLToggle(Ihandle* _ih) : Control(_ih) {}
|
|
GLToggle(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class GLLink : public Control
|
|
{
|
|
public:
|
|
GLLink(const char *url = 0, const char* title = 0) : Control(IupGLLink(url, title)) {}
|
|
GLLink(Ihandle* _ih) : Control(_ih) {}
|
|
GLLink(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class GLFrame : public Container
|
|
{
|
|
public:
|
|
GLFrame(Control child) : Container(IupGLFrame(child.GetHandle())) {}
|
|
GLFrame() : Container(IupGLFrame(0)) {}
|
|
GLFrame(const GLFrame& container) : Container(container.GetHandle()) {}
|
|
GLFrame(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class GLExpander : public Container
|
|
{
|
|
public:
|
|
GLExpander(Control child) : Container(IupGLExpander(child.GetHandle())) {}
|
|
GLExpander() : Container(IupGLExpander(0)) {}
|
|
GLExpander(const GLExpander& container) : Container(container.GetHandle()) {}
|
|
GLExpander(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class GLScrollBox : public Container
|
|
{
|
|
public:
|
|
GLScrollBox(Control child) : Container(IupGLScrollBox(child.GetHandle())) {}
|
|
GLScrollBox() : Container(IupGLScrollBox(0)) {}
|
|
GLScrollBox(const GLScrollBox& container) : Container(container.GetHandle()) {}
|
|
GLScrollBox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class GLSizeBox : public Container
|
|
{
|
|
public:
|
|
GLSizeBox(Control child) : Container(IupGLSizeBox(child.GetHandle())) {}
|
|
GLSizeBox() : Container(IupGLSizeBox(0)) {}
|
|
GLSizeBox(const GLSizeBox& container) : Container(container.GetHandle()) {}
|
|
GLSizeBox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class GLCanvasBox : public Container
|
|
{
|
|
public:
|
|
GLCanvasBox() : Container(IupGLCanvasBox(0)) {}
|
|
GLCanvasBox(Control child0, Control child1 = (Ihandle*)0, Control child2 = (Ihandle*)0, Control child3 = (Ihandle*)0, Control child4 = (Ihandle*)0, Control child5 = (Ihandle*)0, Control child6 = (Ihandle*)0, Control child7 = (Ihandle*)0, Control child8 = (Ihandle*)0, Control child9 = (Ihandle*)0)
|
|
: Container(IupGLCanvasBox(0), child0, child1, child2, child3, child4, child5, child6, child7, child8, child9) {}
|
|
GLCanvasBox(const Control *child_array, int count) : Container(IupGLCanvasBox(0), child_array, count) {}
|
|
GLCanvasBox(const GLCanvasBox& container) : Container(container.GetHandle()) {}
|
|
GLCanvasBox(Ihandle* _ih) : Container(_ih) {}
|
|
};
|
|
class Plot : public Control
|
|
{
|
|
public:
|
|
Plot() : Control(IupPlot()) {}
|
|
Plot(Ihandle* _ih) : Control(_ih) {}
|
|
Plot(const Element& elem) : Control(elem.GetHandle()) {}
|
|
|
|
static void Open() { IupPlotOpen(); }
|
|
|
|
void Begin(int strXdata) { IupPlotBegin(ih, strXdata); }
|
|
void Add(double x, double y) { IupPlotAdd(ih, x, y); }
|
|
void AddStr(const char* x, double y) { IupPlotAddStr(ih, x, y); }
|
|
void AddSegment(double x, double y) { IupPlotAddSegment(ih, x, y); }
|
|
int End() { return IupPlotEnd(ih); }
|
|
|
|
int LoadData(const char* filename, int strXdata) { return IupPlotLoadData(ih, filename, strXdata); }
|
|
|
|
int SetFormula(int sample_count, const char* formula, const char* init) { return IupPlotSetFormula(ih, sample_count, formula, init); }
|
|
|
|
void Insert(int ds_index, int sample_index, double x, double y) { IupPlotInsert(ih, ds_index, sample_index, x, y); }
|
|
void InsertStr(int ds_index, int sample_index, const char* x, double y) { IupPlotInsertStr(ih, ds_index, sample_index, x, y); }
|
|
void InsertSegment(int ds_index, int sample_index, double x, double y) { IupPlotInsertSegment(ih, ds_index, sample_index, x, y); }
|
|
|
|
void InsertStrSamples(int ds_index, int sample_index, const char** x, double* y, int count) { IupPlotInsertStrSamples(ih, ds_index, sample_index, x, y, count); }
|
|
void InsertSamples(int ds_index, int sample_index, double *x, double *y, int count) { IupPlotInsertSamples(ih, ds_index, sample_index, x, y, count); }
|
|
|
|
void AddSamples(int ds_index, double *x, double *y, int count) { IupPlotAddSamples(ih, ds_index, x, y, count); }
|
|
void AddStrSamples(int ds_index, const char** x, double* y, int count) { IupPlotAddStrSamples(ih, ds_index, x, y, count); }
|
|
|
|
void GetSample(int ds_index, int sample_index, double &x, double &y) { IupPlotGetSample(ih, ds_index, sample_index, &x, &y); }
|
|
void GetSampleStr(int ds_index, int sample_index, const char* &x, double &y) { IupPlotGetSampleStr(ih, ds_index, sample_index, &x, &y); }
|
|
int GetSampleSelection(int ds_index, int sample_index) { return IupPlotGetSampleSelection(ih, ds_index, sample_index); }
|
|
double GetSampleExtra(int ds_index, int sample_index) { return IupPlotGetSampleExtra(ih, ds_index, sample_index); }
|
|
void SetSample(int ds_index, int sample_index, double x, double y) { IupPlotSetSample(ih, ds_index, sample_index, x, y); }
|
|
void SetSampleStr(int ds_index, int sample_index, const char* x, double y) { IupPlotSetSampleStr(ih, ds_index, sample_index, x, y); }
|
|
void SetSampleSelection(int ds_index, int sample_index, int selected) { IupPlotSetSampleSelection(ih, ds_index, sample_index, selected); }
|
|
void SetSampleExtra(int ds_index, int sample_index, double extra) { IupPlotSetSampleExtra(ih, ds_index, sample_index, extra); }
|
|
|
|
void Transform(double x, double y, double &cnv_x, double &cnv_y) { IupPlotTransform(ih, x, y, &cnv_x, &cnv_y); }
|
|
void TransformTo(double cnv_x, double cnv_y, double &x, double &y) { IupPlotTransformTo(ih, cnv_x, cnv_y, &x, &y); }
|
|
|
|
int FindSample(double cnv_x, double cnv_y, int &ds_index, int &sample_index) { return IupPlotFindSample(ih, cnv_x, cnv_y, &ds_index, &sample_index); }
|
|
|
|
#ifdef __CD_PLUS_H
|
|
void PaintTo(cd::Canvas& cd_canvas) { IupPlotPaintTo(ih, cd_canvas.GetHandle()); }
|
|
#endif
|
|
};
|
|
class MglPlot : public Control
|
|
{
|
|
public:
|
|
MglPlot() : Control(IupMglPlot()) {}
|
|
MglPlot(Ihandle* _ih) : Control(_ih) {}
|
|
MglPlot(const Element& elem) : Control(elem.GetHandle()) {}
|
|
|
|
static void Open() { IupMglPlotOpen(); }
|
|
|
|
void Begin(int dim) { IupMglPlotBegin(ih, dim); }
|
|
void Add1D(const char* name, double y) { IupMglPlotAdd1D(ih, name, y); }
|
|
void Add2D(double x, double y) { IupMglPlotAdd2D(ih, x, y); }
|
|
void Add3D(double x, double y, double z) { IupMglPlotAdd3D(ih, x, y, z); }
|
|
int End() { return IupMglPlotEnd(ih); }
|
|
|
|
int NewDataSet(int dim) { return IupMglPlotNewDataSet(ih, dim); }
|
|
|
|
void Insert1D(int ds_index, int sample_index, const char** names, const double* y, int count) { IupMglPlotInsert1D(ih, ds_index, sample_index, names, y, count); }
|
|
void Insert2D(int ds_index, int sample_index, const double* x, const double* y, int count) { IupMglPlotInsert2D(ih, ds_index, sample_index, x, y, count); }
|
|
void Insert3D(int ds_index, int sample_index, const double* x, const double* y, const double* z, int count) { IupMglPlotInsert3D(ih, ds_index, sample_index, x, y, z, count); }
|
|
|
|
void Set1D(int ds_index, const char** names, const double* y, int count) { IupMglPlotSet1D(ih, ds_index, names, y, count); }
|
|
void Set2D(int ds_index, const double* x, const double* y, int count) { IupMglPlotSet2D(ih, ds_index, x, y, count); }
|
|
void Set3D(int ds_index, const double* x, const double* y, const double* z, int count) { IupMglPlotSet3D(ih, ds_index, x, y, z, count); }
|
|
void SetFormula(int ds_index, const char* formulaX, const char* formulaY, const char* formulaZ, int count) { IupMglPlotSetFormula(ih, ds_index, formulaX, formulaY, formulaZ, count); }
|
|
|
|
void SetData(int ds_index, const double* data, int count_x, int count_y, int count_z) { IupMglPlotSetData(ih, ds_index, data, count_x, count_y, count_z); }
|
|
void LoadData(int ds_index, const char* filename, int count_x, int count_y, int count_z) { IupMglPlotLoadData(ih, ds_index, filename, count_x, count_y, count_z); }
|
|
void SetFromFormula(int ds_index, const char* formula, int count_x, int count_y, int count_z) { IupMglPlotSetFromFormula(ih, ds_index, formula, count_x, count_y, count_z); }
|
|
|
|
void Transform(double x, double y, double z, int &ix, int &iy) { IupMglPlotTransform(ih, x, y, z, &ix, &iy); }
|
|
void TransformTo(int ix, int iy, double &x, double &y, double &z) { IupMglPlotTransformTo(ih, ix, iy, &x, &y, &z); }
|
|
|
|
void DrawMark(double x, double y, double z) { IupMglPlotDrawMark(ih, x, y, z); }
|
|
void DrawLine(double x1, double y1, double z1, double x2, double y2, double z2) { IupMglPlotDrawLine(ih, x1, y1, z1, x2, y2, z2); }
|
|
void DrawText(const char* text, double x, double y, double z) { IupMglPlotDrawText(ih, text, x, y, z); }
|
|
|
|
void PaintTo(const char* format, int w, int h, double dpi, unsigned char* data) { IupMglPlotPaintTo(ih, format, w, h, dpi, (void*)data); }
|
|
void PaintTo(const char* format, int w, int h, double dpi, const char* filename) { IupMglPlotPaintTo(ih, format, w, h, dpi, (void*)filename); }
|
|
|
|
};
|
|
class MglLabel : public Control
|
|
{
|
|
public:
|
|
MglLabel(const char* title) : Control(IupMglLabel(title)) {}
|
|
MglLabel(Ihandle* _ih) : Control(_ih) {}
|
|
MglLabel(const Element& elem) : Control(elem.GetHandle()) {}
|
|
};
|
|
class OleControl : public Control
|
|
{
|
|
public:
|
|
OleControl(const char* progid) : Control(IupOleControl(progid)) {}
|
|
OleControl(Ihandle* _ih) : Control(_ih) {}
|
|
OleControl(const Element& elem) : Control(elem.GetHandle()) {}
|
|
|
|
static void Open() { IupOleControlOpen(); }
|
|
};
|
|
class WebBrowser : public Control
|
|
{
|
|
public:
|
|
WebBrowser() : Control(IupWebBrowser()) {}
|
|
WebBrowser(Ihandle* _ih) : Control(_ih) {}
|
|
WebBrowser(const Element& elem) : Control(elem.GetHandle()) {}
|
|
|
|
static void Open() { IupWebBrowserOpen(); }
|
|
};
|
|
class Scintilla : public Control
|
|
{
|
|
public:
|
|
Scintilla(): Control(IupScintilla()) {}
|
|
Scintilla(Ihandle* _ih) : Control(_ih) {}
|
|
Scintilla(const Element& elem) : Control(elem.GetHandle()) {}
|
|
|
|
static void Open() { IupScintillaOpen(); }
|
|
};
|
|
class TuioClient : public Element
|
|
{
|
|
public:
|
|
TuioClient(int port) : Element(IupTuioClient(port)) {}
|
|
TuioClient(Ihandle* _ih) : Element(_ih) {}
|
|
TuioClient(const Element& elem) : Element(elem.GetHandle()) {}
|
|
|
|
static void Open() { IupTuioOpen(); }
|
|
};
|
|
|
|
class Config: public Element
|
|
{
|
|
public:
|
|
Config(): Element(IupConfig()) { }
|
|
Config(Ihandle* _ih) : Element(_ih) {}
|
|
Config(const Element& elem) : Element(elem.GetHandle()) {}
|
|
|
|
int LoadConfig() { return IupConfigLoad(ih); }
|
|
int SaveConfig() { return IupConfigSave(ih); }
|
|
|
|
void SetVariableStrId(const char* group, const char* key, int id, const char* value) { IupConfigSetVariableStrId(ih, group, key, id, value); }
|
|
void SetVariableIntId(const char* group, const char* key, int id, int value) { IupConfigSetVariableIntId(ih, group, key, id, value); }
|
|
void SetVariableDoubleId(const char* group, const char* key, int id, double value) { IupConfigSetVariableDoubleId(ih, group, key, id, value); }
|
|
void SetVariableStr(const char* group, const char* key, const char* value) { IupConfigSetVariableStr(ih, group, key, value); }
|
|
void SetVariableInt(const char* group, const char* key, int value) { IupConfigSetVariableInt(ih, group, key, value); }
|
|
void SetVariableDouble(const char* group, const char* key, double value) { IupConfigSetVariableDouble(ih, group, key, value); }
|
|
|
|
char* GetVariableStr(const char* group, const char* key) { return (char*)IupConfigGetVariableStr(ih, group, key); }
|
|
int GetVariableInt(const char* group, const char* key) { return IupConfigGetVariableInt(ih, group, key); }
|
|
double GetVariableDouble(const char* group, const char* key) { return IupConfigGetVariableDouble(ih, group, key); }
|
|
char* GetVariableStrId(const char* group, const char* key, int id) { return (char*)IupConfigGetVariableStrId(ih, group, key, id); }
|
|
int GetVariableIntId(const char* group, const char* key, int id) { return IupConfigGetVariableIntId(ih, group, key, id); }
|
|
double GetVariableDoubleId(const char* group, const char* key, int id) { return IupConfigGetVariableDoubleId(ih, group, key, id); }
|
|
|
|
char* GetVariableStrDef(const char* group, const char* key, const char* def) { return (char*)IupConfigGetVariableStrDef(ih, group, key, def); }
|
|
int GetVariableIntDef(const char* group, const char* key, int def) { return IupConfigGetVariableIntDef(ih, group, key, def); }
|
|
double GetVariableDoubleDef(const char* group, const char* key, double def) { return IupConfigGetVariableDoubleDef(ih, group, key, def); }
|
|
char* GetVariableStrIdDef(const char* group, const char* key, int id, const char* def) { return (char*)IupConfigGetVariableStrIdDef(ih, group, key, id, def); }
|
|
int GetVariableIntIdDef(const char* group, const char* key, int id, int def) { return IupConfigGetVariableIntIdDef(ih, group, key, id, def); }
|
|
double GetVariableDoubleIdDef(const char* group, const char* key, int id, double def) { return IupConfigGetVariableDoubleIdDef(ih, group, key, id, def); }
|
|
|
|
void Copy(const Config& config2, const char* exclude_prefix) { IupConfigCopy(ih, config2.GetHandle(), exclude_prefix); }
|
|
|
|
void SetListVariable(const char *group, const char* key, const char* value, int add) { IupConfigSetListVariable(ih, group, key, value, add); }
|
|
|
|
void RecentInit(Menu menu, Icallback recent_cb, int max_recent) { IupConfigRecentInit(ih, menu.GetHandle(), recent_cb, max_recent); }
|
|
void RecentUpdate(const char* filename) { IupConfigRecentUpdate(ih, filename); }
|
|
|
|
void DialogShow(Dialog dialog, const char* name) { IupConfigDialogShow(ih, dialog.GetHandle(), name); }
|
|
void DialogClosed(Dialog dialog, const char* name) { IupConfigDialogClosed(ih, dialog.GetHandle(), name); }
|
|
};
|
|
}
|
|
|
|
#ifdef __CD_PLUS_H
|
|
namespace cd
|
|
{
|
|
class CanvasIup : public Canvas
|
|
{
|
|
public:
|
|
CanvasIup(Iup::Canvas& iup_canvas)
|
|
: Canvas() { canvas = cdCreateCanvas(CD_IUP, iup_canvas.GetHandle()); }
|
|
};
|
|
class CanvasIupDoubleBuffer : public Canvas
|
|
{
|
|
public:
|
|
CanvasIupDoubleBuffer(Iup::Canvas& iup_canvas)
|
|
: Canvas() { canvas = cdCreateCanvas(CD_IUPDBUFFER, iup_canvas.GetHandle()); }
|
|
};
|
|
class CanvasIupDoubleBufferRGB : public Canvas
|
|
{
|
|
public:
|
|
CanvasIupDoubleBufferRGB(Iup::Canvas& iup_canvas)
|
|
: Canvas() { canvas = cdCreateCanvas(CD_IUPDBUFFERRGB, iup_canvas.GetHandle()); }
|
|
};
|
|
}
|
|
#endif
|
|
|
|
#endif
|