void IupSetClassDefaultAttribute(const char* classname, const char *name, const char* default_value)
{
Iclass* ic;
IattribFunc* afunc;
iupASSERT(classname!=NULL);
if (!classname)
return;
iupASSERT(name!=NULL);
if (!name)
return;
ic = iupRegisterFindClass(name);
if (!ic)
return;
afunc = (IattribFunc*)iupTableGet(ic->attrib_func, name);
if (afunc && !(afunc->flags & IUPAF_NO_DEFAULTVALUE) && /* can has default */
!(afunc->flags & IUPAF_NO_STRING) && /* is a string */
!(afunc->flags & IUPAF_HAS_ID))
{
if (default_value == IUPAF_SAMEASSYSTEM)
afunc->default_value = afunc->system_default;
else
afunc->default_value = default_value;
if (iupClassIsGlobalDefault(afunc->default_value, 0))
afunc->call_global_default = 1;
else
afunc->call_global_default = 0;
}
else if (!afunc && default_value)
iupClassRegisterAttribute(ic, name, NULL, NULL, default_value, NULL, IUPAF_DEFAULT);
}
void IupSetAttribute(Ihandle *ih, const char* name, const char *value)
{
int inherit;
iupASSERT(name!=NULL);
if (!name)
return;
if (!ih)
{
IupSetGlobal(name, value);
return;
}
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return;
if (iupAttribIsInternal(name))
iupAttribSetStr(ih, name, value);
else
{
if (iupClassObjectSetAttribute(ih, name, value, &inherit)!=0) /* store strings and pointers */
iupAttribSetStr(ih, name, value);
if (inherit)
iAttribNotifyChildren(ih, name, value);
}
}
Itable *iupTableCreateSized(Itable_IndexTypes indexType, unsigned int initialSizeIndex)
{
Itable *it = (Itable *)malloc(sizeof(Itable));
iupASSERT(it!=NULL);
if (!it)
return 0;
if (initialSizeIndex > itable_maxTableSizeIndex)
initialSizeIndex = itable_maxTableSizeIndex;
it->entriesSize = itable_hashTableSize[initialSizeIndex];
it->tableSizeIndex = initialSizeIndex;
it->numberOfEntries = 0;
it->indexType = indexType;
it->entries = (ItableEntry *)malloc(it->entriesSize * sizeof(ItableEntry));
iupASSERT(it->entries!=NULL);
if (!it->entries)
{
free(it);
return 0;
}
memset(it->entries, 0, it->entriesSize * sizeof(ItableEntry));
it->context.entryIndex = (unsigned int)-1;
it->context.itemIndex = (unsigned int)-1;
return it;
}
void IupSetAttributeHandle(Ihandle *ih, const char* name, Ihandle *ih_named)
{
int inherit;
char* handle_name;
iupASSERT(name!=NULL);
if (!name)
return;
handle_name = IupGetName(ih_named);
if (!handle_name)
{
iupAttribSetHandleName(ih_named);
handle_name = IupGetName(ih_named);
}
if (ih)
{
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return;
iupClassObjectSetAttribute(ih, name, handle_name, &inherit);
iupAttribStoreStr(ih, name, handle_name);
}
else
IupStoreGlobal(name, handle_name);
}
static int iImageCreate(Ihandle* ih, void** params, int bpp)
{
int width, height, channels, count;
unsigned char *imgdata;
iupASSERT(params!=NULL);
if (!params)
return IUP_ERROR;
width = (int)(params[0]);
height = (int)(params[1]);
iupASSERT(width>0);
iupASSERT(height>0);
if (width <= 0 || height <= 0)
return IUP_ERROR;
ih->currentwidth = width;
ih->currentheight = height;
channels = 1;
if (bpp == 24)
channels = 3;
else if (bpp == 32)
channels = 4;
count = width*height*channels;
imgdata = (unsigned char *)malloc(count);
if (((int)(params[2])==-1) || ((int)(params[3])==-1)) /* compacted in one pointer */
{
if (imgdata && (int)(params[2])!=-1)
memcpy(imgdata, params[2], count);
}
else /* one param for each element */
{
int i;
for(i=0; i<count; i++)
{
imgdata[i] = (unsigned char)((int)(params[i+2]));
}
}
ih->handle = (InativeHandle*)imgdata; /* IupImage is always mapped */
iupAttribSetInt(ih, "BPP", bpp);
iupAttribSetInt(ih, "CHANNELS", channels);
return IUP_NOERROR;
}
void IupResetAttribute(Ihandle *ih, const char* name)
{
iupASSERT(name!=NULL);
if (!name)
return;
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return;
iupAttribSetStr(ih, name, NULL);
if (iAttribIsInherit(ih, name))
iAttribResetChildren(ih, name);
}
static void iTableFreeItemArray(Itable_IndexTypes indexType, unsigned int nextFreeIndex, ItableItem *items)
{
unsigned int i;
/* Used only in iupTableClear */
iupASSERT(items!=NULL);
if (!items)
return;
if (indexType == IUPTABLE_STRINGINDEXED)
{
for (i = 0; i < nextFreeIndex; i++)
{
free((void *)(items[i].key.keyStr));
items[i].key.keyStr = NULL;
}
}
for (i = 0; i < nextFreeIndex; i++)
{
if (items[i].itemType == IUPTABLE_STRING)
{
free(items[i].value);
items[i].value = NULL;
}
}
free(items);
}
char *iupTableNext(Itable *it)
{
unsigned int entryIndex;
iupASSERT(it!=NULL);
if (!it || it->context.entryIndex == (unsigned int)-1
|| it->context.itemIndex == (unsigned int)-1)
return 0;
if (it->context.itemIndex + 1 < it->entries[it->context.entryIndex].nextItemIndex)
{
/* key in the current entry */
it->context.itemIndex++;
return (char*)it->entries[it->context.entryIndex].items[it->context.itemIndex].key.keyStr;
}
else
{
/* find the next used entry */
for (entryIndex = it->context.entryIndex+1; entryIndex < it->entriesSize; entryIndex++)
{
if (it->entries[entryIndex].nextItemIndex > 0)
{
it->context.entryIndex = entryIndex;
it->context.itemIndex = 0;
return (char*)it->entries[entryIndex].items[0].key.keyStr;
}
}
}
return 0;
}
void iupTableRemove(Itable *it, const char *key)
{
unsigned int itemFound,
itemIndex;
unsigned long keyIndex;
ItableEntry *entry;
iupASSERT(it!=NULL);
iupASSERT(key!=NULL);
if (!it || !key)
return;
itemFound = iTableFindItem(it, key, &entry, &itemIndex, &keyIndex);
if (itemFound)
iTableRemoveItem(it, entry, itemIndex);
}
int iupTableCount(Itable *it)
{
iupASSERT(it!=NULL);
if (!it)
return 0;
return it->numberOfEntries;
}
Ihandle* IupSetHandle(const char *name, Ihandle *ih)
{
Ihandle *old_ih;
iupASSERT(name!=NULL);
if (!name)
return NULL;
old_ih = iupTableGet(inames_strtable, name);
if (ih != NULL)
{
iupTableSet(inames_strtable, name, ih, IUPTABLE_POINTER);
/* save the name in the cache if it is a valid handle */
if (iupObjectCheck(ih))
iupAttribStoreStr(ih, "_IUP_LASTHANDLENAME", name);
}
else
{
iupTableRemove(inames_strtable, name);
/* clear the name from the cache if it is a valid handle */
if (iupObjectCheck(old_ih))
iupAttribSetStr(old_ih, "_IUP_LASTHANDLENAME", NULL);
}
return old_ih;
}
Ihandle* IupNextField(Ihandle *ih)
{
Ihandle *ih_next;
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return NULL;
ih_next = iFocusFindNext(ih, 1);
if (!ih_next)
{
/* not found after the element, then start over from the begining,
at the dialog. */
ih_next = iFocusFindNext(IupGetDialog(ih), 1);
if (ih_next == ih)
return NULL;
}
if (ih_next)
{
iupdrvSetFocus(ih_next);
return ih_next;
}
return NULL;
}
int IupGetAllAttributes(Ihandle* ih, char** names, int n)
{
char *name;
int i = 0;
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return 0;
if (!names || !n)
return iupTableCount(ih->attrib);
name = iupTableFirst(ih->attrib);
while (name)
{
names[i] = name;
i++;
if (i == n)
break;
name = iupTableNext(ih->attrib);
}
return i;
}
void IupStoreAttribute(Ihandle *ih, const char* name, const char *value)
{
int inherit;
if (!name)
return;
if (!ih)
{
IupStoreGlobal(name, value);
return;
}
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return;
if (iupAttribIsInternal(name))
iupAttribStoreStr(ih, name, value);
else
{
if (iupClassObjectSetAttribute(ih, name, value, &inherit)==1) /* store only strings */
iupAttribStoreStr(ih, name, value);
if (inherit)
iAttribNotifyChildren(ih, name, value);
}
}
char* IupGetName(Ihandle* ih)
{
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return NULL;
return iupTableGet(inames_ihtable, (char*)ih);
}
void IupGLUseFont(Ihandle* ih, int first, int count, int list_base)
{
HFONT font;
IGlControlData* gldata;
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return;
/* must be an IupGLCanvas */
if (ih->iclass->nativetype != IUP_TYPECANVAS ||
!IupClassMatch(ih, "glcanvas"))
return;
/* must be mapped */
gldata = (IGlControlData*)iupAttribGet(ih, "_IUP_GLCONTROLDATA");
if (!gldata->window)
return;
font = (HFONT)IupGetAttribute(ih, "HFONT");
if (font)
{
HFONT old_font = SelectObject(gldata->device, font);
wglUseFontBitmaps(gldata->device, first, count, list_base);
SelectObject(gldata->device, old_font);
}
}
void IupGLSwapBuffers(Ihandle* ih)
{
IGlControlData* gldata;
Icallback cb;
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return;
/* must be an IupGLCanvas */
if (ih->iclass->nativetype != IUP_TYPECANVAS ||
!IupClassMatch(ih, "glcanvas"))
return;
/* must be mapped */
gldata = (IGlControlData*)iupAttribGet(ih, "_IUP_GLCONTROLDATA");
if (!gldata->window)
return;
cb = IupGetCallback(ih, "SWAPBUFFERS_CB");
if (cb)
cb(ih);
SwapBuffers(gldata->device);
}
void IupGLPalette(Ihandle* ih, int index, float r, float g, float b)
{
IGlControlData* gldata;
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return;
/* must be an IupGLCanvas */
if (ih->iclass->nativetype != IUP_TYPECANVAS ||
!IupClassMatch(ih, "glcanvas"))
return;
/* must be mapped */
gldata = (IGlControlData*)iupAttribGet(ih, "_IUP_GLCONTROLDATA");
if (!gldata->window)
return;
/* must have a palette */
if (gldata->palette)
{
PALETTEENTRY entry;
entry.peRed = (BYTE)(r*255);
entry.peGreen = (BYTE)(g*255);
entry.peBlue = (BYTE)(b*255);
entry.peFlags = PC_NOCOLLAPSE;
SetPaletteEntries(gldata->palette,index,1,&entry);
UnrealizeObject(gldata->device);
SelectPalette(gldata->device,gldata->palette,FALSE);
RealizePalette(gldata->device);
}
}
void IupGLMakeCurrent(Ihandle* ih)
{
IGlControlData* gldata;
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return;
/* must be an IupGLCanvas */
if (ih->iclass->nativetype != IUP_TYPECANVAS ||
!IupClassMatch(ih, "glcanvas"))
return;
/* must be mapped */
gldata = (IGlControlData*)iupAttribGet(ih, "_IUP_GLCONTROLDATA");
if (!gldata->window)
return;
if (wglMakeCurrent(gldata->device, gldata->context)==FALSE)
{
iupAttribSet(ih, "ERROR", "Failed to set new current context.");
iupAttribSetStr(ih, "LASTERROR", IupGetGlobal("LASTERROR"));
}
else
{
iupAttribSet(ih, "ERROR", NULL);
iupAttribSet(ih, "LASTERROR", NULL);
}
}
Ihandle* IupSetHandle(const char *name, Ihandle *ih)
{
Ihandle *old_ih;
iupASSERT(name!=NULL);
if (!name)
return NULL;
old_ih = iupTableGet(inames_strtable, name);
if (ih != NULL)
{
iupTableSet(inames_strtable, name, ih, IUPTABLE_POINTER);
iupTableSet(inames_ihtable, (char*)ih, (char*)name, IUPTABLE_STRING); /* keep only the last name set */
}
else
{
ih = iupTableGet(inames_strtable, name);
iupTableRemove(inames_strtable, name);
if (ih)
{
char* cur_name = iupTableGet(inames_ihtable, (char*)ih);
if (iupStrEqualNoCase(cur_name, name))
iupTableRemove(inames_ihtable, (char*)ih);
}
}
return old_ih;
}
Ihandle* IupGetDialogChild(Ihandle* ih, const char* name)
{
Ihandle *child, *dialog;
char attrib[1024] = "_IUP_DIALOG_CHILD_";
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return NULL;
if (!name)
return NULL;
dialog = IupGetDialog(ih);
if (dialog) ih = dialog;
strcat(attrib, name);
child = (Ihandle*)iupAttribGet(ih, attrib);
if (child) return child;
if (ih->firstchild)
{
child = iBaseFindNamedChild(ih, name);
if (child) return child;
}
ih = IupGetAttributeHandle(ih, "MENU");
if (ih)
{
child = iBaseFindNamedChild(ih, name);
if (child) return child;
}
return NULL;
}
void IupGLPalette(Ihandle* ih, int index, float r, float g, float b)
{
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return;
/* must be a IupGLCanvas */
if (!iupStrEqual(ih->iclass->name, "glcanvas"))
return;
/* must be mapped */
if (!ih->handle)
return;
/* must have a palette */
if (ih->data->palette)
{
PALETTEENTRY entry;
entry.peRed = (BYTE)(r*255);
entry.peGreen = (BYTE)(g*255);
entry.peBlue = (BYTE)(b*255);
entry.peFlags = PC_NOCOLLAPSE;
SetPaletteEntries(ih->data->palette,index,1,&entry);
UnrealizeObject(ih->data->device);
SelectPalette(ih->data->device,ih->data->palette,FALSE);
RealizePalette(ih->data->device);
}
}
void iupTreeCopyMoveCache(Ihandle* ih, int id_src, int id_dst, int count, int is_copy)
{
int remain_count;
iupASSERT(id_src >= 0 && id_src < ih->data->node_count);
if (id_src < 0 || id_src >= ih->data->node_count)
return;
iupASSERT(id_dst >= 0 && id_dst < ih->data->node_count);
if (id_dst < 0 || id_dst >= ih->data->node_count)
return;
iupASSERT(id_dst < id_src || id_dst > id_src+count);
if (id_dst >= id_src && id_dst <= id_src+count)
return;
/* id_dst here points to the final position for a copy operation */
/* node_count here contains the final count for a copy operation */
iTreeIncCacheMem(ih);
/* add space for new nodes */
remain_count = ih->data->node_count - (id_dst + count);
memmove(ih->data->node_cache+id_dst+count, ih->data->node_cache+id_dst, remain_count*sizeof(InodeData));
/* compensate because we add space for new nodes */
if (id_src > id_dst)
id_src += count;
if (is_copy)
{
/* during a copy, the userdata is not reused, so clear it */
memset(ih->data->node_cache+id_dst, 0, count*sizeof(InodeData));
}
else /* move = copy + delete */
{
/* copy userdata from src to dst */
memcpy(ih->data->node_cache+id_dst, ih->data->node_cache+id_src, count*sizeof(InodeData));
/* remove the src */
remain_count = ih->data->node_count - (id_src + count);
memmove(ih->data->node_cache+id_src, ih->data->node_cache+id_src+count, remain_count*sizeof(InodeData));
/* clear the remaining space */
memset(ih->data->node_cache+ih->data->node_count-count, 0, count*sizeof(InodeData));
}
}
void IupUpdateChildren(Ihandle* ih)
{
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return;
iLayoutDisplayUpdateChildren(ih);
}
int IupClassMatch(Ihandle* ih, const char* classname)
{
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return 0;
return iupClassMatch(ih->iclass, classname);
}
char* IupGetClassName(Ihandle *ih)
{
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return NULL;
return (char*)ih->iclass->name;
}
void IupStoreAttributeId2(Ihandle* ih, const char* name, int lin, int col, const char* value)
{
iupASSERT(name!=NULL);
if (!name)
return;
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return;
if (iupClassObjectSetAttributeId2(ih, name, lin, col, value)==1) /* store only strings */
{
char attr[100];
sprintf(attr, "%s%d:%d", name, lin, col);
iupAttribStoreStr(ih, attr, value);
}
}
void IupSetAttributeId(Ihandle *ih, const char* name, int id, const char *value)
{
iupASSERT(name!=NULL);
if (!name)
return;
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return;
if (iupClassObjectSetAttributeId(ih, name, id, value)!=0) /* store strings and pointers */
{
char attr[100];
sprintf(attr, "%s%d", name, id);
iupAttribSetStr(ih, attr, value);
}
}
int IupTreeGetId(Ihandle* ih, void *userdata)
{
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return -1;
return iTreeFindUserDataId(ih, userdata);
}
Ihandle* IupSetAttributes(Ihandle *ih, const char* str)
{
iupASSERT(iupObjectCheck(ih));
if (!iupObjectCheck(ih))
return ih;
if (str)
iAttribParse(ih, str);
return ih;
}
