419 lines
13 KiB
C
419 lines
13 KiB
C
|
/** \file
|
||
|
|
* \brief IupMatrix control core
|
||
|
|
*
|
||
|
|
* See Copyright Notice in "iup.h"
|
||
|
|
*/
|
||
|
|
|
||
|
|
#include <stdio.h>
|
||
|
|
#include <stdlib.h>
|
||
|
|
#include <limits.h>
|
||
|
|
#include <stdarg.h>
|
||
|
|
#include <string.h>
|
||
|
|
|
||
|
|
#include "iup.h"
|
||
|
|
#include "iupcbs.h"
|
||
|
|
#include "iupcontrols.h"
|
||
|
|
|
||
|
|
#include <cd.h>
|
||
|
|
|
||
|
|
#include "iup_object.h"
|
||
|
|
#include "iup_attrib.h"
|
||
|
|
#include "iup_str.h"
|
||
|
|
#include "iup_stdcontrols.h"
|
||
|
|
#include "iup_controls.h"
|
||
|
|
#include "iup_register.h"
|
||
|
|
|
||
|
|
#include "iupmat_def.h"
|
||
|
|
#include "iupmat_getset.h"
|
||
|
|
#include "iupmat_draw.h"
|
||
|
|
#include "iupmat_aux.h"
|
||
|
|
|
||
|
|
|
||
|
|
/* Exported to IupMatrixEx */
|
||
|
|
char* iupMatrixExGetCellValue(Ihandle* ih, int lin, int col, int display)
|
||
|
|
{
|
||
|
|
if (display)
|
||
|
|
return iupMatrixGetValueDisplay(ih, lin, col); /* Display value */
|
||
|
|
else
|
||
|
|
return iupMatrixGetValue(ih, lin, col); /* Internal value (Maximum Precision) */
|
||
|
|
}
|
||
|
|
|
||
|
|
/* Exported to IupMatrixEx */
|
||
|
|
void iupMatrixExSetCellValue(Ihandle* ih, int lin, int col, const char* value)
|
||
|
|
{
|
||
|
|
iupMatrixModifyValue(ih, lin, col, value);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int iMatrixInitNumericColumns(Ihandle* ih, int col)
|
||
|
|
{
|
||
|
|
if (!iupMATRIX_CHECK_COL(ih, col))
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
if (!ih->data->numeric_columns)
|
||
|
|
ih->data->numeric_columns = (ImatNumericData*)calloc(ih->data->columns.num_alloc, sizeof(ImatNumericData));
|
||
|
|
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int iMatrixSetNumericFlag(Ihandle* ih, int col, unsigned char attr, int set)
|
||
|
|
{
|
||
|
|
if (!iMatrixInitNumericColumns(ih, col))
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
if (set)
|
||
|
|
ih->data->numeric_columns[col].flags |= attr;
|
||
|
|
else
|
||
|
|
ih->data->numeric_columns[col].flags &= ~attr;
|
||
|
|
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int iMatrixSetNumericQuantityIndexAttrib(Ihandle* ih, int col, const char* value)
|
||
|
|
{
|
||
|
|
int quantity;
|
||
|
|
int set = iupStrToInt(value, &quantity); /* if NULL or fail will unset */
|
||
|
|
if (iMatrixSetNumericFlag(ih, col, IMAT_IS_NUMERIC, set) && set)
|
||
|
|
{
|
||
|
|
/* no need to check for a valid quantity since it is done by the actual unit implementation */
|
||
|
|
ih->data->numeric_columns[col].quantity = (unsigned char)quantity;
|
||
|
|
ih->data->numeric_convert_func = (ImatNumericConvertFunc)IupGetCallback(ih, "NUMERICCONVERT_FUNC"); /* valid only during set of NUMERICQUANTITY */
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int iMatrixSetNumericFormatAttrib(Ihandle* ih, int col, const char* value)
|
||
|
|
{
|
||
|
|
return iMatrixSetNumericFlag(ih, col, IMAT_HAS_FORMAT, value!=NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int iMatrixSetNumericFormatPrecisionAttrib(Ihandle* ih, int col, const char* value)
|
||
|
|
{
|
||
|
|
int precision;
|
||
|
|
if (iupStrToInt(value, &precision))
|
||
|
|
{
|
||
|
|
if (col == IUP_INVALID_ID)
|
||
|
|
IupSetStrf(ih, "NUMERICFORMATDEF", "%%.%df", precision);
|
||
|
|
else
|
||
|
|
IupSetStrfId(ih, "NUMERICFORMAT", col, "%%.%df", precision);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (col == IUP_INVALID_ID)
|
||
|
|
IupSetAttribute(ih, "NUMERICFORMATDEF", NULL);
|
||
|
|
else
|
||
|
|
IupSetAttributeId(ih, "NUMERICFORMAT", col, NULL);
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static char* iMatrixGetNumericDecimalSymbolAttrib(Ihandle* ih)
|
||
|
|
{
|
||
|
|
char* value = iupAttribGet(ih, "NUMERICDECIMALSYMBOL");
|
||
|
|
if (!value)
|
||
|
|
value = IupGetGlobal("DEFAULTDECIMALSYMBOL");
|
||
|
|
return value;
|
||
|
|
}
|
||
|
|
|
||
|
|
static char* iMatrixGetNumericFormatPrecisionAttrib(Ihandle* ih, int col)
|
||
|
|
{
|
||
|
|
int precision;
|
||
|
|
char* value = iupAttribGetId(ih, "NUMERICFORMAT", col);
|
||
|
|
if (!value)
|
||
|
|
value = iupMatrixGetNumericFormatDef(ih);
|
||
|
|
|
||
|
|
if (!value)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
precision = iupStrGetFormatPrecision(value);
|
||
|
|
if (precision == -1)
|
||
|
|
return NULL;
|
||
|
|
|
||
|
|
return iupStrReturnInt(precision);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int iMatrixSetNumericFormatTitleAttrib(Ihandle* ih, int col, const char* value)
|
||
|
|
{
|
||
|
|
return iMatrixSetNumericFlag(ih, col, IMAT_HAS_FORMATTITLE, value!=NULL);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int iMatrixSetNumericUnitIndexAttrib(Ihandle* ih, int col, const char* value)
|
||
|
|
{
|
||
|
|
int unit;
|
||
|
|
if (iupStrToInt(value, &unit))
|
||
|
|
{
|
||
|
|
if (!iMatrixInitNumericColumns(ih, col))
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
/* no need to check for a valid unit since it is done by the actual unit implementation */
|
||
|
|
ih->data->numeric_columns[col].unit = (unsigned char)unit;
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int iMatrixSetNumericUnitShownIndexAttrib(Ihandle* ih, int col, const char* value)
|
||
|
|
{
|
||
|
|
int unit_shown;
|
||
|
|
if (iupStrToInt(value, &unit_shown))
|
||
|
|
{
|
||
|
|
if (!iMatrixInitNumericColumns(ih, col))
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
/* no need to check for a valid unit since it is done by the actual unit implementation */
|
||
|
|
ih->data->numeric_columns[col].unit_shown = (unsigned char)unit_shown;
|
||
|
|
return 1;
|
||
|
|
}
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static IFniii iMatrixQSort_sort_cb = NULL;
|
||
|
|
static Ihandle* iMatrixQSort_ih = NULL;
|
||
|
|
static int iMatrixQSort_col = 0;
|
||
|
|
|
||
|
|
static int iMatrixCompareCallbackFunc(const void* elem1, const void* elem2)
|
||
|
|
{
|
||
|
|
int lin1 = *((int*)elem1);
|
||
|
|
int lin2 = *((int*)elem2);
|
||
|
|
return iMatrixQSort_sort_cb(iMatrixQSort_ih, iMatrixQSort_col, lin1, lin2);
|
||
|
|
}
|
||
|
|
|
||
|
|
typedef struct _ImatSortNumber {
|
||
|
|
int lin;
|
||
|
|
double number;
|
||
|
|
} ImatSortNumber;
|
||
|
|
|
||
|
|
static int iMatrixCompareNumberFunc(const void* elem1, const void* elem2)
|
||
|
|
{
|
||
|
|
ImatSortNumber* num1 = (ImatSortNumber*)elem1;
|
||
|
|
ImatSortNumber* num2 = (ImatSortNumber*)elem2;
|
||
|
|
if (num1->number < num2->number)
|
||
|
|
return -1;
|
||
|
|
if (num1->number > num2->number)
|
||
|
|
return 1;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int iMatrixQSort_utf8 = 0;
|
||
|
|
static int iMatrixQSort_casesensitive = 1;
|
||
|
|
|
||
|
|
typedef struct _ImatSortText {
|
||
|
|
int lin;
|
||
|
|
char* text;
|
||
|
|
} ImatSortText;
|
||
|
|
|
||
|
|
static int iMatrixCompareTextFunc(const void* elem1, const void* elem2)
|
||
|
|
{
|
||
|
|
ImatSortText* txt1 = (ImatSortText*)elem1;
|
||
|
|
ImatSortText* txt2 = (ImatSortText*)elem2;
|
||
|
|
if ((!txt1->text || txt1->text[0]==0) && (!txt2->text || txt2->text[0]==0)) return 0;
|
||
|
|
if (!txt1->text || txt1->text[0]==0) return -1; /* txt1 < txt2 => -1 */
|
||
|
|
if (!txt2->text || txt2->text[0]==0) return 1;
|
||
|
|
return iupStrCompare(txt1->text, txt2->text, iMatrixQSort_casesensitive, iMatrixQSort_utf8);
|
||
|
|
}
|
||
|
|
|
||
|
|
static int iMatrixSetSortColumnAttrib(Ihandle* ih, int col, const char* value)
|
||
|
|
{
|
||
|
|
int lines_num = ih->data->lines.num;
|
||
|
|
int lin, lin1=1, lin2=lines_num-1; /* ALL */
|
||
|
|
int ascending;
|
||
|
|
int* sort_line_index;
|
||
|
|
IFniii sort_cb;
|
||
|
|
|
||
|
|
/* Notice that sort_line_index[0] is always 0 */
|
||
|
|
|
||
|
|
if (!ih->data->sort_line_index)
|
||
|
|
ih->data->sort_line_index = (int*)calloc(ih->data->lines.num_alloc, sizeof(int));
|
||
|
|
|
||
|
|
sort_line_index = ih->data->sort_line_index;
|
||
|
|
|
||
|
|
if (!ih->data->sort_has_index)
|
||
|
|
{
|
||
|
|
for (lin = 0; lin < lines_num; lin++)
|
||
|
|
sort_line_index[lin] = lin;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (iupStrEqualNoCase(value, "RESET"))
|
||
|
|
{
|
||
|
|
ih->data->sort_has_index = 0;
|
||
|
|
iupAttribSetId(ih, "SORTSIGN", ih->data->last_sort_col, NULL);
|
||
|
|
ih->data->last_sort_col = 0;
|
||
|
|
|
||
|
|
iupMatrixDraw(ih, 1);
|
||
|
|
iupAttribSet(ih, "SORTCOLUMNINTERVAL", NULL);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (iupStrEqualNoCase(value, "INVERT"))
|
||
|
|
{
|
||
|
|
int l1, l2;
|
||
|
|
|
||
|
|
if (!ih->data->sort_has_index)
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
IupGetIntInt(ih, "SORTCOLUMNINTERVAL", &lin1, &lin2);
|
||
|
|
|
||
|
|
for (l1=lin1,l2=lin2; l1<l2; ++l1,--l2)
|
||
|
|
{
|
||
|
|
int tmp = sort_line_index[l1];
|
||
|
|
sort_line_index[l1] = sort_line_index[l2];
|
||
|
|
sort_line_index[l2] = tmp;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (iupStrEqualNoCase(iupAttribGetId(ih, "SORTSIGN", ih->data->last_sort_col), "UP"))
|
||
|
|
iupAttribSetId(ih, "SORTSIGN", ih->data->last_sort_col, "DOWN");
|
||
|
|
else
|
||
|
|
iupAttribSetId(ih, "SORTSIGN", ih->data->last_sort_col, "UP");
|
||
|
|
|
||
|
|
iupMatrixDraw(ih, 1);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
if (!iupMATRIX_CHECK_COL(ih, col))
|
||
|
|
return 0;
|
||
|
|
|
||
|
|
if (!iupStrEqualNoCase(value, "ALL"))
|
||
|
|
iupStrToIntInt(value, &lin1, &lin2, '-');
|
||
|
|
|
||
|
|
iupAttribSetStrf(ih, "SORTCOLUMNINTERVAL", "%d,%d", lin1, lin2);
|
||
|
|
|
||
|
|
if (lin1 < 1) lin1 = 1;
|
||
|
|
if (lin2 < lin1) lin2 = lin1;
|
||
|
|
|
||
|
|
ascending = iupStrEqualNoCase(iupAttribGetStr(ih, "SORTCOLUMNORDER"), "ASCENDING");
|
||
|
|
|
||
|
|
sort_cb = (IFniii)IupGetCallback(ih, "SORTCOLUMNCOMPARE_CB");
|
||
|
|
if (sort_cb)
|
||
|
|
{
|
||
|
|
iMatrixQSort_sort_cb = sort_cb;
|
||
|
|
iMatrixQSort_ih = ih;
|
||
|
|
iMatrixQSort_col = col;
|
||
|
|
qsort(sort_line_index+lin1,lin2-lin1+1,sizeof(int),iMatrixCompareCallbackFunc);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (ih->data->numeric_columns && ih->data->numeric_columns[col].flags & IMAT_IS_NUMERIC)
|
||
|
|
{
|
||
|
|
ImatSortNumber* sort_line_number = (ImatSortNumber*)malloc((lin2-lin1+1)*sizeof(ImatSortNumber));
|
||
|
|
|
||
|
|
for (lin=lin1; lin<=lin2; lin++)
|
||
|
|
{
|
||
|
|
sort_line_number[lin-lin1].lin = sort_line_index[lin];
|
||
|
|
sort_line_number[lin-lin1].number = iupMatrixGetValueNumeric(ih, lin, col);
|
||
|
|
}
|
||
|
|
|
||
|
|
qsort(sort_line_number,lin2-lin1+1,sizeof(ImatSortNumber), iMatrixCompareNumberFunc);
|
||
|
|
|
||
|
|
for (lin=lin1; lin<=lin2; lin++)
|
||
|
|
{
|
||
|
|
if (ascending)
|
||
|
|
sort_line_index[lin] = sort_line_number[lin-lin1].lin;
|
||
|
|
else
|
||
|
|
sort_line_index[lin2 - (lin-lin1)] = sort_line_number[lin-lin1].lin;
|
||
|
|
}
|
||
|
|
|
||
|
|
free(sort_line_number);
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
ImatSortText* sort_line_text = (ImatSortText*)malloc((lin2-lin1+1)*sizeof(ImatSortText));
|
||
|
|
|
||
|
|
for (lin=lin1; lin<=lin2; lin++)
|
||
|
|
{
|
||
|
|
sort_line_text[lin-lin1].lin = sort_line_index[lin];
|
||
|
|
sort_line_text[lin-lin1].text = iupMatrixGetValueDisplay(ih, lin, col);
|
||
|
|
|
||
|
|
if (ih->data->callback_mode)
|
||
|
|
sort_line_text[lin-lin1].text = iupStrDup(sort_line_text[lin-lin1].text);
|
||
|
|
}
|
||
|
|
|
||
|
|
iMatrixQSort_utf8 = IupGetInt(NULL, "UTF8MODE");
|
||
|
|
iMatrixQSort_casesensitive = iupAttribGetInt(ih, "SORTCOLUMNCASESENSITIVE");
|
||
|
|
qsort(sort_line_text,lin2-lin1+1,sizeof(ImatSortText), iMatrixCompareTextFunc);
|
||
|
|
|
||
|
|
for (lin=lin1; lin<=lin2; lin++)
|
||
|
|
{
|
||
|
|
if (ascending)
|
||
|
|
sort_line_index[lin] = sort_line_text[lin-lin1].lin;
|
||
|
|
else
|
||
|
|
sort_line_index[lin2 - (lin-lin1)] = sort_line_text[lin-lin1].lin;
|
||
|
|
|
||
|
|
if (ih->data->callback_mode && sort_line_text[lin-lin1].text)
|
||
|
|
free(sort_line_text[lin-lin1].text);
|
||
|
|
}
|
||
|
|
|
||
|
|
free(sort_line_text);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
iupAttribSetId(ih, "SORTSIGN", ih->data->last_sort_col, NULL);
|
||
|
|
if (ascending)
|
||
|
|
iupAttribSetId(ih, "SORTSIGN", col, "DOWN");
|
||
|
|
else
|
||
|
|
iupAttribSetId(ih, "SORTSIGN", col, "UP");
|
||
|
|
|
||
|
|
ih->data->sort_has_index = 1;
|
||
|
|
ih->data->last_sort_col = col;
|
||
|
|
iupMatrixDraw(ih, 1);
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static char* iMatrixGetLastSortColumnAttrib(Ihandle* ih)
|
||
|
|
{
|
||
|
|
return iupStrReturnInt(ih->data->last_sort_col);
|
||
|
|
}
|
||
|
|
|
||
|
|
static char* iMatrixGetSortLineIndexAttrib(Ihandle* ih, int lin)
|
||
|
|
{
|
||
|
|
if (lin > 0 && lin < ih->data->lines.num && ih->data->sort_has_index)
|
||
|
|
return iupStrReturnInt(ih->data->sort_line_index[lin]);
|
||
|
|
else
|
||
|
|
return NULL;
|
||
|
|
}
|
||
|
|
|
||
|
|
static int iMatrixSetUndoRedoAttrib(Ihandle* ih, const char* value)
|
||
|
|
{
|
||
|
|
if (iupStrBoolean(value))
|
||
|
|
ih->data->undo_redo = 1;
|
||
|
|
else
|
||
|
|
ih->data->undo_redo = 0;
|
||
|
|
return 0;
|
||
|
|
}
|
||
|
|
|
||
|
|
static char* iMatrixGetUndoRedoAttrib(Ihandle* ih)
|
||
|
|
{
|
||
|
|
return iupStrReturnBoolean(ih->data->undo_redo);
|
||
|
|
}
|
||
|
|
|
||
|
|
void iupMatrixRegisterEx(Iclass* ic)
|
||
|
|
{
|
||
|
|
/* Undocumented features, will be exposed in IupMatrixEx */
|
||
|
|
|
||
|
|
/* IupMatrixEx Attributes - Numeric Columns */
|
||
|
|
iupClassRegisterAttributeId(ic, "NUMERICQUANTITYINDEX", NULL, iMatrixSetNumericQuantityIndexAttrib, IUPAF_NO_INHERIT);
|
||
|
|
iupClassRegisterAttributeId(ic, "NUMERICFORMAT", NULL, iMatrixSetNumericFormatAttrib, IUPAF_NO_INHERIT);
|
||
|
|
iupClassRegisterAttributeId(ic, "NUMERICFORMATPRECISION", iMatrixGetNumericFormatPrecisionAttrib, iMatrixSetNumericFormatPrecisionAttrib, IUPAF_NO_INHERIT);
|
||
|
|
iupClassRegisterAttributeId(ic, "NUMERICFORMATTITLE", NULL, iMatrixSetNumericFormatTitleAttrib, IUPAF_NO_INHERIT);
|
||
|
|
iupClassRegisterAttributeId(ic, "NUMERICUNITINDEX", NULL, iMatrixSetNumericUnitIndexAttrib, IUPAF_NO_INHERIT);
|
||
|
|
iupClassRegisterAttributeId(ic, "NUMERICUNITSHOWNINDEX", NULL, iMatrixSetNumericUnitShownIndexAttrib, IUPAF_NO_INHERIT);
|
||
|
|
iupClassRegisterAttribute(ic, "NUMERICFORMATDEF", NULL, NULL, NULL, NULL, IUPAF_NOT_MAPPED | IUPAF_NO_INHERIT);
|
||
|
|
iupClassRegisterAttribute(ic, "NUMERICDECIMALSYMBOL", iMatrixGetNumericDecimalSymbolAttrib, NULL, NULL, NULL, IUPAF_NOT_MAPPED | IUPAF_NO_INHERIT);
|
||
|
|
|
||
|
|
iupClassRegisterCallback(ic, "NUMERICGETVALUE_CB", "ii=d");
|
||
|
|
iupClassRegisterCallback(ic, "NUMERICSETVALUE_CB", "iid");
|
||
|
|
|
||
|
|
/* IupMatrixEx Attributes - Sort Columns */
|
||
|
|
iupClassRegisterAttribute(ic, "LASTSORTCOLUMN", iMatrixGetLastSortColumnAttrib, NULL, NULL, NULL, IUPAF_READONLY|IUPAF_NOT_MAPPED | IUPAF_NO_INHERIT);
|
||
|
|
iupClassRegisterAttributeId(ic, "SORTCOLUMN", NULL, iMatrixSetSortColumnAttrib, IUPAF_WRITEONLY|IUPAF_NO_INHERIT);
|
||
|
|
iupClassRegisterAttribute(ic, "SORTCOLUMNORDER", NULL, NULL, IUPAF_SAMEASSYSTEM, "ASCENDING", IUPAF_NOT_MAPPED | IUPAF_NO_INHERIT);
|
||
|
|
iupClassRegisterAttribute(ic, "SORTCOLUMNCASESENSITIVE", NULL, NULL, IUPAF_SAMEASSYSTEM, "YES", IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
|
||
|
|
iupClassRegisterAttribute(ic, "SORTCOLUMNINTERVAL", NULL, NULL, NULL, NULL, IUPAF_READONLY|IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
|
||
|
|
iupClassRegisterAttributeId(ic, "SORTLINEINDEX", iMatrixGetSortLineIndexAttrib, NULL, IUPAF_READONLY | IUPAF_NO_INHERIT);
|
||
|
|
|
||
|
|
iupClassRegisterCallback(ic, "SORTCOLUMNCOMPARE_CB", "iii");
|
||
|
|
|
||
|
|
/* IupMatrixEx Attributes - Undo/Redo */
|
||
|
|
iupClassRegisterAttribute(ic, "UNDOREDO", iMatrixGetUndoRedoAttrib, iMatrixSetUndoRedoAttrib, NULL, NULL, IUPAF_NOT_MAPPED|IUPAF_NO_INHERIT);
|
||
|
|
}
|
||
|
|
|