1187 lines
27 KiB
C
Executable File
1187 lines
27 KiB
C
Executable File
#if 0
|
|
/* To check for memory leaks */
|
|
#define VLD_MAX_DATA_DUMP 80
|
|
#include <vld.h>
|
|
#endif
|
|
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <ctype.h>
|
|
#include <time.h>
|
|
|
|
#include "iup.h"
|
|
#include "iupcontrols.h"
|
|
#include "iupgl.h"
|
|
#include "iupim.h"
|
|
|
|
#include "iup_str.h"
|
|
#include "iup_object.h"
|
|
#include "iup_image.h"
|
|
|
|
|
|
/* #define STOCK_TEST "24" */
|
|
/* #define STOCK_TEST "48" */
|
|
|
|
|
|
#define MAX_NAMES 5000
|
|
|
|
#ifdef USE_IM
|
|
#include "iupim.h"
|
|
#endif
|
|
|
|
static int close_cb(void)
|
|
{
|
|
return IUP_CLOSE;
|
|
}
|
|
|
|
static int about_cb(void)
|
|
{
|
|
IupMessage("About", " IupView\n\n"
|
|
"Show dialogs and popup menus\n"
|
|
"defined in LED files.\n"
|
|
"Can show all defined images.\n"
|
|
"Can import and export images.\n"
|
|
);
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int inactivetoggle_cb(Ihandle* self, int v)
|
|
{
|
|
Ihandle* tabs = (Ihandle*)IupGetAttribute(self, "TABS");
|
|
Ihandle* child = IupGetNextChild(tabs, NULL);
|
|
while(child)
|
|
{
|
|
IupSetAttribute(child, "ACTIVE", v?"NO":"YES");
|
|
child = IupGetNextChild(tabs, child);
|
|
}
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int imagebutton_cb(Ihandle* self)
|
|
{
|
|
Ihandle* label = (Ihandle*)IupGetAttribute(self, "_INFO_LABEL");
|
|
IupSetAttribute(label, "TITLE", IupGetAttribute(self, "_INFO"));
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int compare_image_names(const void* i1, const void* i2)
|
|
{
|
|
Ihandle* ih1 = *((Ihandle**)i1);
|
|
Ihandle* ih2 = *((Ihandle**)i2);
|
|
char* name1 = IupGetName(ih1);
|
|
char* name2 = IupGetName(ih2);
|
|
return strcmp(name1, name2);
|
|
}
|
|
|
|
static int showallimages_cb(Ihandle* ih)
|
|
{
|
|
Ihandle *dialog, *box, *files, *tabs, *toggle, *label;
|
|
Ihandle* params[500];
|
|
char *names[MAX_NAMES];
|
|
Ihandle* images[MAX_NAMES];
|
|
int i, n = 0, num_images, num_names = IupGetAllNames(names, MAX_NAMES);
|
|
files = IupUser();
|
|
|
|
num_images = 0;
|
|
for (i = 0; i < num_names; i++)
|
|
{
|
|
Ihandle* elem = IupGetHandle(names[i]);
|
|
|
|
if (elem->iclass->nativetype == IUP_TYPEIMAGE)
|
|
{
|
|
/* show only loaded images */
|
|
char* file_title = IupGetAttribute(elem, "_FILE_TITLE");
|
|
if (!file_title)
|
|
continue;
|
|
|
|
images[num_images] = elem;
|
|
num_images++;
|
|
}
|
|
}
|
|
|
|
if (num_images == 0)
|
|
{
|
|
IupMessage("Error", "No images.");
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
qsort(images, num_images, sizeof(Ihandle*), compare_image_names);
|
|
|
|
for (i = 0; i < num_images; i++)
|
|
{
|
|
Ihandle *tbox, *lbox, *button, *elem;
|
|
char* name;
|
|
char* file_title;
|
|
|
|
elem = images[i];
|
|
name = IupGetName(elem);
|
|
|
|
/* show only loaded images */
|
|
file_title = IupGetAttribute(elem, "_FILE_TITLE");
|
|
if (!file_title)
|
|
continue;
|
|
|
|
tbox = (Ihandle*)IupGetAttribute(files, file_title);
|
|
if (!tbox)
|
|
{
|
|
tbox = IupVbox(NULL);
|
|
IupSetAttribute(files, file_title, (char*)tbox);
|
|
IupSetAttribute(tbox, "TABTITLE", file_title);
|
|
#ifdef STOCK_TEST
|
|
params[n] = IupBackgroundBox(tbox);
|
|
IupSetStrAttribute(params[n], "BGCOLOR", IupGetAttribute(IupGetDialog(ih), "BGCOLOR"));
|
|
#else
|
|
params[n] = tbox;
|
|
#endif
|
|
n++;
|
|
}
|
|
|
|
lbox = (Ihandle*)IupGetAttribute(tbox, file_title);
|
|
if (!lbox || IupGetInt(lbox, "LINE_COUNT") == 10)
|
|
{
|
|
lbox = IupHbox(NULL);
|
|
IupAppend(tbox, lbox);
|
|
IupSetAttribute(tbox, file_title, (char*)lbox);
|
|
IupSetAttribute(lbox, "LINE_COUNT", "0");
|
|
}
|
|
|
|
button = IupButton("", NULL);
|
|
#ifdef STOCK_TEST
|
|
IupSetAttribute(button, "FLAT", "Yes");
|
|
#endif
|
|
IupSetStrAttribute(button, "IMAGE", name);
|
|
IupSetfAttribute(button, "_INFO", "%s [%d,%d]", name, IupGetInt(elem, "WIDTH"), IupGetInt(elem, "HEIGHT"));
|
|
IupSetCallback(button, "ACTION", (Icallback)imagebutton_cb);
|
|
IupAppend(lbox, button);
|
|
IupSetfAttribute(lbox, "LINE_COUNT", "%d", IupGetInt(lbox, "LINE_COUNT")+1);
|
|
}
|
|
|
|
params[n] = NULL;
|
|
|
|
box = IupVbox(toggle = IupToggle("INACTIVE", NULL),
|
|
tabs = IupTabsv(params),
|
|
label = IupLabel(""),
|
|
NULL);
|
|
IupSetAttribute(box, "MARGIN", "10x10");
|
|
IupSetAttribute(box, "GAP", "10");
|
|
IupSetAttribute(tabs, "ALIGNMENT", "NW");
|
|
IupSetAttribute(tabs, "SIZE", "150x80");
|
|
IupSetCallback(toggle, "ACTION", (Icallback)inactivetoggle_cb);
|
|
IupSetAttribute(toggle, "TABS", (char*)tabs);
|
|
IupSetAttribute(label, "EXPAND", "HORIZONTAL");
|
|
|
|
dialog = IupDialog(box);
|
|
IupSetAttribute(dialog, "TITLE", "All Images");
|
|
IupSetCallback(dialog, "CLOSE_CB", (Icallback)close_cb);
|
|
IupSetAttribute(dialog, "_INFO_LABEL", (char*)label);
|
|
IupSetAttributeHandle(dialog, "PARENTDIALOG", IupGetDialog(ih));
|
|
|
|
IupPopup(dialog, IUP_CENTER, IUP_CENTER);
|
|
|
|
IupDestroy(dialog);
|
|
IupDestroy(files);
|
|
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static char* getfileformat(int all)
|
|
{
|
|
#define NUM_FORMATS 7
|
|
int ret, count = NUM_FORMATS;
|
|
static char *options[NUM_FORMATS] = {
|
|
"LED",
|
|
"LUA",
|
|
"C",
|
|
"ICO",
|
|
"BMP",
|
|
"GIF",
|
|
"PNG"
|
|
};
|
|
|
|
if (!all)
|
|
count = 3;
|
|
|
|
ret = IupListDialog(1,"File Format",count,options,1,9,count+1,NULL);
|
|
if (ret == -1)
|
|
return NULL;
|
|
else
|
|
return options[ret];
|
|
}
|
|
|
|
static char* getfolder(void)
|
|
{
|
|
static char folder[10240];
|
|
Ihandle *filedlg = IupFileDlg();
|
|
|
|
IupSetAttribute(filedlg, "DIALOGTYPE", "DIR");
|
|
IupSetAttribute(filedlg, "TITLE", "Select Folder for Images");
|
|
|
|
IupPopup(filedlg, IUP_CENTER, IUP_CENTER);
|
|
|
|
if (IupGetInt(filedlg, "STATUS") != -1)
|
|
{
|
|
strcpy(folder, IupGetAttribute(filedlg, "VALUE"));
|
|
IupDestroy(filedlg);
|
|
return folder;
|
|
}
|
|
|
|
IupDestroy(filedlg);
|
|
return NULL;
|
|
}
|
|
|
|
static char* StrLower(const char* sstr)
|
|
{
|
|
static char buf[10];
|
|
iupStrLower(buf, sstr);
|
|
return buf;
|
|
}
|
|
|
|
static int saveallimages_cb(void)
|
|
{
|
|
char *names[MAX_NAMES];
|
|
char* folder;
|
|
int i, n = 0, num_names = IupGetAllNames(names, MAX_NAMES);
|
|
|
|
char* imgtype = getfileformat(1);
|
|
if (!imgtype)
|
|
return IUP_DEFAULT;
|
|
|
|
folder = getfolder();
|
|
if (!folder)
|
|
return IUP_DEFAULT;
|
|
|
|
for (i = 0; i < num_names; i++)
|
|
{
|
|
Ihandle* elem = IupGetHandle(names[i]);
|
|
|
|
if (elem->iclass->nativetype == IUP_TYPEIMAGE)
|
|
{
|
|
char filename[10240] = "";
|
|
|
|
/* save only loaded images */
|
|
char* file_title = IupGetAttribute(elem, "_FILE_TITLE");
|
|
if (!file_title)
|
|
continue;
|
|
|
|
strcpy(filename, folder);
|
|
strcat(filename, "/");
|
|
strcat(filename, file_title);
|
|
strcat(filename, "_");
|
|
strcat(filename, names[i]);
|
|
strcat(filename, ".");
|
|
strcat(filename, StrLower(imgtype));
|
|
|
|
if (!IupSaveImageAsText(elem, filename, imgtype, names[i]))
|
|
{
|
|
#ifdef USE_IM
|
|
if (!IupSaveImage(elem, filename, imgtype))
|
|
{
|
|
char* err_msg = IupGetGlobal("IUPIM_LASTERROR");
|
|
if (err_msg)
|
|
IupMessage("Error", err_msg);
|
|
return IUP_DEFAULT;
|
|
}
|
|
#else
|
|
IupMessage("Error", "Failed to save the image.");
|
|
return IUP_DEFAULT;
|
|
#endif
|
|
}
|
|
|
|
n++;
|
|
}
|
|
}
|
|
|
|
if (n == 0)
|
|
{
|
|
IupMessage("Error", "No images.");
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int GetSaveAsFile(char* file, const char* imgtype)
|
|
{
|
|
Ihandle *gf;
|
|
int ret;
|
|
char *value;
|
|
|
|
gf = IupFileDlg();
|
|
IupSetAttribute(gf, "DIALOGTYPE", "SAVE");
|
|
IupSetfAttribute(gf, "TITLE", "Save %s File", imgtype);
|
|
IupSetfAttribute(gf, "FILTER", "*.%s", StrLower(imgtype));
|
|
IupSetAttribute(gf, "FILE", file);
|
|
IupPopup(gf, IUP_CENTER, IUP_CENTER);
|
|
|
|
value = IupGetAttribute( gf, "VALUE" );
|
|
if (value) strcpy( file, value );
|
|
ret = IupGetInt( gf, "STATUS" );
|
|
|
|
IupDestroy(gf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static void replaceDot(char* filename)
|
|
{
|
|
/* replace all "." by "_" */
|
|
/* replace all "-" by "_" */
|
|
while(*filename)
|
|
{
|
|
if (*filename == '.')
|
|
*filename = '_';
|
|
if (*filename == '-')
|
|
*filename = '_';
|
|
|
|
filename++;
|
|
}
|
|
}
|
|
|
|
static char* strdup_free(const char* str, char* str_ptr)
|
|
{
|
|
int len = (int)strlen(str);
|
|
char* tmp = malloc(len+1);
|
|
memcpy(tmp, str, len+1);
|
|
free(str_ptr);
|
|
return tmp;
|
|
}
|
|
|
|
static char* mainGetFileTitle(const char* filename)
|
|
{
|
|
int i, last = 1, len = (int)strlen(filename);
|
|
char* file_title = malloc(len+1);
|
|
char* dot, *ft_str = file_title;
|
|
|
|
memcpy(file_title, filename, len+1);
|
|
|
|
dot = strchr(file_title, '.');
|
|
if (dot) *dot = 0;
|
|
|
|
for(i = len-1; i >= 0; i--)
|
|
{
|
|
if (last && file_title[i] == '.')
|
|
{
|
|
/* cut last "." forward */
|
|
file_title[i] = 0;
|
|
last = 0;
|
|
}
|
|
|
|
if (file_title[i] == '\\' || file_title[i] == '/')
|
|
{
|
|
replaceDot(file_title+i+1);
|
|
return strdup_free(file_title+i+1, ft_str);
|
|
}
|
|
}
|
|
|
|
replaceDot(file_title);
|
|
return strdup_free(file_title, ft_str);
|
|
}
|
|
|
|
static char* iStrGetNoReserved(const char* p_name)
|
|
{
|
|
static char name[128];
|
|
strcpy(name, p_name);
|
|
iupStrReplaceReserved(name, '_');
|
|
return name;
|
|
}
|
|
|
|
static int saveallimagesone_cb(void)
|
|
{
|
|
char filename[10240] = "*.";
|
|
char *names[MAX_NAMES];
|
|
int i, n = 0, num_names = IupGetAllNames(names, MAX_NAMES);
|
|
FILE* packfile = NULL;
|
|
|
|
char* imgtype = getfileformat(0);
|
|
if (!imgtype)
|
|
return IUP_DEFAULT;
|
|
|
|
strcat(filename, StrLower(imgtype));
|
|
if (GetSaveAsFile(filename, imgtype) == -1)
|
|
return IUP_DEFAULT;
|
|
|
|
for (i = 0; i < num_names; i++)
|
|
{
|
|
Ihandle* elem = IupGetHandle(names[i]);
|
|
|
|
if (elem->iclass->nativetype == IUP_TYPEIMAGE)
|
|
{
|
|
/* save only loaded images */
|
|
char* file_title = IupGetAttribute(elem, "_FILE_TITLE");
|
|
if (!file_title)
|
|
{
|
|
names[i] = NULL;
|
|
continue;
|
|
}
|
|
|
|
if (!packfile)
|
|
{
|
|
packfile = fopen(filename, "wb");
|
|
|
|
if (!packfile)
|
|
{
|
|
IupMessage("Error", "Failed to open the file.");
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
if (iupStrEqualNoCase(imgtype, "C"))
|
|
{
|
|
fprintf(packfile, "/* Generated by IupView export to C. */\n\n");
|
|
|
|
fprintf(packfile, "#include <stdlib.h>\n");
|
|
fprintf(packfile, "#include <iup.h>\n\n");
|
|
}
|
|
else if (iupStrEqualNoCase(imgtype, "LUA"))
|
|
{
|
|
fprintf(packfile, "-- Generated by IupView export to Lua.\n\n");
|
|
}
|
|
else
|
|
{
|
|
fprintf(packfile, "# Generated by IupView export to LED.\n\n");
|
|
}
|
|
}
|
|
|
|
if (!iupImageExportToFile(elem, packfile, imgtype, names[i]))
|
|
{
|
|
fclose(packfile);
|
|
IupMessage("Error", "Failed to write to the file.");
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
n++;
|
|
}
|
|
else
|
|
names[i] = NULL;
|
|
}
|
|
|
|
if (packfile)
|
|
{
|
|
if (iupStrEqualNoCase(imgtype, "C"))
|
|
{
|
|
char* title = mainGetFileTitle(filename);
|
|
iupStrReplaceReserved(title, '_');
|
|
fprintf(packfile, "void create_images_%s(void)\n{\n", title);
|
|
free(title);
|
|
|
|
for (i = 0; i < num_names; i++)
|
|
{
|
|
if (names[i])
|
|
fprintf(packfile, " IupSetHandle(\"%s\", create_image_%s());\n", names[i], iStrGetNoReserved(names[i]));
|
|
}
|
|
fprintf(packfile, "}\n\n");
|
|
}
|
|
else if (iupStrEqualNoCase(imgtype, "LUA"))
|
|
{
|
|
char* title = mainGetFileTitle(filename);
|
|
iupStrReplaceReserved(title, '_');
|
|
fprintf(packfile, "function create_images_%s()\n\n", title);
|
|
free(title);
|
|
|
|
for (i = 0; i < num_names; i++)
|
|
{
|
|
if (names[i])
|
|
fprintf(packfile, " iup.SetHandle(\"%s\", create_image_%s())\n", names[i], iStrGetNoReserved(names[i]));
|
|
}
|
|
fprintf(packfile, "end\n\n");
|
|
}
|
|
|
|
fclose(packfile);
|
|
}
|
|
|
|
if (n == 0)
|
|
{
|
|
IupMessage("Error", "No images.");
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int saveimage_cb(Ihandle* self)
|
|
{
|
|
Ihandle* list = (Ihandle*)IupGetAttribute(self, "mainList");
|
|
char* name = IupGetAttribute(list, IupGetAttribute(list, "VALUE"));
|
|
|
|
if (name) /* the list may be empty */
|
|
{
|
|
Ihandle* elem = IupGetHandle(name);
|
|
|
|
if (elem->iclass->nativetype == IUP_TYPEIMAGE)
|
|
{
|
|
char filename[10240];
|
|
|
|
char* imgtype = getfileformat(1);
|
|
if (!imgtype)
|
|
return IUP_DEFAULT;
|
|
|
|
sprintf(filename, "%s.%s", name, StrLower(imgtype));
|
|
if (GetSaveAsFile(filename, imgtype) != -1)
|
|
{
|
|
if (!IupSaveImageAsText(elem, filename, imgtype, name))
|
|
{
|
|
#ifdef USE_IM
|
|
if (!IupSaveImage(elem, filename, imgtype))
|
|
{
|
|
char* err_msg = IupGetGlobal("IUPIM_LASTERROR");
|
|
if (err_msg)
|
|
IupMessage("Error", err_msg);
|
|
return IUP_DEFAULT;
|
|
}
|
|
#else
|
|
IupMessage("Error", "Failed to save the image.");
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
else
|
|
IupMessage("Error", "Not an image.");
|
|
}
|
|
else
|
|
IupMessage("Error", "No elements.");
|
|
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int hideelem_cb(Ihandle* self)
|
|
{
|
|
Ihandle* list = (Ihandle*)IupGetAttribute(self, "mainList");
|
|
char* name = IupGetAttribute(list, IupGetAttribute(list, "VALUE"));
|
|
|
|
if (name) /* the list may be empty */
|
|
{
|
|
Ihandle* elem = IupGetHandle(name);
|
|
char* type = IupGetClassName(elem);
|
|
|
|
if (iupStrEqual(type, "dialog"))
|
|
IupHide(elem);
|
|
else
|
|
{
|
|
Ihandle* dialog = IupGetDialog(elem);
|
|
if (dialog)
|
|
IupHide(dialog);
|
|
else
|
|
IupMessage("Error", "Will only hide dialogs.");
|
|
}
|
|
}
|
|
else
|
|
IupMessage("Error", "No elements.");
|
|
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int layoutdlg_cb(Ihandle* self)
|
|
{
|
|
Ihandle* list = (Ihandle*)IupGetAttribute(self, "mainList");
|
|
char* name = IupGetAttribute(list, IupGetAttribute(list, "VALUE"));
|
|
|
|
if (name) /* the list may be empty */
|
|
{
|
|
Ihandle* elem = IupGetHandle(name);
|
|
char* type = IupGetClassName(elem);
|
|
|
|
if (iupStrEqual(type, "dialog"))
|
|
IupShow(IupLayoutDialog(elem));
|
|
else
|
|
{
|
|
Ihandle* dialog = IupGetDialog(elem);
|
|
if (dialog)
|
|
IupShow(IupLayoutDialog(dialog));
|
|
else
|
|
IupMessage("Error", "The element must be a dialog or be inside a dialog.");
|
|
}
|
|
}
|
|
else
|
|
IupMessage("Error", "No elements.");
|
|
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int propertiesdlg_cb(Ihandle* self)
|
|
{
|
|
Ihandle* list = (Ihandle*)IupGetAttribute(self, "mainList");
|
|
char* name = IupGetAttribute(list, IupGetAttribute(list, "VALUE"));
|
|
|
|
if (name) /* the list may be empty */
|
|
{
|
|
Ihandle* elem = IupGetHandle(name);
|
|
Ihandle* dlg = IupElementPropertiesDialog(IupGetDialog(list), elem);
|
|
IupPopup(dlg, IUP_CENTERPARENT, IUP_CENTERPARENT);
|
|
IupDestroy(dlg);
|
|
}
|
|
else
|
|
IupMessage("Error", "No elements.");
|
|
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int showelem_cb(Ihandle* self)
|
|
{
|
|
Ihandle* list = (Ihandle*)IupGetAttribute(self, "mainList");
|
|
char* name = IupGetAttribute(list, IupGetAttribute(list, "VALUE"));
|
|
|
|
if (name) /* the list may be empty */
|
|
{
|
|
Ihandle* elem = IupGetHandle(name);
|
|
char* type = IupGetClassName(elem);
|
|
|
|
if (iupStrEqual(type, "dialog"))
|
|
IupShow(elem);
|
|
else
|
|
{
|
|
Ihandle* dialog = IupGetDialog(elem);
|
|
if (dialog)
|
|
IupShow(dialog);
|
|
else
|
|
{
|
|
if (iupStrEqual(type, "menu"))
|
|
IupPopup(elem, IUP_MOUSEPOS, IUP_MOUSEPOS);
|
|
else
|
|
IupMessage("Error", "Will only show dialogs and independent menus.");
|
|
}
|
|
}
|
|
}
|
|
else
|
|
IupMessage("Error", "No elements.");
|
|
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int list_dbclick_cb(Ihandle* self, int i, char *t)
|
|
{
|
|
(void)i;
|
|
(void)t;
|
|
showelem_cb(self);
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int list_cb(Ihandle* self, char *t, int i, int v)
|
|
{
|
|
if (v == 1)
|
|
{
|
|
char str_elem[100];
|
|
Ihandle* elem = IupGetHandle(t);
|
|
Ihandle* label = (Ihandle*)IupGetAttribute(self, "mainLabel");
|
|
sprintf(str_elem, "FileTitle: %s - Type: %s", IupGetAttribute(elem, "_FILE_TITLE"), IupGetClassName(elem));
|
|
IupStoreAttribute(label, "TITLE", str_elem);
|
|
}
|
|
(void)i;
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static void mainUpdateInternals(void)
|
|
{
|
|
char *names[MAX_NAMES];
|
|
int i, num_names = IupGetAllNames(names, MAX_NAMES);
|
|
for (i = 0; i < num_names; i++)
|
|
{
|
|
Ihandle* elem = IupGetHandle(names[i]);
|
|
|
|
if (!IupGetAttribute(elem, "_FILE_TITLE"))
|
|
IupSetAttribute(elem, "_INTERNAL", "YES");
|
|
}
|
|
}
|
|
|
|
static int checkArray(Ihandle* *ih_array, int count, Ihandle* ih)
|
|
{
|
|
int i;
|
|
for (i = 0; i < count; i++)
|
|
{
|
|
if (ih_array[i] == ih)
|
|
return 0;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
static int destroyall_cb(Ihandle* self)
|
|
{
|
|
char *names[MAX_NAMES];
|
|
Ihandle* ih;
|
|
Ihandle* ih_names[MAX_NAMES];
|
|
Ihandle* list = (Ihandle*)IupGetAttribute(self, "mainList");
|
|
int i, j=0, num_names = IupGetAllNames(names, MAX_NAMES);
|
|
memset(ih_names, 0, MAX_NAMES * sizeof(Ihandle*));
|
|
for (i = 0; i < num_names; i++)
|
|
{
|
|
ih = IupGetHandle(names[i]);
|
|
if (iupObjectCheck(ih) && IupGetInt(ih, "_INTERNAL") == 0)
|
|
{
|
|
ih = IupGetDialog(ih);
|
|
if (checkArray(ih_names, j, ih))
|
|
{
|
|
ih_names[j] = ih;
|
|
j++;
|
|
}
|
|
}
|
|
}
|
|
num_names = j;
|
|
|
|
for (i = 0; i < num_names; i++)
|
|
{
|
|
Ihandle* elem = ih_names[i];
|
|
|
|
if (iupObjectCheck(elem))
|
|
{
|
|
char* type = IupGetClassName(elem);
|
|
|
|
if (iupStrEqual(type, "dialog"))
|
|
IupDestroy(elem);
|
|
else
|
|
{
|
|
Ihandle* dialog = IupGetDialog(elem);
|
|
if (!dialog)
|
|
IupDestroy(elem);
|
|
}
|
|
}
|
|
}
|
|
|
|
IupSetAttribute(list, "1", NULL);
|
|
IupSetAttribute(list, "VALUE", "1");
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static void mainUpdateList(Ihandle* self, const char* filename)
|
|
{
|
|
char *names[MAX_NAMES];
|
|
char str_item[20];
|
|
Ihandle* list = (Ihandle*)IupGetAttribute(self, "mainList");
|
|
int i, n = 0, num_names = IupGetAllNames(names, MAX_NAMES);
|
|
char* file_title = mainGetFileTitle(filename);
|
|
for (i = 0; i < num_names; i++)
|
|
{
|
|
Ihandle* elem = IupGetHandle(names[i]);
|
|
|
|
if (IupGetInt(elem, "_INTERNAL") == 0)
|
|
{
|
|
sprintf(str_item, "%d", n+1);
|
|
IupSetAttribute(list, str_item, names[i]);
|
|
|
|
if (!IupGetAttribute(elem, "_FILE_TITLE"))
|
|
IupStoreAttribute(elem, "_FILE_TITLE", file_title);
|
|
n++;
|
|
}
|
|
}
|
|
sprintf(str_item, "%d", n+1);
|
|
IupSetAttribute(list, str_item, NULL);
|
|
|
|
if (n != 0)
|
|
{
|
|
IupSetAttribute(list, "VALUE", "1");
|
|
list_cb(list, IupGetAttribute(list, "1"), -1, 1);
|
|
}
|
|
|
|
free(file_title);
|
|
}
|
|
|
|
static int loadimagelib_cb(Ihandle* self)
|
|
{
|
|
mainUpdateInternals();
|
|
|
|
iupImageStockLoadAll();
|
|
|
|
mainUpdateList(self, "ImageLib");
|
|
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int loadbuffer_cb(Ihandle* self)
|
|
{
|
|
char buffer[10240] = "";
|
|
if (IupGetText("LED", buffer, 10240))
|
|
{
|
|
char* error;
|
|
|
|
mainUpdateInternals();
|
|
|
|
error = IupLoadBuffer(buffer);
|
|
if (error)
|
|
IupMessage("Error", error);
|
|
else
|
|
mainUpdateList(self, "<Buffer>");
|
|
}
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int loadled_cb(Ihandle* self)
|
|
{
|
|
char filename[10240] = "./*.led";
|
|
int ret = IupGetFile(filename);
|
|
if (ret == 0)
|
|
{
|
|
char* error;
|
|
|
|
mainUpdateInternals();
|
|
|
|
error = IupLoad(filename);
|
|
if (error)
|
|
IupMessage("Error", error);
|
|
else
|
|
mainUpdateList(self, filename);
|
|
}
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
#ifdef USE_IM
|
|
#ifdef WIN32
|
|
static char* ParseFile(const char* dir, const char* FileName, int *offset)
|
|
{
|
|
const char* file = FileName;
|
|
while (*file != 0 && *file != '|')
|
|
file++;
|
|
|
|
if (file == FileName)
|
|
return NULL;
|
|
|
|
{
|
|
int size = (int)(file - FileName) + 1;
|
|
int dir_size = (int)strlen(dir);
|
|
char* filename = malloc(size+dir_size+1);
|
|
memcpy(filename, dir, dir_size);
|
|
filename[dir_size] = '\\';
|
|
memcpy(filename+dir_size+1, FileName, size-1);
|
|
filename[size+dir_size] = 0;
|
|
*offset += size;
|
|
return filename;
|
|
}
|
|
}
|
|
|
|
static char* ParseDir(const char* FileName, int *offset)
|
|
{
|
|
const char* file = FileName;
|
|
while (*file != 0 && *file != '|')
|
|
file++;
|
|
|
|
if (*file == 0)
|
|
return NULL;
|
|
|
|
{
|
|
int size = (int)(file - FileName) + 1;
|
|
char* dir = malloc(size);
|
|
memcpy(dir, FileName, size-1);
|
|
dir[size-1] = 0;
|
|
*offset = size;
|
|
return dir;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
static void LoadImageFile(Ihandle* self, const char* filename)
|
|
{
|
|
Ihandle* new_image = IupLoadImage(filename);
|
|
if (new_image)
|
|
{
|
|
char* file_title = mainGetFileTitle(filename);
|
|
IupSetHandle(file_title, new_image);
|
|
free(file_title);
|
|
mainUpdateList(self, filename);
|
|
}
|
|
else
|
|
{
|
|
char* err_msg = IupGetGlobal("IUPIM_LASTERROR");
|
|
if (err_msg)
|
|
IupMessage("Error", err_msg);
|
|
}
|
|
}
|
|
|
|
static int getOpenFileName(char* file)
|
|
{
|
|
Ihandle *gf;
|
|
int ret;
|
|
char *value;
|
|
|
|
gf = IupFileDlg();
|
|
IupSetAttribute(gf, "DIALOGTYPE", "OPEN");
|
|
IupSetAttribute(gf, "TITLE", "Load Image File(s)");
|
|
IupSetAttribute(gf, "MULTIPLEFILES", "YES");
|
|
IupPopup(gf, IUP_CENTER, IUP_CENTER);
|
|
|
|
value = IupGetAttribute(gf, "VALUE");
|
|
if (value) strcpy(file, value);
|
|
ret = IupGetInt(gf, "STATUS");
|
|
|
|
IupDestroy(gf);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static int loadimage_cb(Ihandle* self)
|
|
{
|
|
char FileName[2000] = "*.*";
|
|
|
|
/* Retrieve a file name */
|
|
if (getOpenFileName(FileName) == -1)
|
|
return IUP_DEFAULT;
|
|
|
|
mainUpdateInternals();
|
|
|
|
#ifdef WIN32
|
|
/* parse multiple files */
|
|
{
|
|
int offset;
|
|
char* filename;
|
|
char* dir = ParseDir(FileName, &offset);
|
|
if (dir)
|
|
{
|
|
while ((filename = ParseFile(dir, FileName + offset, &offset)) != NULL)
|
|
{
|
|
LoadImageFile(self, filename);
|
|
free(filename);
|
|
}
|
|
free(dir);
|
|
}
|
|
else
|
|
LoadImageFile(self, FileName);
|
|
}
|
|
#else
|
|
LoadImageFile(self, FileName);
|
|
#endif
|
|
|
|
return IUP_DEFAULT;
|
|
}
|
|
#endif
|
|
|
|
static int dropfile_cb(Ihandle *self, char* filename)
|
|
{
|
|
char* error;
|
|
|
|
mainUpdateInternals();
|
|
|
|
error = IupLoad(filename);
|
|
if (error)
|
|
IupMessage("Error", error);
|
|
else
|
|
mainUpdateList(self, filename);
|
|
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static int use_utf8_cb(Ihandle *self)
|
|
{
|
|
(void)self;
|
|
if (IupGetInt(NULL, "UTF8MODE"))
|
|
IupSetGlobal("UTF8MODE", "No");
|
|
else
|
|
IupSetGlobal("UTF8MODE", "Yes");
|
|
return IUP_DEFAULT;
|
|
}
|
|
|
|
static Ihandle* mainDialog(void)
|
|
{
|
|
Ihandle *main_dialog, *box, *menu, *list, *label;
|
|
|
|
menu = IupMenu(
|
|
IupSubmenu("File", IupMenu(
|
|
IupSetCallbacks(IupItem("Load Buffer...", NULL), "ACTION", (Icallback)loadbuffer_cb, NULL),
|
|
IupSetCallbacks(IupItem("Load Led...", NULL), "ACTION", (Icallback)loadled_cb, NULL),
|
|
IupSeparator(),
|
|
IupSetCallbacks(IupItem("Load Image Lib", NULL), "ACTION", (Icallback)loadimagelib_cb, NULL),
|
|
#ifdef USE_IM
|
|
IupSetCallbacks(IupItem("Import Image(s)...", NULL), "ACTION", (Icallback)loadimage_cb, NULL),
|
|
#endif
|
|
IupSeparator(),
|
|
IupSetCallbacks(IupSetAttributes(IupItem("Use UTF-8", NULL), "AUTOTOGGLE=Yes"), "ACTION", (Icallback)use_utf8_cb, NULL),
|
|
IupSetCallbacks(IupItem("Exit", NULL), "ACTION", (Icallback)close_cb, NULL),
|
|
NULL)),
|
|
IupSubmenu("Element", IupMenu(
|
|
IupSetCallbacks(IupItem("Show...", NULL), "ACTION", (Icallback)showelem_cb, NULL),
|
|
IupSetCallbacks(IupItem("Hide Dialog", NULL), "ACTION", (Icallback)hideelem_cb, NULL),
|
|
IupSetCallbacks(IupItem("Dialog Layout...", NULL), "ACTION", (Icallback)layoutdlg_cb, NULL),
|
|
IupSetCallbacks(IupItem("Element Properties...", NULL), "ACTION", (Icallback)propertiesdlg_cb, NULL),
|
|
IupSeparator(),
|
|
IupSetCallbacks(IupItem("Destroy All...", NULL), "ACTION", (Icallback)destroyall_cb, NULL),
|
|
IupSetCallbacks(IupItem("Show All Images...", NULL), "ACTION", (Icallback)showallimages_cb, NULL),
|
|
IupSeparator(),
|
|
IupSetCallbacks(IupItem("Save Image...", NULL), "ACTION", (Icallback)saveimage_cb, NULL),
|
|
IupSetCallbacks(IupItem("Save All Images...", NULL), "ACTION", (Icallback)saveallimages_cb, NULL),
|
|
IupSetCallbacks(IupItem("Save All Images (One File)...", NULL), "ACTION", (Icallback)saveallimagesone_cb, NULL),
|
|
NULL)),
|
|
IupSubmenu("Help", IupMenu(
|
|
IupSetCallbacks(IupItem("About...", NULL), "ACTION", (Icallback)about_cb, NULL),
|
|
NULL)),
|
|
NULL
|
|
);
|
|
IupSetHandle("mainMenu", menu);
|
|
|
|
box = IupVbox(
|
|
IupLabel("Elements:"),
|
|
list = IupList(NULL),
|
|
IupSetAttributes(IupFill(), "SIZE=2"),
|
|
IupFrame(label = IupLabel("")),
|
|
NULL);
|
|
IupSetAttribute(box, "MARGIN", "10x10");
|
|
IupSetAttribute(list, "SORT", "YES");
|
|
IupSetCallback(list, "ACTION", (Icallback)list_cb);
|
|
IupSetCallback(list, "DBLCLICK_CB", (Icallback)list_dbclick_cb);
|
|
|
|
IupSetAttribute(list, "SIZE", "150x80");
|
|
IupSetAttribute(list, "EXPAND", "YES");
|
|
IupSetAttribute(label, "EXPAND", "HORIZONTAL");
|
|
|
|
main_dialog = IupDialog(box);
|
|
IupSetAttribute(main_dialog, "TITLE", "IupView");
|
|
IupSetAttribute(main_dialog, "MENU", "mainMenu");
|
|
IupSetAttribute(main_dialog, "mainList", (char*)list);
|
|
IupSetAttribute(main_dialog, "mainLabel", (char*)label);
|
|
IupSetCallback(main_dialog, "CLOSE_CB", (Icallback)close_cb);
|
|
IupSetCallback(main_dialog, "DROPFILES_CB", (Icallback)dropfile_cb);
|
|
IupSetAttribute(main_dialog, "_INTERNAL", "YES");
|
|
|
|
IupSetAttribute(menu, "mainList", (char*)list);
|
|
IupSetAttribute(menu, "mainLabel", (char*)label);
|
|
|
|
return main_dialog;
|
|
}
|
|
|
|
static int converter_usage(void)
|
|
{
|
|
fprintf(stderr,
|
|
"iupview [-h] [-t type] [-o out_file] in_files\n"
|
|
" IUP version: %s\n"
|
|
" Converts image files to source code that creates an IupImage.\n"
|
|
" Can pack several files in a single output file.\n"
|
|
" Each image will correspond to a function called create_image_<filetitle>,\n"
|
|
" where <filetitle> is the file name of the input image without path.\n"
|
|
" -h print this help\n"
|
|
" -t output format, can be LED, LUA or C (default: C)\n"
|
|
" -o out_file place output in file <out_file> (default: images.c)\n"
|
|
, IupVersion());
|
|
return -1;
|
|
}
|
|
|
|
static void replace_dots(char* sstr)
|
|
{
|
|
for (; *sstr; sstr++)
|
|
{
|
|
if (*sstr == '.')
|
|
*sstr = '_';
|
|
}
|
|
}
|
|
|
|
static int image_converter(int argc, char **argv)
|
|
{
|
|
char* outname = NULL;
|
|
char* imgtype = NULL;
|
|
char* intitle;
|
|
FILE* outfile;
|
|
|
|
while (argc > 1)
|
|
{
|
|
char *op = *(argv+1);
|
|
if (op[0] != '-') break;
|
|
argc--;
|
|
argv++;
|
|
switch (op[1])
|
|
{
|
|
case 'h':
|
|
return converter_usage();
|
|
case 'o':
|
|
if (argc>1)
|
|
{
|
|
argc--;
|
|
argv++;
|
|
outname = *argv;
|
|
break;
|
|
}
|
|
else
|
|
return converter_usage();
|
|
case 't':
|
|
if (argc>1)
|
|
{
|
|
argc--;
|
|
argv++;
|
|
imgtype = *argv;
|
|
break;
|
|
}
|
|
else
|
|
return converter_usage();
|
|
default:
|
|
return converter_usage();
|
|
}
|
|
}
|
|
|
|
if (!outname) outname = "images.c";
|
|
if (!imgtype) imgtype = "C";
|
|
|
|
outfile = fopen(outname, "wb");
|
|
if (!outfile)
|
|
{
|
|
printf("Error: Failed to open the output file.");
|
|
return -1;
|
|
}
|
|
|
|
IupOpen(&argc, &argv);
|
|
|
|
while (--argc > 0)
|
|
{
|
|
char* inname = *++argv;
|
|
Ihandle* image = IupLoadImage(inname);
|
|
if (!image)
|
|
{
|
|
printf("Error: %s\n", IupGetGlobal("IUPIM_LASTERROR"));
|
|
|
|
fclose(outfile);
|
|
IupClose();
|
|
return -1;
|
|
}
|
|
|
|
intitle = iupStrFileGetTitle(inname);
|
|
replace_dots(intitle);
|
|
|
|
if (!iupImageExportToFile(image, outfile, imgtype, intitle))
|
|
{
|
|
printf("Error: Failed to write to the output file.");
|
|
|
|
free(intitle);
|
|
IupDestroy(image);
|
|
|
|
fclose(outfile);
|
|
IupClose();
|
|
return -1;
|
|
}
|
|
|
|
free(intitle);
|
|
IupDestroy(image);
|
|
}
|
|
|
|
fclose(outfile);
|
|
IupClose();
|
|
return 0;
|
|
}
|
|
|
|
int main (int argc, char **argv)
|
|
{
|
|
if (argc < 2)
|
|
{
|
|
Ihandle* main_dialog;
|
|
|
|
IupOpen(&argc, &argv);
|
|
IupImageLibOpen();
|
|
IupControlsOpen();
|
|
IupImOpen();
|
|
#ifndef USE_NO_OPENGL
|
|
IupGLCanvasOpen();
|
|
#endif
|
|
|
|
#ifdef STOCK_TEST
|
|
IupSetGlobal("IMAGESTOCKSIZE", STOCK_TEST);
|
|
IupSetGlobal("IMAGESTOCKAUTOSCALE", "NO");
|
|
#endif
|
|
|
|
IupSetGlobal("GLOBALLAYOUTDLGKEY", "Yes");
|
|
/* IupSetGlobal("UTF8MODE", "YES"); */
|
|
|
|
mainUpdateInternals();
|
|
|
|
main_dialog = mainDialog();
|
|
IupShow(main_dialog);
|
|
|
|
IupMainLoop();
|
|
IupClose();
|
|
|
|
return 0;
|
|
}
|
|
else
|
|
return image_converter(argc, argv);
|
|
}
|
|
|