// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// MainWindow::execute:
//
// Determine which action was triggered and execute respective action.
// Skip this if action is not image-processing related: open(), quit()
//
void
MainWindow::execute(QAction* action)
{
// skip over menu ops that don't require image processing
QString name = action->text();
if(name == QString("&Open") || name == QString("&Quit")) {
m_code = -1;
return;
}
// get code from action
m_code = action->data().toInt();
// set output radio button to true
m_radioDisplay[1]->setChecked(true);
// use code to index into stack widget and array of filters
m_stackWidgetPanels->setCurrentIndex(m_code);
m_imageFilterType[m_code]->applyFilter(m_imageSrc, m_imageDst);
preview();
}
void KIconConfig::EffectSetup(int state)
{
int viewedGroup = (mUsage == KIconLoader::LastGroup) ? KIconLoader::FirstGroup : mUsage;
QPixmap pm = mpLoader->loadIcon(mExample, KIconLoader::NoGroup, mSizes[viewedGroup]);
QImage img = pm.toImage();
QString caption;
switch (state)
{
case 0 : caption = i18n("Setup Default Icon Effect"); break;
case 1 : caption = i18n("Setup Active Icon Effect"); break;
case 2 : caption = i18n("Setup Disabled Icon Effect"); break;
}
KIconEffectSetupDialog dlg(mEffects[viewedGroup][state], mDefaultEffect[state], caption, img, this);
if (dlg.exec() == QDialog::Accepted)
{
if (mUsage == KIconLoader::LastGroup) {
for (int i=0; i<KIconLoader::LastGroup; i++)
mEffects[i][state] = dlg.effect();
} else {
mEffects[mUsage][state] = dlg.effect();
}
// AK - can this call be moved therefore removing
// code duplication?
emit changed(true);
if (mUsage == KIconLoader::LastGroup) {
for (int i=0; i<KIconLoader::LastGroup; i++)
mbChanged[i] = true;
} else {
mbChanged[mUsage] = true;
}
}
preview(state);
}
QImage QgsSymbolV2::bigSymbolPreviewImage()
{
QImage preview( QSize( 100, 100 ), QImage::Format_ARGB32_Premultiplied );
preview.fill( 0 );
QPainter p( &preview );
p.setRenderHint( QPainter::Antialiasing );
p.translate( 0.5, 0.5 ); // shift by half a pixel to avoid blurring due antialising
if ( mType == QgsSymbolV2::Marker )
{
p.setPen( QPen( Qt::gray ) );
p.drawLine( 0, 50, 100, 50 );
p.drawLine( 50, 0, 50, 100 );
}
QgsRenderContext context = QgsSymbolLayerV2Utils::createRenderContext( &p );
startRender( context );
if ( mType == QgsSymbolV2::Line )
{
QPolygonF poly;
poly << QPointF( 0, 50 ) << QPointF( 99, 50 );
static_cast<QgsLineSymbolV2*>( this )->renderPolyline( poly, 0, context );
}
else if ( mType == QgsSymbolV2::Fill )
{
QPolygonF polygon;
polygon << QPointF( 20, 20 ) << QPointF( 80, 20 ) << QPointF( 80, 80 ) << QPointF( 20, 80 ) << QPointF( 20, 20 );
static_cast<QgsFillSymbolV2*>( this )->renderPolygon( polygon, NULL, 0, context );
}
else // marker
{
static_cast<QgsMarkerSymbolV2*>( this )->renderPoint( QPointF( 50, 50 ), 0, context );
}
stopRender( context );
return preview;
}
void ImportASCIIDialog::changePreviewFile(const QString& path)
{
if (path.isEmpty())
return;
if (d_current_path.isEmpty()){//avoid importing the first file which is by default selected in the file dialog
d_current_path = path;
return;
}
QFileInfo fi(path);
if (!fi.exists() || fi.isDir() || !fi.isFile())
return;
if (!fi.isReadable()){
QMessageBox::critical(this, tr("QtiPlot - File openning error"),
tr("You don't have the permission to open this file: <b>%1</b>").arg(path));
return;
}
d_current_path = path;
preview();
}
SchedulePrintDialog::SchedulePrintDialog( ScheduleWidget * widget )
: QDialog( widget )
, mScheduleWidget( widget )
{
setupUi(this);
for( int i=0; pageSizeNames[i]; i++ )
mPageSizeCombo->addItem( pageSizeNames[i] );
connect( mPreviewButton, SIGNAL( clicked() ), SLOT( preview() ) );
connect( mPrintButton, SIGNAL( clicked() ), SLOT( print() ) );
connect( mSavePdfButton, SIGNAL( clicked() ), SLOT( savePdf() ) );
mFontTree->setHeaderLabels( QStringList() << "Location" << "Font" );
connect( mFontTree, SIGNAL( itemDoubleClicked( QTreeWidgetItem *, int ) ), SLOT( updateFont( QTreeWidgetItem * ) ) );
mDisplayOptions = widget->mDisplayOptions;
ScheduleDisplayOptions & dops = mDisplayOptions;
setupFontItem( mFontTree, "Header Month/Year", &dops.headerMonthYearFont );
setupFontItem( mFontTree, "Header Day/Week", &dops.headerDayWeekFont );
setupFontItem( mFontTree, "Panel", &dops.panelFont );
setupFontItem( mFontTree, "Cell Day", &dops.cellDayFont );
setupFontItem( mFontTree, "Entry", &dops.entryFont );
setupFontItem( mFontTree, "Entry Hours", &dops.entryHoursFont );
}
int main( int argc, char** argv ) {
QApplication app( argc, argv );
// Create a report
KDReports::Report report;
QFile reportFile( ":/MailMerge.xml" );
if( !reportFile.open( QIODevice::ReadOnly ) ) {
QMessageBox::warning(
0, QObject::tr( "Warning" ),
QObject::tr( "Could not open report description file 'MailMerge.xml'. "
"Please start this program from the HelloWorldXML directory." ) );
return -1;
}
TableModel members;
members.setDataHasVerticalHeaders( false );
members.loadFromCSV( ":/members.csv" );
report.associateModel( QLatin1String( "members" ), &members);
for (int i = 0; i < members.rowCount(); i++ ) {
report.setCurrentRow(&members, i);
KDReports::ErrorDetails details;
if( !report.loadFromXML( &reportFile, &details ) ) {
QMessageBox::warning( 0, QObject::tr( "Warning" ), QObject::tr( "Could not parse report description file:\n%1" ).arg(details.message()) );
reportFile.close();
return -2;
}
if ( i < members.rowCount() - 1 )
report.addPageBreak();
// show a print preview:
}
KDReports::PreviewDialog preview( &report );
return preview.exec();
}
int MainWindow::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = QMainWindow::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
switch (_id) {
case 0: addFiles(); break;
case 1: about(); break;
case 2: next(); break;
case 3: preview(); break;
case 4: doubleclickplay(); break;
case 5: stateChanged((*reinterpret_cast< Phonon::State(*)>(_a[1])),(*reinterpret_cast< Phonon::State(*)>(_a[2]))); break;
case 6: tick((*reinterpret_cast< qint64(*)>(_a[1]))); break;
case 7: sourceChanged((*reinterpret_cast< const Phonon::MediaSource(*)>(_a[1]))); break;
case 8: metaStateChanged((*reinterpret_cast< Phonon::State(*)>(_a[1])),(*reinterpret_cast< Phonon::State(*)>(_a[2]))); break;
case 9: aboutToFinish(); break;
case 10: tableClicked((*reinterpret_cast< int(*)>(_a[1])),(*reinterpret_cast< int(*)>(_a[2]))); break;
default: ;
}
_id -= 11;
}
return _id;
}
DesktopBackgroundDialog::DesktopBackgroundDialog(RazorSettings * cfg, int screen, int desktop, QSize desktopSize, const QBrush & brush, QWidget * parent)
: QDialog(parent),
m_desktopSize(desktopSize),
m_type(RazorWorkSpaceManager::BackgroundColor),
m_config(cfg),
m_screen(screen),
m_desktop(desktop)
{
setupUi(this);
// center it to current desktop
move(parent->geometry().center() - geometry().center());
// read current wallpaper brush
if (brush.texture().isNull())
{
m_color = brush.color();
preview();
}
else
{
QPixmap p = brush.texture().scaled(previewLabel->size(), Qt::IgnoreAspectRatio, Qt::FastTransformation);
previewLabel->setPixmap(p);
}
connect(colorButton, SIGNAL(clicked()),
this, SLOT(colorButton_clicked()));
connect(wallpaperButton, SIGNAL(clicked()),
this, SLOT(wallpaperButton_clicked()));
connect(systemButton, SIGNAL(clicked()),
this, SLOT(systemButton_clicked()));
connect(keepAspectCheckBox, SIGNAL(toggled(bool)),
this, SLOT(preview()));
buttonBox->button(QDialogButtonBox::Ok)->setEnabled(false);
keepAspectCheckBox->setEnabled(false);
}
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// MainWindow::open:
//
// Open input image.
//
void
MainWindow::open() {
QFileDialog dialog(this);
// open the last known working directory
if(!m_currentDir.isEmpty())
dialog.setDirectory(m_currentDir);
// display existing files and directories
dialog.setFileMode(QFileDialog::ExistingFile);
// invoke native file browser to select file
m_file = dialog.getOpenFileName(this,
"Open File", m_currentDir,
"Images (*.jpg *.png *.ppm *.pgm *.bmp);;All files (*)");
// verify that file selection was made
if(m_file.isNull()) return;
// save current directory
QFileInfo f(m_file);
m_currentDir = f.absolutePath();
// DISABLE IMAGING FUNCTIONALITY FOR NOW....
// read input image
m_imageIn = IP_readImage(qPrintable(m_file));
if(m_radioMode[1]->isChecked())
IP_castImage(m_imageIn, BW_IMAGE, m_imageSrc);
else IP_castImage(m_imageIn, RGB_IMAGE, m_imageSrc);
// init vars
m_width = m_imageSrc->width ();
m_height = m_imageSrc->height();
preview();
}
void StatePreview::generateImage( const QSize& wallDimensions,
const ContentWindowPtrs &contentWindows )
{
QSize previewDimension( wallDimensions );
previewDimension.scale( PREVIEW_IMAGE_SIZE, Qt::KeepAspectRatio );
// Transparent image
QImage preview( previewDimension, QImage::Format_ARGB32 );
preview.fill( qRgba( 0, 0, 0, 0 ));
QPainter painter( &preview );
// Paint all Contents at their correct location
BOOST_FOREACH( ContentWindowPtr window, contentWindows )
{
if( window->getContent()->getType() == CONTENT_TYPE_PIXEL_STREAM )
continue;
const QRectF& winCoord = window->getCoordinates();
const QRectF area( winCoord.x() * preview.size().width(),
winCoord.y() * preview.size().height(),
winCoord.width() * preview.size().width(),
winCoord.height() * preview.size().height( ));
const QString& filename = window->getContent()->getURI();
ThumbnailGeneratorPtr generator =
ThumbnailGeneratorFactory::getGenerator( filename, THUMBNAIL_SIZE );
const QImage image = generator->generate( filename );
painter.drawImage( area, image );
}
painter.end();
previewImage_ = preview;
}
void PreviewToggleCommand::postProcess() {
TApp *app = TApp::instance();
CleanupSettingsModel *model = CleanupSettingsModel::instance();
TXshSimpleLevel *sl;
TFrameId fid;
model->getCleanupFrame(sl, fid);
assert(sl);
if (!sl) return;
// Retrieve transformed image
TRasterImageP transformed;
{
TRasterImageP original;
TAffine transform;
model->getPreviewData(original, transformed, transform);
if (!transformed) return;
}
// Perform post-processing
TRasterImageP preview(
TCleanupper::instance()->processColors(transformed->getRaster()));
TPointD dpi;
transformed->getDpi(dpi.x, dpi.y);
preview->setDpi(dpi.x, dpi.y);
transformed = TRasterImageP();
// Substitute current frame image with previewed one
sl->setFrame(fid, preview);
TApp::instance()->getCurrentLevel()->notifyLevelChange();
}
static void
gfilter_dialog(GFilterArgs *args,
GwyContainer *data,
GwyDataField *dfield,
GwyDataField *mfield,
gint id,
GQuark mquark)
{
GtkWidget *dialog, *table, *vbox, *hbox, *scwin, *hbox2, *label;
GtkTreeView *treeview;
GtkTreeSelection *selection;
GFilterControls controls;
gint response, row, i;
GwySIUnit *siunit;
GwyPixmapLayer *layer;
controls.args = args;
controls.mask = mfield;
controls.in_init = TRUE;
controls.computed = FALSE;
siunit = gwy_si_unit_new(NULL);
for (i = 0; i < NQUANTITIES; i++) {
controls.vf[i]
= gwy_si_unit_get_format_with_digits(siunit,
GWY_SI_UNIT_FORMAT_VFMARKUP,
1.0, 4, NULL);
}
g_object_unref(siunit);
dialog = gtk_dialog_new_with_buttons(_("Filter Grains"),
NULL, 0, NULL);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog),
gwy_stock_like_button_new(_("_Update"),
GTK_STOCK_EXECUTE),
RESPONSE_PREVIEW);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), RESPONSE_PREVIEW,
!args->update);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
controls.dialog = dialog;
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE, TRUE, 4);
vbox = gtk_vbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 4);
controls.mydata = gwy_container_new();
gwy_container_set_object_by_name(controls.mydata, "/0/data", dfield);
mfield = gwy_data_field_duplicate(mfield);
gwy_container_set_object_by_name(controls.mydata, "/0/mask", mfield);
g_object_unref(mfield);
gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_RANGE,
GWY_DATA_ITEM_REAL_SQUARE,
0);
controls.view = gwy_data_view_new(controls.mydata);
layer = gwy_layer_basic_new();
g_object_set(layer,
"data-key", "/0/data",
"gradient-key", "/0/base/palette",
"range-type-key", "/0/base/range-type",
"min-max-key", "/0/base",
NULL);
gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.view), "/0/data");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer);
layer = gwy_layer_mask_new();
gwy_pixmap_layer_set_data_key(layer, "/0/mask");
gwy_layer_mask_set_color_key(GWY_LAYER_MASK(layer), "/0/mask");
gwy_data_view_set_alpha_layer(GWY_DATA_VIEW(controls.view), layer);
gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE);
gtk_box_pack_start(GTK_BOX(vbox), controls.view, FALSE, FALSE, 0);
controls.update = gtk_check_button_new_with_mnemonic(_("I_nstant updates"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.update),
args->update);
gtk_box_pack_start(GTK_BOX(vbox), controls.update, FALSE, FALSE, 0);
g_signal_connect_swapped(controls.update, "toggled",
G_CALLBACK(update_changed), &controls);
hbox2 = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic(_("_Mask color:"));
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
controls.color_button = gwy_color_button_new();
gwy_color_button_set_use_alpha(GWY_COLOR_BUTTON(controls.color_button),
TRUE);
load_mask_color(controls.color_button,
gwy_data_view_get_data(GWY_DATA_VIEW(controls.view)));
gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.color_button);
gtk_box_pack_start(GTK_BOX(hbox2), controls.color_button, FALSE, FALSE, 0);
g_signal_connect(controls.color_button, "clicked",
G_CALLBACK(mask_color_changed), &controls);
table = gtk_table_new(10, 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(hbox), table, TRUE, TRUE, 4);
controls.table = table;
row = 0;
scwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_table_attach(GTK_TABLE(table), scwin, 0, 4, row, row+1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
controls.values = gwy_grain_value_tree_view_new(FALSE,
"name", "symbol_markup",
NULL);
treeview = GTK_TREE_VIEW(controls.values);
gtk_widget_set_size_request(scwin, -1, 120);
gtk_tree_view_set_headers_visible(treeview, FALSE);
selection = gtk_tree_view_get_selection(treeview);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gwy_grain_value_tree_view_set_same_units(treeview, args->units_equal);
gwy_grain_value_tree_view_set_expanded_groups(treeview, args->expanded);
gtk_container_add(GTK_CONTAINER(scwin), controls.values);
row++;
hbox2 = gtk_hbox_new(FALSE, 0);
for (i = 0; i < NQUANTITIES; i++) {
gchar buf[2];
buf[0] = 'A' + i;
buf[1] = '\0';
controls.set_as[i] = gtk_button_new_with_label(buf);
gtk_box_pack_start(GTK_BOX(hbox2), controls.set_as[i], FALSE, FALSE, 0);
g_object_set_data(G_OBJECT(controls.set_as[i]),
"id", GUINT_TO_POINTER(i));
g_signal_connect_swapped(controls.set_as[i], "clicked",
G_CALLBACK(set_as_clicked), &controls);
}
gwy_table_attach_hscale(table, row++,
_("Set selected as:"), NULL,
GTK_OBJECT(hbox2), GWY_HSCALE_WIDGET_NO_EXPAND);
controls.logical_op
= gwy_enum_combo_box_newl(G_CALLBACK(logical_op_changed), &controls,
args->logical,
"A", GRAIN_LOGICAL_A,
"A ∧ B", GRAIN_LOGICAL_A_AND_B,
"A ∨ B", GRAIN_LOGICAL_A_OR_B,
"A ∧ B ∧ C", GRAIN_LOGICAL_A_AND_B_AND_C,
"A ∨ B ∨ C", GRAIN_LOGICAL_A_OR_B_OR_C,
"(A ∧ B) ∨ C", GRAIN_LOGICAL_A_AND_B_OR_C,
"(A ∨ B) ∧ C", GRAIN_LOGICAL_A_OR_B_AND_C,
NULL);
gwy_table_attach_hscale(table, row++,
_("Keep grains satisfying:"), NULL,
GTK_OBJECT(controls.logical_op),
GWY_HSCALE_WIDGET);
for (i = 0; i < NQUANTITIES; i++) {
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
controls.header[i] = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.header[i]), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.header[i],
0, 4, row, row+1, GTK_FILL, 0, 0, 0);
row++;
/* The values are set properly later. */
controls.lower_label[i] = gtk_label_new(_("Lower threshold:"));
gtk_misc_set_alignment(GTK_MISC(controls.lower_label[i]), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.lower_label[i],
0, 1, row, row+1, GTK_FILL, 0, 0, 0);
controls.lower[i] = gtk_adjustment_new(0.0, 0.0, 0.0,
1.0, 10.0, 0.0);
g_object_set_data(G_OBJECT(controls.lower[i]), "id",
GUINT_TO_POINTER(i));
g_signal_connect_swapped(controls.lower[i], "value-changed",
G_CALLBACK(threshold_changed), &controls);
controls.lower_scale[i]
= gtk_hscale_new(GTK_ADJUSTMENT(controls.lower[i]));
gtk_scale_set_draw_value(GTK_SCALE(controls.lower_scale[i]), FALSE);
gtk_widget_set_size_request(controls.lower_scale[i],
GWY_HSCALE_WIDTH, -1);
gtk_table_attach(GTK_TABLE(table), controls.lower_scale[i],
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.lower_entry[i] = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(controls.lower_entry[i]), 8);
gtk_table_attach(GTK_TABLE(table), controls.lower_entry[i],
2, 3, row, row+1, GTK_FILL, 0, 0, 0);
gwy_widget_set_activate_on_unfocus(controls.lower_entry[i], TRUE);
g_object_set_data(G_OBJECT(controls.lower_entry[i]), "id",
GUINT_TO_POINTER(i));
g_signal_connect_swapped(controls.lower_entry[i], "activate",
G_CALLBACK(threshold_activated), &controls);
controls.lower_units[i] = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.lower_units[i]), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.lower_units[i],
3, 4, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.upper_label[i] = gtk_label_new(_("Upper threshold:"));
gtk_misc_set_alignment(GTK_MISC(controls.upper_label[i]), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.upper_label[i],
0, 1, row, row+1, GTK_FILL, 0, 0, 0);
controls.upper[i] = gtk_adjustment_new(0.0, 0.0, 0.0,
1.0, 10.0, 0.0);
g_object_set_data(G_OBJECT(controls.upper[i]), "id",
GUINT_TO_POINTER(i | IS_UPPER));
g_signal_connect_swapped(controls.upper[i], "value-changed",
G_CALLBACK(threshold_changed), &controls);
controls.upper_scale[i]
= gtk_hscale_new(GTK_ADJUSTMENT(controls.upper[i]));
gtk_scale_set_draw_value(GTK_SCALE(controls.upper_scale[i]), FALSE);
gtk_widget_set_size_request(controls.upper_scale[i],
GWY_HSCALE_WIDTH, -1);
gtk_table_attach(GTK_TABLE(table), controls.upper_scale[i],
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.upper_entry[i] = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(controls.upper_entry[i]), 8);
gtk_table_attach(GTK_TABLE(table), controls.upper_entry[i],
2, 3, row, row+1, GTK_FILL, 0, 0, 0);
gwy_widget_set_activate_on_unfocus(controls.upper_entry[i], TRUE);
g_object_set_data(G_OBJECT(controls.upper_entry[i]), "id",
GUINT_TO_POINTER(i | IS_UPPER));
g_signal_connect_swapped(controls.upper_entry[i], "activate",
G_CALLBACK(threshold_activated), &controls);
controls.upper_units[i] = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.upper_units[i]), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.upper_units[i],
3, 4, row, row+1, GTK_FILL, 0, 0, 0);
row++;
}
for (i = 0; i < NQUANTITIES; i++) {
GwyInventory *inventory;
GwyGrainValue *gvalue;
inventory = gwy_grain_values();
gvalue = gwy_inventory_get_item(inventory, args->ranges[i].quantity);
set_up_quantity(&controls, gvalue, i);
}
logical_op_changed(GTK_COMBO_BOX(controls.logical_op), &controls);
/* finished initializing, allow instant updates */
controls.in_init = FALSE;
gfilter_invalidate(&controls);
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
args->expanded = gwy_grain_value_tree_view_get_expanded_groups
(GTK_TREE_VIEW(controls.values));
for (i = 0; i < NQUANTITIES; i++)
gwy_si_unit_value_format_free(controls.vf[i]);
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
g_object_unref(controls.mydata);
gfilter_save_args(gwy_app_settings_get(), args);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_PREVIEW:
preview(&controls);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
for (i = 0; i < NQUANTITIES; i++)
gwy_si_unit_value_format_free(controls.vf[i]);
args->expanded = gwy_grain_value_tree_view_get_expanded_groups
(GTK_TREE_VIEW(controls.values));
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
gfilter_save_args(gwy_app_settings_get(), args);
if (controls.computed) {
mfield = gwy_container_get_object_by_name(controls.mydata, "/0/mask");
gwy_app_undo_qcheckpointv(data, 1, &mquark);
gwy_container_set_object(data, mquark, mfield);
g_object_unref(controls.mydata);
}
else {
g_object_unref(controls.mydata);
run_noninteractive(args, data, controls.mask, mquark);
}
gwy_app_channel_log_add_proc(data, id, id);
}
// virtual
void CustomRuler::paintEvent(QPaintEvent *e)
{
QStylePainter p(this);
const QRect &paintRect = e->rect();
p.setClipRect(paintRect);
p.fillRect(paintRect, palette().midlight().color());
// Draw zone background
const int zoneStart = (int)(m_zoneStart * m_factor);
const int zoneEnd = (int)((m_zoneEnd + 1)* m_factor);
int zoneHeight = LABEL_SIZE * 0.8;
p.fillRect(zoneStart - m_offset, MAX_HEIGHT - zoneHeight + 1, zoneEnd - zoneStart, zoneHeight - 1, m_zoneBG);
double f, fend;
const int offsetmax = ((paintRect.right() + m_offset) / FRAME_SIZE + 1) * FRAME_SIZE;
int offsetmin;
p.setPen(palette().text().color());
// draw time labels
if (paintRect.y() < LABEL_SIZE) {
offsetmin = (paintRect.left() + m_offset) / m_textSpacing;
offsetmin = offsetmin * m_textSpacing;
for (f = offsetmin; f < offsetmax; f += m_textSpacing) {
QString lab;
if (KdenliveSettings::frametimecode())
lab = QString::number((int)(f / m_factor + 0.5));
else
lab = m_timecode.getTimecodeFromFrames((int)(f / m_factor + 0.5));
p.drawText(f - m_offset + 2, LABEL_SIZE, lab);
}
}
p.setPen(palette().dark().color());
offsetmin = (paintRect.left() + m_offset) / littleMarkDistance;
offsetmin = offsetmin * littleMarkDistance;
// draw the little marks
fend = m_scale * littleMarkDistance;
if (fend > 5) {
QLineF l(offsetmin - m_offset, LITTLE_MARK_X, offsetmin - m_offset, MAX_HEIGHT);
for (f = offsetmin; f < offsetmax; f += fend) {
l.translate(fend, 0);
p.drawLine(l);
}
}
offsetmin = (paintRect.left() + m_offset) / mediumMarkDistance;
offsetmin = offsetmin * mediumMarkDistance;
// draw medium marks
fend = m_scale * mediumMarkDistance;
if (fend > 5) {
QLineF l(offsetmin - m_offset - fend, MIDDLE_MARK_X, offsetmin - m_offset - fend, MAX_HEIGHT);
for (f = offsetmin - fend; f < offsetmax + fend; f += fend) {
l.translate(fend, 0);
p.drawLine(l);
}
}
offsetmin = (paintRect.left() + m_offset) / bigMarkDistance;
offsetmin = offsetmin * bigMarkDistance;
// draw big marks
fend = m_scale * bigMarkDistance;
if (fend > 5) {
QLineF l(offsetmin - m_offset, LABEL_SIZE, offsetmin - m_offset, MAX_HEIGHT);
for (f = offsetmin; f < offsetmax; f += fend) {
l.translate(fend, 0);
p.drawLine(l);
}
}
// draw zone handles
if (zoneStart > 0) {
QPolygon pa(4);
pa.setPoints(4, zoneStart - m_offset + FONT_WIDTH / 2, MAX_HEIGHT - zoneHeight, zoneStart - m_offset, MAX_HEIGHT - zoneHeight, zoneStart - m_offset, MAX_HEIGHT, zoneStart - m_offset + FONT_WIDTH / 2, MAX_HEIGHT);
p.drawPolyline(pa);
}
if (zoneEnd > 0) {
QColor center(Qt::white);
center.setAlpha(150);
QRect rec(zoneStart - m_offset + (zoneEnd - zoneStart - zoneHeight) / 2 + 2, MAX_HEIGHT - zoneHeight + 2, zoneHeight - 4, zoneHeight - 4);
p.fillRect(rec, center);
p.drawRect(rec);
QPolygon pa(4);
pa.setPoints(4, zoneEnd - m_offset - FONT_WIDTH / 2, MAX_HEIGHT - zoneHeight, zoneEnd - m_offset, MAX_HEIGHT - zoneHeight, zoneEnd - m_offset, MAX_HEIGHT, zoneEnd - m_offset - FONT_WIDTH / 2, MAX_HEIGHT );
p.drawPolyline(pa);
}
// draw Rendering preview zones
if (!m_hidePreview) {
p.setPen(palette().dark().color());
p.drawLine(paintRect.left(), MAX_HEIGHT, paintRect.right(), MAX_HEIGHT);
p.fillRect(paintRect.left(), MAX_HEIGHT + 1, paintRect.width(), PREVIEW_SIZE - 1, palette().mid().color());
QColor preview(Qt::green);
preview.setAlpha(120);
double chunkWidth = KdenliveSettings::timelinechunks() * m_factor;
foreach(int frame, m_renderingPreviews) {
double xPos = frame * m_factor - m_offset;
if (xPos + chunkWidth < paintRect.x() || xPos > paintRect.right())
continue;
QRectF rec(xPos, MAX_HEIGHT + 1, chunkWidth, PREVIEW_SIZE - 1);
p.fillRect(rec, preview);
}
void BilateralDialog::previewButtonPressed() {
emit preview(ui->diameterSlider->value(),ui->sigmaCSlider->value(),ui->sigmaSSlider->value());
}
void DekeystoningWidget::setPreview(QPixmap pixmap)
{
previewPixmap = pixmap;
if (preview())
ui->view->setPixmap(pixmap);
}
void PopupAppearance::onCurrentIndexChanged(int)
{
setModified(true);
preview();
}
int PCB_EDITOR_CONTROL::PlaceModule( const TOOL_EVENT& aEvent )
{
MODULE* module = NULL;
KIGFX::VIEW* view = getView();
KIGFX::VIEW_CONTROLS* controls = getViewControls();
BOARD* board = getModel<BOARD>();
// Add a VIEW_GROUP that serves as a preview for the new item
KIGFX::VIEW_GROUP preview( view );
view->Add( &preview );
m_toolMgr->RunAction( COMMON_ACTIONS::selectionClear, true );
controls->ShowCursor( true );
controls->SetSnapping( true );
Activate();
m_frame->SetToolID( ID_PCB_MODULE_BUTT, wxCURSOR_HAND, _( "Add footprint" ) );
// Main loop: keep receiving events
while( OPT_TOOL_EVENT evt = Wait() )
{
VECTOR2I cursorPos = controls->GetCursorPosition();
if( evt->IsCancel() || evt->IsActivate() )
{
if( module )
{
board->Delete( module ); // it was added by LoadModuleFromLibrary()
module = NULL;
preview.Clear();
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
controls->ShowCursor( true );
}
else
break;
if( evt->IsActivate() ) // now finish unconditionally
break;
}
else if( module && evt->Category() == TC_COMMAND )
{
if( evt->IsAction( &COMMON_ACTIONS::rotate ) )
{
module->Rotate( module->GetPosition(), m_frame->GetRotationAngle() );
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
}
else if( evt->IsAction( &COMMON_ACTIONS::flip ) )
{
module->Flip( module->GetPosition() );
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
}
}
else if( evt->IsClick( BUT_LEFT ) )
{
if( !module )
{
// Pick the module to be placed
module = m_frame->LoadModuleFromLibrary( wxEmptyString,
m_frame->Prj().PcbFootprintLibs(),
true, NULL );
if( module == NULL )
continue;
module->SetPosition( wxPoint( cursorPos.x, cursorPos.y ) );
// Add all the drawable parts to preview
preview.Add( module );
module->RunOnChildren( boost::bind( &KIGFX::VIEW_GROUP::Add, &preview, _1 ) );
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
}
else
{
// Place the selected module
module->RunOnChildren( boost::bind( &KIGFX::VIEW::Add, view, _1 ) );
view->Add( module );
module->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
m_frame->OnModify();
m_frame->SaveCopyInUndoList( module, UR_NEW );
// Remove from preview
preview.Remove( module );
module->RunOnChildren( boost::bind( &KIGFX::VIEW_GROUP::Remove, &preview, _1 ) );
module = NULL; // to indicate that there is no module that we currently modify
}
bool placing = ( module != NULL );
controls->SetAutoPan( placing );
controls->CaptureCursor( placing );
controls->ShowCursor( !placing );
}
else if( module && evt->IsMotion() )
{
module->SetPosition( wxPoint( cursorPos.x, cursorPos.y ) );
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
}
}
controls->ShowCursor( false );
controls->SetSnapping( false );
controls->SetAutoPan( false );
controls->CaptureCursor( false );
view->Remove( &preview );
m_frame->SetToolID( ID_NO_TOOL_SELECTED, wxCURSOR_DEFAULT, wxEmptyString );
return 0;
}
KIconConfig::KIconConfig(const KComponentData &inst, QWidget *parent)
: KCModule(inst, parent)
{
QGridLayout *top = new QGridLayout(this );
top->setColumnStretch(0, 1);
top->setColumnStretch(1, 1);
// Use of Icon at (0,0) - (1, 0)
QGroupBox *gbox = new QGroupBox(i18n("Use of Icon"), this);
top->addWidget(gbox, 0, 0, 2, 1);
QBoxLayout *g_vlay = new QVBoxLayout(gbox);
mpUsageList = new QListWidget(gbox);
connect(mpUsageList, SIGNAL(currentRowChanged(int)), SLOT(slotUsage(int)));
g_vlay->addWidget(mpUsageList);
KSeparator *sep = new KSeparator( Qt::Horizontal, this );
top->addWidget(sep, 1, 1);
// Preview at (2,0) - (2, 1)
QGridLayout *g_lay = new QGridLayout();
g_lay->setSpacing( 0);
top->addLayout(g_lay, 2, 0, 1, 2 );
g_lay->addItem(new QSpacerItem(0, fontMetrics().lineSpacing()), 0, 0);
QPushButton *push;
push = addPreviewIcon(0, i18nc("@label The icon rendered by default", "Default"), this, g_lay);
connect(push, SIGNAL(clicked()), SLOT(slotEffectSetup0()));
push = addPreviewIcon(1, i18nc("@label The icon rendered as active", "Active"), this, g_lay);
connect(push, SIGNAL(clicked()), SLOT(slotEffectSetup1()));
push = addPreviewIcon(2, i18nc("@label The icon rendered as disabled", "Disabled"), this, g_lay);
connect(push, SIGNAL(clicked()), SLOT(slotEffectSetup2()));
m_pTab1 = new QWidget(this);
m_pTab1->setObjectName( QLatin1String("General Tab" ));
top->addWidget(m_pTab1, 0, 1);
QGridLayout *grid = new QGridLayout(m_pTab1);
grid->setColumnStretch(1, 1);
grid->setColumnStretch(2, 1);
// Size
QLabel *lbl = new QLabel(i18n("Size:"), m_pTab1);
lbl->setFixedSize(lbl->sizeHint());
grid->addWidget(lbl, 0, 0, Qt::AlignLeft);
mpSizeBox = new QComboBox(m_pTab1);
connect(mpSizeBox, SIGNAL(activated(int)), SLOT(slotSize(int)));
lbl->setBuddy(mpSizeBox);
grid->addWidget(mpSizeBox, 0, 1, Qt::AlignLeft);
mpAnimatedCheck = new QCheckBox(i18n("Animate icons"), m_pTab1);
connect(mpAnimatedCheck, SIGNAL(toggled(bool)), SLOT(slotAnimatedCheck(bool)));
grid->addWidget(mpAnimatedCheck, 2, 0, 1, 2, Qt::AlignLeft);
grid->setRowStretch(3, 10);
top->activate();
init();
read();
apply();
preview();
}
void KIconConfig::preview()
{
preview(0);
preview(1);
preview(2);
}
MeasureMarkersWindow::~MeasureMarkersWindow() {
//关闭摄像头
if (mbPlay)
preview();
}
int PCB_EDITOR_CONTROL::PlaceTarget( const TOOL_EVENT& aEvent )
{
KIGFX::VIEW* view = getView();
KIGFX::VIEW_CONTROLS* controls = getViewControls();
BOARD* board = getModel<BOARD>();
PCB_TARGET* target = new PCB_TARGET( board );
// Init the new item attributes
target->SetLayer( Edge_Cuts );
target->SetWidth( board->GetDesignSettings().m_EdgeSegmentWidth );
target->SetSize( Millimeter2iu( 5 ) );
VECTOR2I cursorPos = controls->GetCursorPosition();
target->SetPosition( wxPoint( cursorPos.x, cursorPos.y ) );
// Add a VIEW_GROUP that serves as a preview for the new item
KIGFX::VIEW_GROUP preview( view );
preview.Add( target );
view->Add( &preview );
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
m_toolMgr->RunAction( COMMON_ACTIONS::selectionClear, true );
controls->SetSnapping( true );
Activate();
m_frame->SetToolID( ID_PCB_MIRE_BUTT, wxCURSOR_PENCIL, _( "Add layer alignment target" ) );
// Main loop: keep receiving events
while( OPT_TOOL_EVENT evt = Wait() )
{
cursorPos = controls->GetCursorPosition();
if( evt->IsCancel() || evt->IsActivate() )
break;
else if( evt->IsAction( &COMMON_ACTIONS::incWidth ) )
{
target->SetWidth( target->GetWidth() + WIDTH_STEP );
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
}
else if( evt->IsAction( &COMMON_ACTIONS::decWidth ) )
{
int width = target->GetWidth();
if( width > WIDTH_STEP )
{
target->SetWidth( width - WIDTH_STEP );
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
}
}
else if( evt->IsClick( BUT_LEFT ) )
{
assert( target->GetSize() > 0 );
assert( target->GetWidth() > 0 );
view->Add( target );
board->Add( target );
target->ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
m_frame->OnModify();
m_frame->SaveCopyInUndoList( target, UR_NEW );
preview.Remove( target );
// Create next PCB_TARGET
target = new PCB_TARGET( *target );
preview.Add( target );
}
else if( evt->IsMotion() )
{
target->SetPosition( wxPoint( cursorPos.x, cursorPos.y ) );
preview.ViewUpdate( KIGFX::VIEW_ITEM::GEOMETRY );
}
}
delete target;
controls->SetSnapping( false );
view->Remove( &preview );
m_frame->SetToolID( ID_NO_TOOL_SELECTED, wxCURSOR_DEFAULT, wxEmptyString );
return 0;
}
KIconEffectSetupDialog::KIconEffectSetupDialog(const Effect &effect,
const Effect &defaultEffect,
const QString &caption, const QImage &image,
QWidget *parent, char *name)
: KDialog( parent ),
mEffect(effect),
mDefaultEffect(defaultEffect),
mExample(image)
{
setObjectName( name );
setModal( true );
setCaption( caption );
setButtons( Default|Ok|Cancel );
mpEffect = new KIconEffect;
QLabel *lbl;
QGroupBox *frame;
QGridLayout *grid;
QWidget *page = new QWidget(this);
setMainWidget(page);
QGridLayout *top = new QGridLayout(page);
top->setMargin(0);
top->setColumnStretch(0,1);
top->setColumnStretch(1,2);
top->setRowStretch(1,1);
lbl = new QLabel(i18n("&Effect:"), page);
top->addWidget(lbl, 0, 0, Qt::AlignLeft);
mpEffectBox = new QListWidget(page);
mpEffectBox->addItem(i18n("No Effect"));
mpEffectBox->addItem(i18n("To Gray"));
mpEffectBox->addItem(i18n("Colorize"));
mpEffectBox->addItem(i18n("Gamma"));
mpEffectBox->addItem(i18n("Desaturate"));
mpEffectBox->addItem(i18n("To Monochrome"));
connect(mpEffectBox, SIGNAL(currentRowChanged(int)), SLOT(slotEffectType(int)));
top->addWidget(mpEffectBox, 1, 0, 2, 1, Qt::AlignLeft);
lbl->setBuddy(mpEffectBox);
mpSTCheck = new QCheckBox(i18n("&Semi-transparent"), page);
connect(mpSTCheck, SIGNAL(toggled(bool)), SLOT(slotSTCheck(bool)));
top->addWidget(mpSTCheck, 3, 0, Qt::AlignLeft);
frame = new QGroupBox(i18n("Preview"), page);
top->addWidget(frame, 0, 1, 2, 1);
grid = new QGridLayout(frame);
grid->addItem(new QSpacerItem(0, fontMetrics().lineSpacing()), 0, 0);
grid->setRowStretch(1, 1);
mpPreview = new QLabel(frame);
mpPreview->setAlignment(Qt::AlignCenter);
mpPreview->setMinimumSize(105, 105);
grid->addWidget(mpPreview, 1, 0);
mpEffectGroup = new QGroupBox(i18n("Effect Parameters"), page);
top->addWidget(mpEffectGroup, 2, 1, 2, 1);
QFormLayout *form = new QFormLayout(mpEffectGroup);
mpEffectSlider = new QSlider(Qt::Horizontal, mpEffectGroup);
mpEffectSlider->setMinimum(0);
mpEffectSlider->setMaximum(100);
mpEffectSlider->setPageStep(5);
connect(mpEffectSlider, SIGNAL(valueChanged(int)), SLOT(slotEffectValue(int)));
form->addRow(i18n("&Amount:"), mpEffectSlider);
mpEffectLabel = static_cast<QLabel *>(form->labelForField(mpEffectSlider));
mpEColButton = new KColorButton(mpEffectGroup);
connect(mpEColButton, SIGNAL(changed(const QColor &)),
SLOT(slotEffectColor(const QColor &)));
form->addRow(i18n("Co&lor:"), mpEColButton);
mpEffectColor = static_cast<QLabel *>(form->labelForField(mpEColButton));
mpECol2Button = new KColorButton(mpEffectGroup);
connect(mpECol2Button, SIGNAL(changed(const QColor &)),
SLOT(slotEffectColor2(const QColor &)));
form->addRow(i18n("&Second color:"), mpECol2Button);
mpEffectColor2 = static_cast<QLabel *>(form->labelForField(mpECol2Button));
init();
preview();
}
void EFX::preview(QVector <QPoint>& polygon) const
{
preview(polygon, Function::Forward, 0);
}
void KIconEffectSetupDialog::slotEffectValue(int value)
{
mEffect.value = 0.01 * value;
preview();
}
static void
deposit_dialog(DepositArgs *args,
GwyContainer *data,
GwyDataField *dfield,
gint id)
{
GtkWidget *dialog, *table, *hbox, *label, *pivot;
DepositControls controls;
gint response;
GwyPixmapLayer *layer;
gint row, newid;
GwyDataField *rfield;
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Deposit spherical particles"), NULL, 0,
NULL);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog),
gwy_stock_like_button_new(_("_Start"),
GTK_STOCK_EXECUTE),
RESPONSE_PREVIEW);
gtk_dialog_add_button(GTK_DIALOG(dialog), _("_Reset"), RESPONSE_RESET);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
controls.dialog = dialog;
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.mydata = gwy_container_duplicate_by_prefix(data,
"/0/data/",
"/0/base/palette",
"/0/base/range-type",
"/0/base/", NULL);
gwy_container_set_object_by_name(controls.mydata, "/0/data", gwy_data_field_duplicate(dfield));
controls.old_dfield = gwy_data_field_duplicate(dfield);
controls.view = gwy_data_view_new(controls.mydata);
layer = gwy_layer_basic_new();
g_object_set(layer,
"data-key", "/0/data",
"gradient-key", "/0/base/palette",
"range-type-key", "/0/base/range-type",
"min-max-key", "/0/base",
NULL);
gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.view), "/0/data");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer);
gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE);
gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4);
table = gtk_table_new(10, 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(hbox), table, TRUE, TRUE, 4);
row = 0;
gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Deposition parameters:")),
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
table_attach_threshold(table, &row, _("_Size"),
&controls.size, args->size,
&controls);
pivot = gwy_table_hscale_get_scale(controls.size);
controls.value_size = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.value_size), 1.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.value_size,
2, 3, row, row+1, GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(controls.size, "value-changed",
G_CALLBACK(update_threshold_size), &controls);
gwy_widget_sync_sensitivity(pivot, controls.value_size);
controls.format_size
= gwy_data_field_get_value_format_z(dfield, GWY_SI_UNIT_FORMAT_VFMARKUP,
NULL);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_label_set_markup(GTK_LABEL(label), controls.format_size->units);
gtk_table_attach(GTK_TABLE(table), label,
3, 4, row, row+1, GTK_FILL, 0, 0, 0);
gwy_widget_sync_sensitivity(pivot, label);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
/*
table_attach_threshold(table, &row, _("_Distribution width"),
&controls.width, args->width,
&controls);
pivot = gwy_table_hscale_get_scale(controls.width);
controls.value_width = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.value_width), 1.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.value_width,
2, 3, row, row+1, GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(controls.width, "value-changed",
G_CALLBACK(update_threshold_width), &controls);
gwy_widget_sync_sensitivity(pivot, controls.value_width);
controls.format_width
= gwy_data_field_get_value_format_z(dfield, GWY_SI_UNIT_FORMAT_VFMARKUP,
NULL);
label = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_label_set_markup(GTK_LABEL(label), controls.format_width->units);
gtk_table_attach(GTK_TABLE(table), label,
3, 4, row, row+1, GTK_FILL, 0, 0, 0);
gwy_widget_sync_sensitivity(pivot, label);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
*/
table_attach_threshold(table, &row, _("_Coverage:"),
&controls.coverage, args->coverage,
&controls);
table_attach_threshold(table, &row, _("_Revise after settle"),
&controls.revise, args->revise,
&controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
deposit_invalidate(&controls);
update_threshold_size(&controls);
//update_threshold_width(&controls);
/* finished initializing, allow instant updates */
controls.in_init = FALSE;
/* show initial preview if instant updates are on */
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
deposit_dialog_update_values(&controls, args);
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
g_object_unref(controls.mydata);
gwy_si_unit_value_format_free(controls.format_size);
//gwy_si_unit_value_format_free(controls.format_width);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
*args = deposit_defaults;
deposit_dialog_update_controls(&controls, args);
controls.in_init = TRUE;
preview(&controls, args);
controls.in_init = FALSE;
break;
case RESPONSE_PREVIEW:
deposit_dialog_update_values(&controls, args);
preview(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
deposit_dialog_update_values(&controls, args);
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
gwy_si_unit_value_format_free(controls.format_size);
//gwy_si_unit_value_format_free(controls.format_width);
if (args->computed) {
rfield = gwy_container_get_object_by_name(controls.mydata, "/0/data");
newid = gwy_app_data_browser_add_data_field(rfield,
data, TRUE);
gwy_app_sync_data_items(data, data,
id, newid, FALSE,
GWY_DATA_ITEM_GRADIENT,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_REAL_SQUARE,
GWY_DATA_ITEM_SELECTIONS,
0);
gwy_app_set_data_field_title(data, newid, _("Particles"));
g_object_unref(controls.mydata);
}
}
void KIconEffectSetupDialog::slotEffectColor2(const QColor &col)
{
mEffect.color2 = col;
preview();
}
void DekeystoningWidget::setPixmap(QPixmap pixmap)
{
inputPixmap = pixmap;
if (!preview())
ui->view->setPixmap(pixmap);
}
void KIconEffectSetupDialog::slotSTCheck(bool b)
{
mEffect.transparent = b;
preview();
}
static void
facets_dialog(FacetsArgs *args,
GwyContainer *data,
GwyContainer *fdata,
GwyDataField *dfield,
GwyDataField *mfield,
gint id,
GQuark mquark)
{
GtkWidget *dialog, *table, *hbox, *hbox2, *vbox, *label, *scale, *button;
GtkWidget *spin;
FacetsControls controls;
enum {
RESPONSE_RESET = 1,
RESPONSE_PREVIEW = 2
};
gint response;
GwyPixmapLayer *layer;
GwyVectorLayer *vlayer;
GwySelection *selection;
gint row;
memset(&controls, 0, sizeof(FacetsControls));
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Mark Facets"),
NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
_("_Mark"), RESPONSE_PREVIEW,
_("_Reset"), RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
controls.dialog = dialog;
/* Shallow-copy stuff to temporary container */
controls.fdata = fdata;
controls.mydata = gwy_container_new();
gwy_container_set_object_by_name(controls.mydata, "/0/data", dfield);
gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
GWY_DATA_ITEM_RANGE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_REAL_SQUARE,
0);
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.view = gwy_data_view_new(controls.mydata);
layer = gwy_layer_basic_new();
g_object_set(layer,
"data-key", "/0/data",
"gradient-key", "/0/base/palette",
"range-type-key", "/0/base/range-type",
"min-max-key", "/0/base",
NULL);
gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.view), "/0/data");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer);
gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE);
vlayer = g_object_new(g_type_from_name("GwyLayerPoint"), NULL);
gwy_vector_layer_set_selection_key(vlayer, "/0/select/pointer");
gwy_data_view_set_top_layer(GWY_DATA_VIEW(controls.view), vlayer);
selection = gwy_vector_layer_ensure_selection(vlayer);
g_signal_connect(selection, "changed",
G_CALLBACK(preview_selection_updated), &controls);
gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
hbox2 = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
/* Slope view */
controls.fview = gwy_data_view_new(controls.fdata);
gtk_box_pack_start(GTK_BOX(hbox2), controls.fview, FALSE, FALSE, 0);
layer = gwy_layer_basic_new();
gwy_pixmap_layer_set_data_key(layer, "/0/data");
gwy_layer_basic_set_gradient_key(GWY_LAYER_BASIC(layer), "/0/base/palette");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.fview),
layer);
vlayer = g_object_new(g_type_from_name("GwyLayerPoint"), NULL);
gwy_vector_layer_set_selection_key(vlayer, "/0/select/pointer");
gwy_data_view_set_top_layer(GWY_DATA_VIEW(controls.fview),
GWY_VECTOR_LAYER(vlayer));
selection = gwy_vector_layer_ensure_selection(vlayer);
g_signal_connect(selection, "changed",
G_CALLBACK(facet_view_selection_updated), &controls);
/* Info table */
table = gtk_table_new(7, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(hbox2), table, TRUE, TRUE, 4);
row = 0;
label = gwy_label_new_header(gwy_sgettext("noun|Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.theta_label = add_angle_label(table, _("θ:"), &row);
controls.phi_label = add_angle_label(table, _("φ:"), &row);
button = gtk_button_new_with_mnemonic(_("_Find Maximum"));
gtk_table_attach(GTK_TABLE(table), button,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(facet_view_reset_maximum), &controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
label = gwy_label_new_header(_("Mean Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.mtheta_label = add_angle_label(table, _("θ:"), &row);
controls.mphi_label = add_angle_label(table, _("φ:"), &row);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new_with_mnemonic(_("Facet plane size:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.kernel_size = gtk_adjustment_new(args->kernel_size,
0.0, MAX_PLANE_SIZE, 1.0, 1.0, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.kernel_size), 0.0, 0);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), spin);
gtk_table_attach(GTK_TABLE(table), spin,
0, 1, row, row+1, 0, 0, 0, 0);
g_signal_connect(controls.kernel_size, "value-changed",
G_CALLBACK(facet_view_recompute), &controls);
row++;
table = gtk_table_new(9, 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 4);
row = 0;
controls.tolerance = gtk_adjustment_new(args->tolerance*180.0/G_PI,
0.0, 15.0, 0.01, 0.1, 0);
scale = gwy_table_attach_hscale(table, row++, _("_Tolerance:"), _("deg"),
controls.tolerance, 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(scale), 3);
g_signal_connect(controls.tolerance, "value-changed",
G_CALLBACK(facets_tolerance_changed), &controls);
controls.color_button = gwy_color_button_new();
gwy_color_button_set_use_alpha(GWY_COLOR_BUTTON(controls.color_button),
TRUE);
load_mask_color(controls.color_button,
gwy_data_view_get_data(GWY_DATA_VIEW(controls.view)));
gwy_table_attach_hscale(table, row++, _("_Mask color:"), NULL,
GTK_OBJECT(controls.color_button),
GWY_HSCALE_WIDGET_NO_EXPAND);
g_signal_connect(controls.color_button, "clicked",
G_CALLBACK(mask_color_change_cb), &controls);
if (!gwy_si_unit_equal(gwy_data_field_get_si_unit_xy(dfield),
gwy_data_field_get_si_unit_z(dfield))) {
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new(_("Warning: Lateral and value units differ. "
"Angles are not physically meaningful."));
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
}
facets_invalidate(&controls);
gtk_widget_show_all(dialog);
facet_view_select_angle(&controls, args->theta0, args->phi0);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
g_object_unref(controls.mydata);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
args->tolerance = facets_defaults.tolerance;
args->kernel_size = facets_defaults.kernel_size;
facets_dialog_update_controls(&controls, args);
break;
case RESPONSE_PREVIEW:
preview(&controls, args);
update_average_angle(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
if (controls.computed) {
mfield = gwy_container_get_object_by_name(controls.mydata, "/0/mask");
gwy_app_undo_qcheckpointv(data, 1, &mquark);
gwy_container_set_object(data, mquark, mfield);
g_object_unref(controls.mydata);
}
else {
g_object_unref(controls.mydata);
run_noninteractive(args, data, fdata, dfield, mfield, mquark);
}
}
void KIconEffectSetupDialog::slotDefault()
{
mEffect = mDefaultEffect;
init();
preview();
}
