int KgColors::addColorSelector(QString cfgName, QString name, QColor dflt, QString dfltName,
ADDITIONAL_COLOR *addColor, int addColNum)
{
int index = itemList.count() - offset;
labelList.append(addLabel(colorsGrid, index, 0, name, colorsGrp));
KonfiguratorColorChooser *chooser = createColorChooser("Colors", cfgName, dflt, colorsGrp, false, addColor, addColNum);
chooser->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Fixed);
if (!dfltName.isEmpty())
chooser->setDefaultText(dfltName);
colorsGrid->addWidget(chooser, index, 1);
connect(chooser, SIGNAL(colorChanged()), this, SLOT(generatePreview()));
if (!offset)
connect(chooser, SIGNAL(colorChanged()), this, SLOT(slotActiveChanged()));
itemList.append(chooser);
itemNames.append(cfgName);
return index;
}
/*--------------------------------------------------------------------------*/
int sci_uigetcolor(char *fname, void* pvApiCtx)
{
SciErr sciErr;
//WARNING ALL NEW DECALRATIONS ARE HERE IF YOUR HAVE MANY FUNCTIONS
//IN THE FILE YOU HAVE PROBABLY TO MOVE DECLARATIONS IN GOOD FUNCTIONS
int* piAddrredAdr = NULL;
double* redAdr = NULL;
int* piAddrtitleAdr = NULL;
char* titleAdr = NULL;
int* piAddrgreenAdr = NULL;
double* greenAdr = NULL;
int* piAddrblueAdr = NULL;
double* blueAdr = NULL;
int colorChooserID = 0;
int firstColorIndex = 0;
int nbRow = 0, nbCol = 0;
double *selectedRGB = NULL;
CheckInputArgument(pvApiCtx, 0, 4);
if ((nbOutputArgument(pvApiCtx) != 1) && (nbOutputArgument(pvApiCtx) != 3)) /* Bad use */
{
Scierror(999, _("%s: Wrong number of output arguments: %d or %d expected.\n"), fname, 1, 3);
return FALSE;
}
/* Rhs==1: title or [R, G, B] given */
if (nbInputArgument(pvApiCtx) == 1)
{
if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrredAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 1.
sciErr = getMatrixOfDouble(pvApiCtx, piAddrredAdr, &nbRow, &nbCol, &redAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 1);
return 1;
}
if ((nbRow != 1) || (nbCol != 3))
{
Scierror(999, _("%s: Wrong size for input argument #%d: A 1 x %d real row vector expected.\n"), fname, 1, 3);
return FALSE;
}
}
else if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrtitleAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 1.
if (getAllocatedSingleString(pvApiCtx, piAddrtitleAdr, &titleAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
return 1;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A real or a string expected.\n"), fname, 1);
return FALSE;
}
}
/* Title and [R, G, B] given */
if (nbInputArgument(pvApiCtx) == 2)
{
/* Title */
if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrtitleAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 1.
if (getAllocatedSingleString(pvApiCtx, piAddrtitleAdr, &titleAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
return 1;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
return FALSE;
}
/* [R, G, B] */
if ((checkInputArgumentType(pvApiCtx, 2, sci_matrix)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrredAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 2.
sciErr = getMatrixOfDouble(pvApiCtx, piAddrredAdr, &nbRow, &nbCol, &redAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, 2);
return 1;
}
if (nbRow*nbCol != 3)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A 1 x %d real row vector expected.\n"), fname, 2, 3);
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A 1 x %d real row vector expected.\n"), fname, 2, 3);
return FALSE;
}
}
/* No title given but colors given with separate values */
if (nbInputArgument(pvApiCtx) == 3)
{
firstColorIndex = 1;
}
/* Title and colors given with separate values */
if (nbInputArgument(pvApiCtx) == 4)
{
firstColorIndex = 2;
/* Title */
if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrtitleAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position 1.
if (getAllocatedSingleString(pvApiCtx, piAddrtitleAdr, &titleAdr))
{
Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
return 1;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A real or a string expected.\n"), fname, 1);
return FALSE;
}
}
/* R, G, B given */
if (nbInputArgument(pvApiCtx) >= 3)
{
/* Default red value */
if ((checkInputArgumentType(pvApiCtx, firstColorIndex, sci_matrix)))
{
sciErr = getVarAddressFromPosition(pvApiCtx, firstColorIndex, &piAddrredAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position firstColorIndex.
sciErr = getMatrixOfDouble(pvApiCtx, piAddrredAdr, &nbRow, &nbCol, &redAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, firstColorIndex);
return 1;
}
if (nbRow*nbCol != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, firstColorIndex);
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, firstColorIndex);
return FALSE;
}
/* Default green value */
if (checkInputArgumentType(pvApiCtx, firstColorIndex + 1, sci_matrix))
{
sciErr = getVarAddressFromPosition(pvApiCtx, firstColorIndex + 1, &piAddrgreenAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position firstColorIndex + 1.
sciErr = getMatrixOfDouble(pvApiCtx, piAddrgreenAdr, &nbRow, &nbCol, &greenAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, firstColorIndex + 1);
return 1;
}
if (nbRow*nbCol != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, firstColorIndex + 1);
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, firstColorIndex + 1);
return FALSE;
}
/* Default blue value */
if (checkInputArgumentType(pvApiCtx, firstColorIndex + 2, sci_matrix))
{
sciErr = getVarAddressFromPosition(pvApiCtx, firstColorIndex + 2, &piAddrblueAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
return 1;
}
// Retrieve a matrix of double at position firstColorIndex + 2.
sciErr = getMatrixOfDouble(pvApiCtx, piAddrblueAdr, &nbRow, &nbCol, &blueAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(202, _("%s: Wrong type for argument #%d: A real expected.\n"), fname, firstColorIndex + 2);
return 1;
}
if (nbRow*nbCol != 1)
{
Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, firstColorIndex + 2);
return FALSE;
}
}
else
{
Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, firstColorIndex + 2);
return FALSE;
}
}
/* Create the Java Object */
colorChooserID = createColorChooser();
/* Title */
if (titleAdr != 0)
{
setColorChooserTitle(colorChooserID, titleAdr);
freeAllocatedSingleString(titleAdr);
}
/* Default red value */
if (redAdr != 0)
{
if (greenAdr != 0 ) /* All values given in first input argument */
{
setColorChooserDefaultRGBSeparateValues(colorChooserID, (int)redAdr[0], (int)greenAdr[0], (int)blueAdr[0]);
}
else
{
setColorChooserDefaultRGB(colorChooserID, redAdr);
}
}
/* Display it and wait for a user input */
colorChooserDisplayAndWait(colorChooserID);
/* Return the selected color */
/* Read the user answer */
selectedRGB = getColorChooserSelectedRGB(colorChooserID);
if (selectedRGB[0] >= 0) /* The user selected a color */
{
nbRow = 1;
if (nbOutputArgument(pvApiCtx) == 1)
{
nbCol = 3;
sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, selectedRGB);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
}
if (nbOutputArgument(pvApiCtx) >= 2)
{
nbCol = 1;
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &redAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
redAdr[0] = selectedRGB[0];
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &greenAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
greenAdr[0] = selectedRGB[1];
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &blueAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
blueAdr[0] = selectedRGB[2];
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
}
}
else /* The user canceled */
{
nbRow = 0;
nbCol = 0;
if (nbOutputArgument(pvApiCtx) == 1)
{
/* Return [] */
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &redAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
}
if (nbOutputArgument(pvApiCtx) >= 2)
{
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &redAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &greenAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &blueAdr);
if (sciErr.iErr)
{
printError(&sciErr, 0);
Scierror(999, _("%s: Memory allocation error.\n"), fname);
return 1;
}
AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
}
}
ReturnArguments(pvApiCtx);
return TRUE;
}
void Configurator::loadItem( QListWidgetItem* item )
{
if( 0 == item )
return;
// searching corresponding section
QString sectionName = item->listWidget()->objectName();
QDomNode configurator = _domDocument.documentElement();
QDomNode section = configurator.firstChild();
while( false == section.isNull() )
{
QDomNamedNodeMap sectionAttributes = section.attributes();
if( sectionName == sectionAttributes.namedItem(c_attributeName).nodeValue() )
break;
section = section.nextSibling();
}
// having section, searching for the sectionItem
QString sectionItemName = item->data( Qt::UserRole ).toString();
QDomNode sectionItem = section.firstChild();
while( false == sectionItem.isNull() )
{
QDomNamedNodeMap sectionItemAttributes = sectionItem.attributes();
if( QDomNode::CommentNode != section.nodeType() )
if( sectionItemName == sectionItemAttributes.namedItem(c_attributeName).nodeValue() )
break;
sectionItem = sectionItem.nextSibling();
}
// destroying all previous controls from the frame
QObjectList children = _configOptions->children();
foreach( QObject* child, children )
delete child;
// vertical-layout all the frame's objects
QVBoxLayout* verticalLayout = new QVBoxLayout( _configOptions );
// at this step we have everything to start load data from DOM
QDomNode control = sectionItem.firstChild();
while( false == control.isNull() )
{
// note: not all the nodes met will have these attributes, speciffic nodes will have some of these
QDomNamedNodeMap controlAttributes = control.attributes();
QString controlName = controlAttributes.namedItem( c_attributeName ).nodeValue();
QString controlText = controlAttributes.namedItem( c_attributeText ).nodeValue();
QString controlType = controlAttributes.namedItem( c_attributeType ).nodeValue();
QString controlValue = controlAttributes.namedItem( c_attributeValue ).nodeValue();
switch( getControlTypeByName(controlType) )
{
case eFontChooser : verticalLayout->addWidget( createFontChooser(controlName,controlText,controlValue) ); break;
case eColorChooser : verticalLayout->addWidget( createColorChooser(controlName,controlText,controlValue) ); break;
case ePathChooser : verticalLayout->addWidget( createPathChooser(controlName,controlText,controlValue) ); break;
case eRadioBoxes : verticalLayout->addWidget( createRadioBoxes(controlName,controlText,controlValue,control.firstChild()) ); break;
case eCheckBoxes : verticalLayout->addWidget( createCheckBoxes(controlName,controlText,controlValue,control.firstChild()) ); break;
case eTextViewer : verticalLayout->addWidget( createTextViewer(controlName,control) ); break;
case eLineInput : verticalLayout->addWidget( createLineInput(controlName,controlText,controlValue) ); break;
case ePlugins : verticalLayout->addWidget( createPlugins(controlName,controlValue) ); break;
default:
break;
}
control = control.nextSibling();
}
}
/* --------------------------------------------------------------------------
* ObjectPanel
*
* Constructor for ObjectPanel
* -------------------------------------------------------------------------- */
ObjectPanel::ObjectPanel( Renderer *renderer, QWidget *parent )
: QWidget( parent )
{
m_pRenderer = renderer;
createColorChooser();
}
