void DIALOG_CHOOSE_COMPONENT::OnHandlePreviewRepaint( wxPaintEvent& aRepaintEvent )
{
int unit = 0;
LIB_ALIAS* selection = m_search_container->GetSelectedAlias( &unit );
LIB_PART* part = selection ? selection->GetPart() : NULL;
// Don't draw anything (not even the background) if we don't have
// a part to show
if( !part )
return;
if( selection->IsRoot() )
{
// just show the part directly
renderPreview( part, unit );
}
else
{
// switch out the name temporarily for the alias name
wxString tmp( part->GetName() );
part->SetName( selection->GetName() );
renderPreview( part, unit );
part->SetName( tmp );
}
}
ThemePreviewer::ThemePreviewer(const Theme& theme, int width, int height) :
width_{width},
height_{height}
{
renderPreview(theme);
}
ThemePreviewer::ThemePreviewer(const Theme& theme, int width, int height)
{
this->width = width;
this->height = height;
renderPreview(theme);
}
void dialogThresholdChanged(GtkWidget *widget, PlugInVals *vals) {
#ifdef DEBUG
g_warning("old threshold = %d",vals->threshold);
#endif
vals->threshold = gtk_adjustment_get_value(GTK_ADJUSTMENT(widget));
#ifdef DEBUG
g_warning("new threshold = %d",vals->threshold);
#endif
renderPreview(vals);
}
void Dock::changeDirectory( const QString& dir )
{
slideIndex_[currentDir_.path()] = flow_->centerIndex();
flow_->clear();
currentDir_ = dir;
currentDir_.setFilter( QDir::Files | QDir::Dirs | QDir::NoDotAndDotDot );
QStringList filters = ContentFactory::getSupportedFilesFilter();
filters.append( "*.dcx" );
currentDir_.setNameFilters( filters );
const QFileInfoList& fileList = currentDir_.entryInfoList();
currentDir_.setFilter( QDir::Dirs | QDir::NoDotAndDotDot );
currentDir_.setNameFilters( QStringList( ));
const QFileInfoList& dirList = currentDir_.entryInfoList();
QDir rootDir = dir;
const bool hasRootDir = rootDir.cdUp();
if( hasRootDir)
{
QString upFolder = rootDir.path();
QImage img = createSlideImage_( flow_->slideSize(), upFolder, true,
Qt::darkGray, Qt::lightGray );
flow_->addSlide( img, "UP: " + upFolder );
}
for( int i = 0; i < fileList.size(); ++i )
{
QFileInfo fileInfo = fileList.at( i );
const QString& fileName =
currentDir_.absoluteFilePath( fileInfo.fileName( ));
emit renderPreview( fileName, flow_->slideCount( ));
QImage img = createSlideImage_( flow_->slideSize(), fileName, false,
Qt::black, Qt::white );
flow_->addSlide( img, fileInfo.fileName( ));
}
for( int i = 0; i < dirList.size(); ++i )
{
QFileInfo fileInfo = dirList.at( i );
const QString& fileName =
currentDir_.absoluteFilePath( fileInfo.fileName( ));
if( !fileName.endsWith( ".pyramid" ))
{
QImage img = createSlideImage_( flow_->slideSize(), fileName, true,
Qt::black, Qt::white );
flow_->addSlide( img, fileInfo.fileName( ));
}
}
flow_->setCenterIndex( slideIndex_[currentDir_.path()] );
}
MainWindow::MainWindow(QWidget *parent, Qt::WFlags flags)
: QMainWindow(parent, flags)
{
ui.setupUi(this);
sh = new sdSyntaxHighlighter(ui.teCode->document());
timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), this, SLOT(renderPreview()));
autoPreview = true;
}
void DockPixelStreamer::loadNextThumbnailInList()
{
while(!slideImagesToLoad_.empty())
{
int i = slideImagesToLoad_.front();
slideImagesToLoad_.pop_front();
if (!slideImagesLoaded_[i].first)
{
slideImagesLoaded_[i].first = true;
emit renderPreview( slideImagesLoaded_[i].second, i );
return;
}
}
}
void PreviewContentWidget::render(QPainter &p)
{
p.save();
p.setPen(Qt::NoPen);
p.setBrush(Qt::NoBrush);
applyClippingPath(p);
renderPreview(p);
p.restore();
renderTextBubble(p);
}
void ThemeDialog::imageChanged()
{
if (!m_background_image->image().isEmpty()) {
QSize image = QImageReader(m_background_image->image()).size();
QSize desktop = QApplication::desktop()->size();
if ((image.width() * image.height() * 4) <= (desktop.width() * desktop.height())) {
m_background_type->setCurrentIndex(1);
} else if (m_background_type->currentIndex() < 2) {
m_background_type->setCurrentIndex(5);
}
} else {
m_background_type->setCurrentIndex(0);
}
renderPreview();
}
void dialogSourceChangedCallback(GimpIntComboBox *widget, PlugInVals *vals) {
gint value;
#ifdef DEBUG
g_warning("dialogSourceChangedCallback");
#endif
if (gimp_int_combo_box_get_active(widget,&value)) {
vals->image_drawable_id = value;
vals->output_drawable_id = value;
update_image(vals);
renderPreview(vals);
}
}
void buildPreviewSourceImage (PlugInVals *vals) {
#ifdef DEBUG
g_warning("buildPreviewSourceImage");
#endif
interface_vals.previewImage =
g_new (guchar, interface_vals.previewWidth *
interface_vals.previewHeight * 4);
util_fillReducedBuffer (interface_vals.previewImage,
interface_vals.previewWidth,
interface_vals.previewHeight,
4, TRUE,
interface_vals.image_drawable,
interface_vals.selectionX0, interface_vals.selectionY0,
interface_vals.selectionWidth, interface_vals.selectionHeight);
interface_vals.previewMask =
g_new (guchar, interface_vals.previewWidth*interface_vals.previewHeight * 1);
if (interface_vals.mask_drawable != NULL) {
util_fillReducedBuffer (interface_vals.previewMask,
interface_vals.previewWidth,
interface_vals.previewHeight,
1, FALSE,
interface_vals.mask_drawable,
interface_vals.selectionX0, interface_vals.selectionY0,
interface_vals.selectionWidth, interface_vals.selectionHeight);
}
interface_vals.previewStopPath =
g_new (guchar, interface_vals.previewWidth*interface_vals.previewHeight * 1);
fill_stop_path_buffer_from_path(vals->stop_path_id);
// else {
// gint size = interface_vals.previewHeight*interface_vals.previewWidth;
// gint i;
// for (i = 0; i < size; ++i) {
// interface_vals.previewMask[i] = 255;
// }
// //memset(interface_vals.previewMask,0,interface_vals.previewWidth*interface_vals.previewHeight);
// }
renderPreview(vals);
}
void dialogStopPathChangedCallback(GtkWidget *widget, PlugInVals *vals) {
gint value;
#ifdef DEBUG
g_warning("dialogStopPathChangedCallback");
#endif
if (GTK_WIDGET_SENSITIVE(widget)) {
//if (gtk_widget_get_sensitive(widget)) {
if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(widget),&value)) {
vals->stop_path_id = value;
} else {
vals->stop_path_id = -1;
}
} else {
vals->stop_path_id = -1;
}
update_stop_path(vals);
renderPreview(vals);
}
void dialogMaskChangedCallback(GtkWidget *widget, PlugInVals *vals) {
gint value;
#ifdef DEBUG
g_warning("dialogMaskChangedCallback");
#endif
if (GTK_WIDGET_SENSITIVE(widget)) {
//if (gtk_widget_get_sensitive(widget)) {
if (gimp_int_combo_box_get_active(GIMP_INT_COMBO_BOX(widget),&value)) {
vals->mask_drawable_id = value;
} else {
vals->mask_drawable_id = -1;
}
} else {
vals->mask_drawable_id = gimp_image_get_selection(gimp_drawable_get_image(vals->image_drawable_id));
}
update_mask(vals);
renderPreview(vals);
}
void dovo_mainFrame::OnInstancesSelected( wxListEvent& event )
{
long item = m_instances->GetNextItem(-1, wxLIST_NEXT_ALL, wxLIST_STATE_SELECTED);
if (item == -1)
return;
#ifdef _WIN32
// on Windows, boost::filesystem::path is a wstring
boost::filesystem::path filename = m_instances->GetItemText(item, 1);
#else
boost::filesystem::path filename = m_instances->GetItemText(item, 1).ToUTF8().data();
#endif
wxSize s = m_preview->GetClientSize();
wxBusyCursor wait;
dcm2img(filename, s.GetWidth(), s.GetHeight(), image);
wxClientDC dc(m_preview);
renderPreview(dc);
}
void dovo_mainFrame::OnPaintPreview( wxPaintEvent& event )
{
wxPaintDC dc(m_preview);
renderPreview(dc);
}
void LaserManager::draw() {
if(testPattern==1) {
//addLaserRectEased(pmin, pmax, white);
//addLaserLineEased(maskRectangle.getTopLeft(), maskRectangle.getBottomRight(), white);
//addLaserLineEased(maskRectangle.getTopRight(), maskRectangle.getBottomLeft(), white);
ofPoint v = maskRectangle.getBottomRight() - maskRectangle.getTopLeft();
for(float x =0 ; x<=1; x+=0.2) {
for(float y = 0; y<=1; y+=0.2) {
//addLaserDot(ofPoint(maskRectangle.x + (v.x*x), maskRectangle.y + (v.y*y)), white, 1);
if(x ==0) {
addLaserLineEased(ofPoint(maskRectangle.getLeft(), maskRectangle.getTop()+v.y*y),ofPoint(maskRectangle.getRight(), maskRectangle.getTop()+v.y*y), ofColor::white );
}
}
addLaserLineEased(ofPoint(maskRectangle.x + v.x*x, maskRectangle.getTop()),ofPoint(maskRectangle.x + v.x*x, maskRectangle.getBottom()), ofColor::red );
}
addLaserCircle(maskRectangle.getCenter(), white, 10);
addLaserCircle(maskRectangle.getCenter(), ofFloatColor(1,0,0), 50);
/*
addLaserDot(pmin, white, 1);
addLaserDot(ofPoint(pmax.x, pmin.y), white, 1);
addLaserDot(pmax, white, 1);
addLaserDot(ofPoint(pmin.x, pmax.y), white, 1);
*/
} else if((testPattern>=2) && (testPattern<=5)) {
ofColor c;
ofRectangle rect(appWidth*0.3, appHeight*0.3, appWidth*0.3, appHeight*0.3);
for(int row = 0; row<5; row ++ ) {
float y = rect.getTop() + (rect.getHeight()*row/4);
ofPoint left = ofPoint(rect.getLeft(), y);
ofPoint right = ofPoint(rect.getRight(), y);
moveLaser(left);
for(int i = 0; i<shapePreBlank; i++) {
addIldaPoint(left, black, 1);
}
if(testPattern == 2) c.set(255,0,0);
else if(testPattern == 3) c.set(0,255,0);
else if(testPattern == 4) c.set(0,0,255);
else if(testPattern == 5) c.set(255,255,255);
switch (row) {
case 0 :
c.r *= red100;
c.g *= green100;
c.b *= blue100;
break;
case 1 :
c.r *= red75;
c.g *= green75;
c.b *= blue75;
break;
case 2 :
c.r *= red50;
c.g *= green50;
c.b *= blue50;
break;
case 3 :
c.r *= red25;
c.g *= green25;
c.b *= blue25;
break;
case 4 :
c.r *= red0;
c.g *= green0;
c.b *= blue0;
break;
}
for(int i = 0; i<shapePreBlank; i++) {
addIldaPoint(left, c, 1, true);
}
float speed = 20 * ( 1- (row*0.25));
if(speed<5) speed = 5;
for(float x = rect.getLeft(); x<=rect.getRight(); x+=speed) {
addIldaPoint(ofPoint(x,y),c,1, false);
}
for(int i = 0; i<shapePostBlank; i++) {
addIldaPoint(right, c, 1, false);
}
for(int i = 0; i<shapePostBlank; i++) {
addIldaPoint(right, black, 1);
}
// 0 = normalspeed;
// 1 = normalspeed * 0.75
// 2 = normalspeed * 0.5
// 3 = normalspeed * 0.25
// 0 = 1;
// 1 = 0.75
// 2 = 0.5;
// 3 = 0.25
//float brightness = 1 - (row*0.25);
//if(brightness < 0) brightness =
}
}
// if we're using the clever laser render delay
// system
if(delay > 0) {
float currentTime = ofGetElapsedTimef();
//cout << "------------pushing history " << shapes.size() << endl;
// add the current shapes and time to the
// histories
shapesHistory.push_back(shapes);
frameTimes.push_back(currentTime);
//start from the oldest shapes and while the next set of
// shapes are due, delete the oldest
int numDeleted = 0;
while((frameTimes.size()>1) && (frameTimes[1]+delay < currentTime)) {
shapes = shapesHistory.front();
// DELETE ALL SHAPES IN HISTORY.FRONT
for(int i = 0; i<shapes.size(); i++) {
delete shapes[i];
}
shapesHistory.pop_front();
frameTimes.pop_front();
//resetIldaPoints();
//cout << "deleting oldest " << endl;
numDeleted++;
}
shapes = shapesHistory.front();
if(numDeleted == 0 ) {
//cout << "NONE DELETED" << endl;
}
//cout << "using shapes " << shapesHistory.size() << endl;
//cout << "shapes size " << shapes.size() << endl;
//cout << "pathMesh vertices " << pathMesh.getVertices().size() << endl;
/*
if((frameTimes.size()>0) && (frameTimes[0]+delay <= ofGetElapsedTimef())) {
// if we have too many, we have to delete some!
while((frameTimes.size()>1) && (frameTimes[1]+delay <= ofGetElapsedTimef())) {
shapes = shapesHistory.front();
shapesHistory.pop_front();
frameTimes.pop_front();
//resetIldaPoints();
}
shapes = shapesHistory.front();
shapesHistory.pop_front();
frameTimes.pop_front();
} else {
// we're not ready to show the next shapes yet so show
// the oldest ones.
// need to do this otherwise the shapes get deleted
// more than once
clearShapes = true;
shapes = shapesHistory.front();
//shapes.clear();
}*/
} else if(shapesHistory.size()!=0) {
// TODO need to also delete shapes otherwise memory leak
for(int i = 0; i<shapesHistory.size(); i++) {
for(int j = 0; j<shapesHistory[i].size(); j++) {
delete shapesHistory[i][j];
}
}
shapesHistory.clear();
frameTimes.clear();
}
//ofDrawBitmapString(ofToString(shapesHistory.size()), 200,200);
drawShapes();
if(renderLaserPreview) {
renderPreview();
//ofRect(0,0,100,100);
}
while(ildaPoints.size()<minPoints) {
addIldaPoint(currentPosition, black);
}
vector<ofxIlda::Point> adjustedPoints;
// SORT OUT COLOUR CHANGE DELAY.
for(int i = 0; i<ildaPoints.size(); i++) {
ofxIlda::Point p = ildaPoints.at(i);
int colourPointIndex = i+colourChangeDelay;
while(colourPointIndex<0) colourPointIndex+=ildaPoints.size();
ofxIlda::Point colourPoint = ildaPoints.at(colourPointIndex%ildaPoints.size());
p.r = round(colourPoint.r);
p.g = round(colourPoint.g);
p.b = round(colourPoint.b);
adjustedPoints.push_back(p);
}
if(!useTCP) {
etherdream.setPoints(adjustedPoints);
etherdream.setPPS(pps);
} else {
sendPointsTCP(adjustedPoints);
}
ofPushStyle();
if(maskRectangleBrightness>0) {
ofNoFill();
ofSetColor(maskRectangleBrightness * 255);
ofRect(maskRectangle);
maskRectangleBrightness-=0.01;
}
ofPopStyle();
// TODO if we're not using the delay system, let's
// delete all the shapes
if(delay==0) {
for(int i = 0; i<shapes.size(); i++) {
delete shapes[i];
}
}
// clear the shapes vector no matter what
shapes.clear();
// cout << "pathMesh vertices " << pathMesh.getVertices().size() << " " << ildaPoints.size() << endl;
}
void ThemeDialog::positionChanged(int index)
{
m_foreground_width->setEnabled(index != 3);
renderPreview();
}
ThemeDialog::ThemeDialog(Theme& theme, QWidget* parent)
: QDialog(parent, Qt::WindowTitleHint | Qt::WindowSystemMenuHint | Qt::WindowCloseButtonHint),
m_theme(theme)
{
setWindowTitle(tr("Edit Theme"));
setWindowModality(Qt::WindowModal);
// Create name edit
m_name = new QLineEdit(this);
m_name->setText(m_theme.name());
connect(m_name, SIGNAL(textChanged(QString)), this, SLOT(checkNameAvailable()));
QHBoxLayout* name_layout = new QHBoxLayout;
name_layout->setMargin(0);
name_layout->addWidget(new QLabel(tr("Name:"), this));
name_layout->addWidget(m_name);
// Create scrollarea
QWidget* contents = new QWidget(this);
QScrollArea* scroll = new QScrollArea(this);
scroll->setWidget(contents);
scroll->setWidgetResizable(true);
// Create text group
QGroupBox* text_group = new QGroupBox(tr("Text"), contents);
m_text_color = new ColorButton(text_group);
m_text_color->setColor(m_theme.textColor());
connect(m_text_color, SIGNAL(changed(QColor)), this, SLOT(renderPreview()));
m_font_names = new FontComboBox(text_group);
m_font_names->setEditable(false);
m_font_names->setCurrentFont(m_theme.textFont());
connect(m_font_names, SIGNAL(activated(int)), this, SLOT(fontChanged()));
connect(m_font_names, SIGNAL(activated(int)), this, SLOT(renderPreview()));
m_font_sizes = new QComboBox(text_group);
m_font_sizes->setEditable(true);
m_font_sizes->setMinimumContentsLength(3);
connect(m_font_sizes, SIGNAL(editTextChanged(QString)), this, SLOT(renderPreview()));
fontChanged();
m_misspelled_color = new ColorButton(text_group);
m_misspelled_color->setColor(m_theme.misspelledColor());
connect(m_misspelled_color, SIGNAL(changed(QColor)), this, SLOT(renderPreview()));
QHBoxLayout* font_layout = new QHBoxLayout;
font_layout->addWidget(m_font_names);
font_layout->addWidget(m_font_sizes);
QFormLayout* text_layout = new QFormLayout(text_group);
text_layout->setFieldGrowthPolicy(QFormLayout::FieldsStayAtSizeHint);
text_layout->addRow(tr("Color:"), m_text_color);
text_layout->addRow(tr("Font:"), font_layout);
text_layout->addRow(tr("Misspelled:"), m_misspelled_color);
// Create background group
QGroupBox* background_group = new QGroupBox(tr("Window Background"), contents);
m_background_color = new ColorButton(background_group);
m_background_color->setColor(m_theme.backgroundColor());
connect(m_background_color, SIGNAL(changed(QColor)), this, SLOT(renderPreview()));
m_background_image = new ImageButton(background_group);
m_background_image->setImage(m_theme.backgroundImage(), m_theme.backgroundPath());
connect(m_background_image, SIGNAL(changed(QString)), this, SLOT(imageChanged()));
m_clear_image = new QPushButton(tr("Remove"), background_group);
connect(m_clear_image, SIGNAL(clicked()), m_background_image, SLOT(unsetImage()));
m_background_type = new QComboBox(background_group);
m_background_type->addItems(QStringList() << tr("No Image") << tr("Tiled") << tr("Centered") << tr("Stretched") << tr("Scaled") << tr("Zoomed"));
m_background_type->setCurrentIndex(m_theme.backgroundType());
connect(m_background_type, SIGNAL(activated(int)), this, SLOT(renderPreview()));
QVBoxLayout* image_layout = new QVBoxLayout;
image_layout->setSpacing(0);
image_layout->setMargin(0);
image_layout->addWidget(m_background_image);
image_layout->addWidget(m_clear_image);
QFormLayout* background_layout = new QFormLayout(background_group);
background_layout->setFieldGrowthPolicy(QFormLayout::FieldsStayAtSizeHint);
background_layout->addRow(tr("Color:"), m_background_color);
background_layout->addRow(tr("Image:"), image_layout);
background_layout->addRow(tr("Type:"), m_background_type);
// Create foreground group
QGroupBox* foreground_group = new QGroupBox(tr("Text Background"), contents);
m_foreground_color = new ColorButton(foreground_group);
m_foreground_color->setColor(m_theme.foregroundColor());
connect(m_foreground_color, SIGNAL(changed(QColor)), this, SLOT(renderPreview()));
m_foreground_opacity = new QSpinBox(foreground_group);
m_foreground_opacity->setCorrectionMode(QSpinBox::CorrectToNearestValue);
m_foreground_opacity->setSuffix(QLocale().percent());
m_foreground_opacity->setRange(theme.foregroundOpacity().minimumValue(), theme.foregroundOpacity().maximumValue());
m_foreground_opacity->setValue(m_theme.foregroundOpacity());
connect(m_foreground_opacity, SIGNAL(valueChanged(int)), this, SLOT(renderPreview()));
m_foreground_position = new QComboBox(foreground_group);
m_foreground_position->addItems(QStringList() << tr("Left") << tr("Centered") << tr("Right") << tr("Stretched"));
m_foreground_position->setCurrentIndex(m_theme.foregroundPosition());
connect(m_foreground_position, SIGNAL(currentIndexChanged(int)), this, SLOT(positionChanged(int)));
m_foreground_width = new QSpinBox(foreground_group);
m_foreground_width->setCorrectionMode(QSpinBox::CorrectToNearestValue);
m_foreground_width->setSuffix(tr(" pixels"));
m_foreground_width->setRange(theme.foregroundWidth().minimumValue(), theme.foregroundWidth().maximumValue());
m_foreground_width->setValue(m_theme.foregroundWidth());
m_foreground_width->setEnabled(m_theme.foregroundPosition() != 3);
connect(m_foreground_width, SIGNAL(valueChanged(int)), this, SLOT(renderPreview()));
QFormLayout* foreground_layout = new QFormLayout(foreground_group);
foreground_layout->setFieldGrowthPolicy(QFormLayout::FieldsStayAtSizeHint);
foreground_layout->addRow(tr("Color:"), m_foreground_color);
foreground_layout->addRow(tr("Opacity:"), m_foreground_opacity);
foreground_layout->addRow(tr("Position:"), m_foreground_position);
foreground_layout->addRow(tr("Width:"), m_foreground_width);
// Create rounding group
m_round_corners = new QGroupBox(tr("Round Text Background Corners"), contents);
m_round_corners->setCheckable(true);
m_round_corners->setChecked(m_theme.roundCornersEnabled());
connect(m_round_corners, SIGNAL(clicked()), this, SLOT(renderPreview()));
m_corner_radius = new QSpinBox(m_round_corners);
m_corner_radius->setCorrectionMode(QSpinBox::CorrectToNearestValue);
m_corner_radius->setSuffix(tr(" pixels"));
m_corner_radius->setRange(theme.cornerRadius().minimumValue(), theme.cornerRadius().maximumValue());
m_corner_radius->setValue(m_theme.cornerRadius());
connect(m_corner_radius, SIGNAL(valueChanged(int)), this, SLOT(renderPreview()));
QFormLayout* corner_layout = new QFormLayout(m_round_corners);
corner_layout->setFieldGrowthPolicy(QFormLayout::FieldsStayAtSizeHint);
corner_layout->addRow(tr("Radius:"), m_corner_radius);
// Create blur group
m_blur = new QGroupBox(tr("Blur Text Background"), contents);
m_blur->setCheckable(true);
m_blur->setChecked(m_theme.blurEnabled());
connect(m_blur, SIGNAL(clicked()), this, SLOT(renderPreview()));
m_blur_radius = new QSpinBox(m_blur);
m_blur_radius->setCorrectionMode(QSpinBox::CorrectToNearestValue);
m_blur_radius->setSuffix(tr(" pixels"));
m_blur_radius->setRange(theme.blurRadius().minimumValue(), theme.blurRadius().maximumValue());
m_blur_radius->setValue(m_theme.blurRadius());
connect(m_blur_radius, SIGNAL(valueChanged(int)), this, SLOT(renderPreview()));
QFormLayout* blur_layout = new QFormLayout(m_blur);
blur_layout->setFieldGrowthPolicy(QFormLayout::FieldsStayAtSizeHint);
blur_layout->addRow(tr("Radius:"), m_blur_radius);
// Create shadow group
m_shadow = new QGroupBox(tr("Text Background Drop Shadow"), contents);
m_shadow->setCheckable(true);
m_shadow->setChecked(m_theme.shadowEnabled());
connect(m_shadow, SIGNAL(clicked()), this, SLOT(renderPreview()));
m_shadow_color = new ColorButton(m_shadow);
m_shadow_color->setColor(m_theme.shadowColor());
connect(m_shadow_color, SIGNAL(changed(QColor)), this, SLOT(renderPreview()));
m_shadow_radius = new QSpinBox(m_shadow);
m_shadow_radius->setCorrectionMode(QSpinBox::CorrectToNearestValue);
m_shadow_radius->setSuffix(tr(" pixels"));
m_shadow_radius->setRange(theme.shadowRadius().minimumValue(), theme.shadowRadius().maximumValue());
m_shadow_radius->setValue(m_theme.shadowRadius());
connect(m_shadow_radius, SIGNAL(valueChanged(int)), this, SLOT(renderPreview()));
m_shadow_offset = new QSpinBox(m_shadow);
m_shadow_offset->setCorrectionMode(QSpinBox::CorrectToNearestValue);
m_shadow_offset->setSuffix(tr(" pixels"));
m_shadow_offset->setRange(theme.shadowOffset().minimumValue(), theme.shadowOffset().maximumValue());
m_shadow_offset->setValue(m_theme.shadowOffset());
connect(m_shadow_offset, SIGNAL(valueChanged(int)), this, SLOT(renderPreview()));
QFormLayout* shadow_layout = new QFormLayout(m_shadow);
shadow_layout->setFieldGrowthPolicy(QFormLayout::FieldsStayAtSizeHint);
shadow_layout->addRow(tr("Color:"), m_shadow_color);
shadow_layout->addRow(tr("Radius:"), m_shadow_radius);
shadow_layout->addRow(tr("Vertical Offset:"), m_shadow_offset);
// Create margins group
QGroupBox* margins_group = new QGroupBox(tr("Margins"), contents);
m_foreground_margin = new QSpinBox(margins_group);
m_foreground_margin->setCorrectionMode(QSpinBox::CorrectToNearestValue);
m_foreground_margin->setSuffix(tr(" pixels"));
m_foreground_margin->setRange(theme.foregroundMargin().minimumValue(), theme.foregroundMargin().maximumValue());
m_foreground_margin->setValue(m_theme.foregroundMargin());
connect(m_foreground_margin, SIGNAL(valueChanged(int)), this, SLOT(renderPreview()));
m_foreground_padding = new QSpinBox(margins_group);
m_foreground_padding->setCorrectionMode(QSpinBox::CorrectToNearestValue);
m_foreground_padding->setSuffix(tr(" pixels"));
m_foreground_padding->setRange(theme.foregroundPadding().minimumValue(), theme.foregroundPadding().maximumValue());
m_foreground_padding->setValue(m_theme.foregroundPadding());
connect(m_foreground_padding, SIGNAL(valueChanged(int)), this, SLOT(renderPreview()));
QFormLayout* margins_layout = new QFormLayout(margins_group);
margins_layout->setFieldGrowthPolicy(QFormLayout::FieldsStayAtSizeHint);
margins_layout->addRow(tr("Window:"), m_foreground_margin);
margins_layout->addRow(tr("Page:"), m_foreground_padding);
// Create line spacing group
QGroupBox* line_spacing = new QGroupBox(tr("Line Spacing"), contents);
m_line_spacing_type = new QComboBox(line_spacing);
m_line_spacing_type->setEditable(false);
m_line_spacing_type->addItems(QStringList() << tr("Single") << tr("1.5 Lines") << tr("Double") << tr("Proportional"));
m_line_spacing_type->setCurrentIndex(3);
m_line_spacing = new QSpinBox(line_spacing);
m_line_spacing->setSuffix(QLocale().percent());
m_line_spacing->setRange(theme.lineSpacing().minimumValue(), theme.lineSpacing().maximumValue());
m_line_spacing->setValue(m_theme.lineSpacing());
m_line_spacing->setEnabled(false);
switch (m_theme.lineSpacing()) {
case 100: m_line_spacing_type->setCurrentIndex(0); break;
case 150: m_line_spacing_type->setCurrentIndex(1); break;
case 200: m_line_spacing_type->setCurrentIndex(2); break;
default: m_line_spacing->setEnabled(true); break;
}
connect(m_line_spacing_type, SIGNAL(currentIndexChanged(int)), this, SLOT(lineSpacingChanged(int)));
connect(m_line_spacing_type, SIGNAL(currentIndexChanged(int)), this, SLOT(renderPreview()));
connect(m_line_spacing, SIGNAL(valueChanged(int)), this, SLOT(renderPreview()));
QFormLayout* line_spacing_layout = new QFormLayout(line_spacing);
line_spacing_layout->setFieldGrowthPolicy(QFormLayout::FieldsStayAtSizeHint);
line_spacing_layout->addRow(tr("Type:"), m_line_spacing_type);
line_spacing_layout->addRow(tr("Height:"), m_line_spacing);
// Create paragraph spacing group
QGroupBox* paragraph_spacing = new QGroupBox(tr("Paragraph Spacing"), contents);
m_tab_width = new QSpinBox(paragraph_spacing);
m_tab_width->setSuffix(tr(" pixels"));
m_tab_width->setRange(theme.tabWidth().minimumValue(), theme.tabWidth().maximumValue());
m_tab_width->setValue(m_theme.tabWidth());
connect(m_tab_width, SIGNAL(valueChanged(int)), this, SLOT(renderPreview()));
m_spacing_above_paragraph = new QSpinBox(paragraph_spacing);
m_spacing_above_paragraph->setSuffix(tr(" pixels"));
m_spacing_above_paragraph->setRange(theme.spacingAboveParagraph().minimumValue(), theme.spacingAboveParagraph().maximumValue());
m_spacing_above_paragraph->setValue(m_theme.spacingAboveParagraph());
connect(m_spacing_above_paragraph, SIGNAL(valueChanged(int)), this, SLOT(renderPreview()));
m_spacing_below_paragraph = new QSpinBox(paragraph_spacing);
m_spacing_below_paragraph->setSuffix(tr(" pixels"));
m_spacing_below_paragraph->setRange(theme.spacingBelowParagraph().minimumValue(), theme.spacingBelowParagraph().maximumValue());
m_spacing_below_paragraph->setValue(m_theme.spacingBelowParagraph());
connect(m_spacing_below_paragraph, SIGNAL(valueChanged(int)), this, SLOT(renderPreview()));
m_indent_first_line = new QCheckBox(tr("Indent first line"), paragraph_spacing);
m_indent_first_line->setChecked(m_theme.indentFirstLine());
connect(m_indent_first_line, SIGNAL(toggled(bool)), this, SLOT(renderPreview()));
QFormLayout* paragraph_spacing_layout = new QFormLayout(paragraph_spacing);
paragraph_spacing_layout->setFieldGrowthPolicy(QFormLayout::FieldsStayAtSizeHint);
paragraph_spacing_layout->addRow(tr("Tab Width:"), m_tab_width);
paragraph_spacing_layout->addRow(tr("Above:"), m_spacing_above_paragraph);
paragraph_spacing_layout->addRow(tr("Below:"), m_spacing_below_paragraph);
paragraph_spacing_layout->addRow("", m_indent_first_line);
// Create preview
m_preview_text = new QTextEdit;
m_preview_text->setFrameStyle(QFrame::NoFrame);
m_preview_text->setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
m_preview_text->setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
QFile file(":/lorem.txt");
if (file.open(QFile::ReadOnly)) {
m_preview_text->setPlainText(QString::fromLatin1(file.readAll()));
file.close();
}
m_preview = new QLabel(this);
m_preview->setAlignment(Qt::AlignCenter);
m_preview->setFrameStyle(QFrame::Sunken | QFrame::StyledPanel);
QPixmap pixmap(480, 270);
pixmap.fill(palette().window().color());
m_preview->setPixmap(pixmap);
m_theme_renderer = new ThemeRenderer(this);
connect(m_theme_renderer, SIGNAL(rendered(QImage,QRect,Theme)), this, SLOT(renderPreview(QImage,QRect,Theme)));
renderPreview();
// Lay out dialog
QDialogButtonBox* buttons = new QDialogButtonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel, Qt::Horizontal, this);
m_ok = buttons->button(QDialogButtonBox::Ok);
connect(buttons, SIGNAL(accepted()), this, SLOT(accept()));
connect(buttons, SIGNAL(rejected()), this, SLOT(reject()));
QVBoxLayout* groups_layout = new QVBoxLayout(contents);
groups_layout->addWidget(text_group);
groups_layout->addWidget(background_group);
groups_layout->addWidget(foreground_group);
groups_layout->addWidget(m_round_corners);
groups_layout->addWidget(m_blur);
groups_layout->addWidget(m_shadow);
groups_layout->addWidget(margins_group);
groups_layout->addWidget(line_spacing);
groups_layout->addWidget(paragraph_spacing);
QGridLayout* layout = new QGridLayout(this);
layout->setColumnStretch(0, 1);
layout->setRowStretch(1, 1);
layout->setRowMinimumHeight(2, layout->margin());
layout->addLayout(name_layout, 0, 0, 1, 2);
layout->addWidget(scroll, 1, 0, 1, 1);
layout->addWidget(m_preview, 1, 1, 1, 1, Qt::AlignCenter);
layout->addWidget(buttons, 3, 0, 1, 2);
resize(QSettings().value("ThemeDialog/Size", sizeHint()).toSize());
}
gboolean dialog (
PlugInVals *vals,
PlugInUIVals *ui_vals)
{
if (!gimp_drawable_is_valid(vals->image_drawable_id)) {
vals->image_drawable_id = default_vals.image_drawable_id;
}
if (!gimp_drawable_is_valid(vals->mask_drawable_id)) {
vals->mask_drawable_id = default_vals.mask_drawable_id;
}
if (!gimp_vectors_is_valid(vals->stop_path_id)) {
vals->stop_path_id = default_vals.stop_path_id;
}
vals->output_drawable_id = vals->image_drawable_id;
print_vals(vals);
set_defaults(ui_vals);
interface_vals.imageID = gimp_drawable_get_image(vals->image_drawable_id);
interface_vals.image_name = gimp_image_get_name(interface_vals.imageID);
interface_vals.image_drawable = NULL;
interface_vals.mask_drawable = NULL;
if (vals->image_drawable_id >= 0) {
#ifdef DEBUG
g_warning("There is an input image drawable id");
#endif
interface_vals.image_drawable = gimp_drawable_get(vals->image_drawable_id);
}
if (vals->mask_drawable_id >= 0) {
interface_vals.mask_drawable = gimp_drawable_get(vals->mask_drawable_id);
} else {
interface_vals.mask_drawable = NULL;
}
ui_state = ui_vals;
//if there is a selection create mask drawable and fill
gimp_drawable_mask_bounds(vals->image_drawable_id,&interface_vals.selectionX0,
&interface_vals.selectionY0,
&interface_vals.selectionX1,
&interface_vals.selectionY1);
interface_vals.selectionWidth = interface_vals.selectionX1-interface_vals.selectionX0;
interface_vals.selectionHeight = interface_vals.selectionY1-interface_vals.selectionY0;
gint image_width = gimp_drawable_width(vals->image_drawable_id);
gint image_height = gimp_drawable_height(vals->image_drawable_id);
interface_vals.selectionX0 -= PREVIEW_SIZE*0.1;
if (interface_vals.selectionX0 < 0) interface_vals.selectionX0 = 0;
interface_vals.selectionX1 += PREVIEW_SIZE*0.1;
if (interface_vals.selectionX1 > image_width) interface_vals.selectionX1 = image_width;
interface_vals.selectionY0 -= PREVIEW_SIZE*0.1;
if (interface_vals.selectionY0 < 0) interface_vals.selectionY0 = 0;
interface_vals.selectionY1 += PREVIEW_SIZE*0.1;
if (interface_vals.selectionY1 > image_height) interface_vals.selectionY1 = image_height;
interface_vals.selectionWidth = interface_vals.selectionX1-interface_vals.selectionX0;
interface_vals.selectionHeight = interface_vals.selectionY1-interface_vals.selectionY0;
//vals->mask_drawable_id = gimp_image_get_selection(gimp_drawable_get_image(vals->image_drawable_id));
//g_warning("there is a selection with id = %d",vals->mask_drawable_id);
//if (interface_vals.mask_drawable != NULL) gimp_drawable_detach(interface_vals.mask_drawable);
//interface_vals.mask_drawable = gimp_drawable_get(vals->mask_drawable_id);
#ifdef DEBUG
g_warning("image dims: x0,x1,y0,y1 = %d,%d,%d,%d",interface_vals.selectionX0,interface_vals.selectionX1,interface_vals.selectionY0,interface_vals.selectionY1);
#endif
gchar text[100];
sprintf(text,"Inpainting: %s",interface_vals.image_name);
gimp_ui_init (PLUGIN_NAME, TRUE);
GtkWidget* dlg = gimp_dialog_new (text, PLUGIN_NAME,
NULL, 0,
gimp_standard_help_func, "gimp-inpaint-BCT",
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_APPLY, GTK_RESPONSE_APPLY,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gimp_window_set_transient (GTK_WINDOW (dlg));
GtkWidget* vbox = gtk_vbox_new (FALSE, 10);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 10);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dlg))),
vbox, FALSE, FALSE, 0);
gtk_widget_show (vbox);
/* Preview */
GtkWidget* hbox = gtk_hbox_new (TRUE, 0);
gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
GtkWidget* frame = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, FALSE, 0);
gtk_widget_show (frame);
// interface_vals.preview = TRUE;
// interface_vals.preview_widget = GIMP_DRAWABLE_PREVIEW (gimp_drawable_preview_new(interface_vals.image_drawable,&interface_vals.preview));
// gtk_container_add (GTK_CONTAINER (frame), GTK_WIDGET (interface_vals.preview_widget));
// gtk_widget_show (GTK_WIDGET (interface_vals.preview_widget));
interface_vals.previewWidth = MIN (interface_vals.selectionWidth, PREVIEW_SIZE);
interface_vals.previewHeight = MIN (interface_vals.selectionHeight, PREVIEW_SIZE);
interface_vals.preview_widget = gimp_preview_area_new ();
gtk_widget_set_size_request (interface_vals.preview_widget,
interface_vals.previewWidth, interface_vals.previewHeight);
gtk_container_add (GTK_CONTAINER (frame), interface_vals.preview_widget);
gtk_widget_show (interface_vals.preview_widget);
buildPreviewSourceImage (vals);
/* Source and Mask selection */
GtkWidget* table = gtk_table_new (5, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
//gtk_table_set_row_spacing (GTK_TABLE (table), 1, 12);
//gtk_table_set_row_spacing (GTK_TABLE (table), 3, 12);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
GtkWidget* label = gtk_label_new (_("Source:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
GtkWidget* combo = gimp_drawable_combo_box_new (NULL, NULL);
#ifdef DEBUG
g_warning("setting initi value of source combo box as %d",vals->image_drawable_id);
#endif
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (combo), vals->image_drawable_id,
G_CALLBACK (dialogSourceChangedCallback),vals);
gtk_table_attach (GTK_TABLE (table), combo, 1, 3, 0, 1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (combo);
label = gtk_label_new(_("Mask:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 1, 2,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
interface_vals.mask_combo_widget = gimp_drawable_combo_box_new (NULL, NULL);
if (interface_vals.mask_type == SELECTION) {
gtk_widget_set_sensitive(interface_vals.mask_combo_widget,FALSE);
}
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (interface_vals.mask_combo_widget),
vals->mask_drawable_id,
G_CALLBACK (dialogMaskChangedCallback),vals);
gtk_table_attach (GTK_TABLE (table), interface_vals.mask_combo_widget, 1, 3, 1, 2,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (interface_vals.mask_combo_widget);
label = gtk_label_new (_("Stop Path:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 2, 3,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
interface_vals.stop_path_combo_widget = gimp_vectors_combo_box_new (NULL, NULL);
gtk_widget_set_sensitive(interface_vals.stop_path_combo_widget,FALSE);
gimp_int_combo_box_connect (GIMP_INT_COMBO_BOX (interface_vals.stop_path_combo_widget), vals->stop_path_id,
G_CALLBACK (dialogStopPathChangedCallback),vals);
gtk_table_attach (GTK_TABLE (table), interface_vals.stop_path_combo_widget, 1, 3, 2, 3,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (interface_vals.stop_path_combo_widget);
label = gtk_label_new(_("Mask Type:"));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
gtk_widget_show (label);
interface_vals.mask_type_widget = gtk_combo_box_new_text();
gint num_vectors;
gimp_image_get_vectors(interface_vals.imageID,&num_vectors);
gtk_combo_box_append_text(GTK_COMBO_BOX(interface_vals.mask_type_widget),"Selection");
if (num_vectors > 0)
gtk_combo_box_append_text(GTK_COMBO_BOX(interface_vals.mask_type_widget),"Selection With Stop Path");
gtk_combo_box_append_text(GTK_COMBO_BOX(interface_vals.mask_type_widget),"Binary Mask");
if (num_vectors > 0)
gtk_combo_box_append_text(GTK_COMBO_BOX(interface_vals.mask_type_widget),"Binary Mask With Stop Path");
gtk_combo_box_append_text(GTK_COMBO_BOX(interface_vals.mask_type_widget),"Mask Including Ordering");
if (interface_vals.mask_type == SELECTION) {
int mt_index = 0 + (vals->stop_path_id > 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(interface_vals.mask_type_widget),mt_index);
} else if (interface_vals.mask_type == BINARY_MASK) {
int mt_index = 1 + (num_vectors > 0) + (vals->stop_path_id > 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(interface_vals.mask_type_widget),mt_index);
} else {
int mt_index = 2 + 2*(num_vectors > 0);
gtk_combo_box_set_active(GTK_COMBO_BOX(interface_vals.mask_type_widget),mt_index);
}
g_signal_connect (interface_vals.mask_type_widget, "changed",
G_CALLBACK(maskTypeChangedCallback), vals);
maskTypeChangedCallback(GTK_COMBO_BOX(interface_vals.mask_type_widget),vals);
gtk_table_attach (GTK_TABLE (table), interface_vals.mask_type_widget, 1, 3, 3, 4,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
gtk_widget_show (interface_vals.mask_type_widget);
// Create the parameter table
// table = gtk_table_new (5, 3, FALSE);
// gtk_table_set_col_spacings (GTK_TABLE (table), 6);
// gtk_table_set_row_spacings (GTK_TABLE (table), 6);
// gtk_container_set_border_width (GTK_CONTAINER (table), 12);
// gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
//
// gtk_widget_show (table);
interface_vals.threshold_scale = gimp_scale_entry_new (GTK_TABLE (table), 0, 4,"_Mask Threshold:", SCALE_WIDTH, 0,vals->threshold, 0, 255, 0.1, 0.2, EPS_DIGITS,TRUE, 0, 0,NULL, NULL);
g_signal_connect (interface_vals.threshold_scale, "value_changed", G_CALLBACK(dialogThresholdChanged), vals);
GtkWidget *separator = gtk_hseparator_new ();
gtk_box_pack_start (GTK_BOX (vbox), separator, FALSE, FALSE, 5);
gtk_widget_show (separator);
table = gtk_table_new (5, 3, FALSE);
gtk_table_set_col_spacings (GTK_TABLE (table), 6);
gtk_table_set_row_spacings (GTK_TABLE (table), 6);
//gtk_table_set_row_spacing (GTK_TABLE (table), 1, 12);
//gtk_table_set_row_spacing (GTK_TABLE (table), 3, 12);
gtk_box_pack_start (GTK_BOX (vbox), table, FALSE, FALSE, 0);
gtk_widget_show (table);
interface_vals.epsilon_scale = gimp_scale_entry_new (GTK_TABLE (table), 0, 0,"_Pixel neighborhood (epsilon):", SCALE_WIDTH, 0,vals->epsilon, 1, SCALE_MAX, 0.5, 0.2, EPS_DIGITS,TRUE, 0, 0,NULL, NULL);
g_signal_connect (interface_vals.epsilon_scale, "value_changed", G_CALLBACK(gimp_float_adjustment_update), &vals->epsilon);
interface_vals.kappa_scale = gimp_scale_entry_new (GTK_TABLE (table), 0, 1, "_Sharpness (kappa in %):", SCALE_WIDTH, 0, vals->kappa, 0, CONV_MAX, 1, 0.1, KAPPA_DIGITS,TRUE, 0, 0,NULL, NULL);
g_signal_connect (interface_vals.kappa_scale, "value_changed", G_CALLBACK(gimp_float_adjustment_update), &vals->kappa);
interface_vals.sigma_scale = gimp_scale_entry_new (GTK_TABLE (table), 0, 2, "_Pre-smoothing (sigma):", SCALE_WIDTH, 0, vals->sigma, 0, SCALE_MAX, 0.1, 0.1, SMOOTH_DIGITS,TRUE, 0, 0,NULL, NULL);
g_signal_connect (interface_vals.sigma_scale, "value_changed", G_CALLBACK(gimp_float_adjustment_update), &vals->sigma);
interface_vals.rho_scale = gimp_scale_entry_new (GTK_TABLE (table), 0, 3, "_Post-smoothing (rho):", SCALE_WIDTH, 0, vals->rho, 0.001, SCALE_MAX, 0.1, 0.1, SMOOTH_DIGITS,TRUE, 0, 0,NULL, NULL);
g_signal_connect (interface_vals.rho_scale, "value_changed", G_CALLBACK(gimp_float_adjustment_update), &vals->rho);
// // test extra button
// GtkWidget *togglebutton = gtk_check_button_new_with_label("Inpaint Animation");
// gtk_toggle_button_set_active( (GtkToggleButton *) togglebutton, ui_vals->anim_mode);
// gtk_widget_show(togglebutton);
//
// gimp_table_attach_aligned(GTK_TABLE (table),0,4,NULL,0,0,togglebutton,1,TRUE);
//
// g_signal_connect (togglebutton, "toggled", G_CALLBACK(gimp_toggle_button_update), &ui_vals->anim_mode);
GtkWidget *default_param_button = gtk_button_new_with_label("Default Parameters");
gtk_widget_show(default_param_button);
gtk_table_attach((GtkTable *)table,default_param_button,0,1,4,5,GTK_EXPAND,GTK_EXPAND,0,0);
g_signal_connect (default_param_button, "clicked", G_CALLBACK(set_default_param), NULL);
//test end
// Display dialog
gtk_widget_show(dlg);
renderPreview(vals);
GtkResponseType status = gimp_dialog_run (GIMP_DIALOG (dlg));
while (status == GTK_RESPONSE_APPLY) {
render (vals);
gimp_displays_flush ();
status = gimp_dialog_run (GIMP_DIALOG (dlg));
}
ui_vals->mask_type = interface_vals.mask_type;
destroy();
gtk_widget_destroy (dlg);
return (status == GTK_RESPONSE_OK);
}
