static void method_changed_cb (GtkButton *button, gpointer user_data) { GthFileToolGrayscale *self = user_data; apply_changes (self); }
void edit_main_rep::print (url name, bool conform, int first, int last) { if (inside ("screens")) { tree style= copy (get_style ()); tree init = copy (get_init ()); tree t = copy (subtree (et, rp)); call ("dynamic-make-slides"); apply_changes (); print_bis (name, conform, first, last); set_style (style); set_init (init); assign (rp, t); apply_changes (); } else print_bis (name, conform, first, last); }
void edit_interface_rep::handle_repaint (SI x1, SI y1, SI x2, SI y2) { if (is_nil (eb)) apply_changes (); if (env_change != 0) { system_warning ("Invalid situation (" * as_string (env_change) * ")", "(edit_interface_rep::handle_repaint)"); return; } /* // In the past, we used the code below in order to hide the trace of // a moving cursor. This code is now incorrect, because the rectangle // (x1, y1)--(x2, y2) does not correspond to the repaint region clipping. // Nevertheless, the code seems no longer necessary. In case it would be, // it should be moved somewhere inside the internal repaint routines. SI extra= 3 * get_init_int (FONT_BASE_SIZE) * PIXEL / (2*sfactor); SI X1= (x1-extra) * sfactor, Y1= (y1-extra) * sfactor; SI X2= (x2+extra) * sfactor, Y2= (y2+extra) * sfactor; draw_with_stored (rectangle (X1, Y1, X2, Y2)); */ // cout << "Repainting\n"; draw_with_stored (rectangle (x1, y1, x2, y2) * sfactor); if (last_change-last_update > 0) last_change = texmacs_time (); // cout << "Repainted\n"; }
/* called when the ok button is clicked. */ static void ok_cb (GtkWidget *widget, DialogData *data) { apply_changes (data, data->image, data->image, FALSE, FALSE); gtk_widget_destroy (data->dialog); }
/** * apply_cb * @w: widget * @data: callback data * * Description: * handles apply button events * * Returns: * TRUE if the event was handled **/ static void apply_cb (GtkWidget * w, gpointer data) { apply_changes (); gtk_widget_destroy (propbox); propbox = NULL; }
int cmd_playlist_add_track(int argc, char **argv) { sp_link *plink, *tlink; sp_track *t; sp_playlist *pl; int i; struct pl_update_work *puw; if(argc < 4) { printf("add [playlist uri] [position] [track uri] <[track uri]>...\n"); return 1; } plink = sp_link_create_from_string(argv[1]); if (!plink) { fprintf(stderr, "%s is not a spotify link\n", argv[1]); return -1; } if(sp_link_type(plink) != SP_LINKTYPE_PLAYLIST) { fprintf(stderr, "%s is not a playlist link\n", argv[1]); sp_link_release(plink); return -1; } puw = malloc(sizeof(struct pl_update_work)); puw->position = atoi(argv[2]); puw->tracks = malloc(sizeof(sp_track *) * argc - 3); puw->num_tracks = 0; for(i = 0; i < argc - 3; i++) { tlink = sp_link_create_from_string(argv[i + 3]); if(tlink == NULL) { fprintf(stderr, "%s is not a spotify link, skipping\n", argv[i + 3]); continue; } if(sp_link_type(tlink) != SP_LINKTYPE_TRACK) { fprintf(stderr, "%s is not a track link, skipping\n", argv[i + 3]); continue; } t = sp_link_as_track(tlink); sp_track_add_ref(t); puw->tracks[puw->num_tracks++] = t; sp_link_release(tlink); } pl = sp_playlist_create(g_session, plink); if(!apply_changes(pl, puw)) { // Changes applied directly, we're done sp_playlist_release(pl); sp_link_release(plink); return 1; } fprintf(stderr, "Playlist not yet loaded, waiting...\n"); sp_playlist_add_callbacks(pl, &pl_update_callbacks, puw); sp_link_release(plink); return 0; }
static void ok_button_clicked_cb (GtkButton *button, gpointer user_data) { GthFileToolGrayscale *self = user_data; self->priv->apply_to_original = TRUE; apply_changes (self); }
static void pl_state_change(sp_playlist *pl, void *userdata) { struct pl_update_work *puw = userdata; if(apply_changes(pl, puw)) return; sp_playlist_remove_callbacks(pl, &pl_update_callbacks, puw); sp_playlist_release(pl); cmd_done(); }
static void destroy_cb (GtkWidget *widget, DialogData *data) { apply_changes (data); gth_browser_set_dialog (data->browser, "preferences", NULL); g_object_unref (data->builder); g_free (data); }
static int tostring(lua_State *L) { Lua_Hstore *strg = lua_touserdata(L, 1); apply_changes(L, strg); if (strg->issync){ lua_pushstring(L, OutputFunctionCall(&hs_type.output, PointerGetDatum(strg->hstore))); }else{ return luaL_error(L, "hstore apply changes failed"); } return 1; }
/** \brief Add or edit a rotor configuration. * \param conf Pointer to a rotator configuration. * * If conf->name is not NULL the widgets will be populated with the data. */ void sat_pref_rot_editor_run(rotor_conf_t * conf) { gint response; gboolean finished = FALSE; /* crate dialog and add contents */ dialog = gtk_dialog_new_with_buttons(_("Edit rotator configuration"), GTK_WINDOW(window), GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLEAR, GTK_RESPONSE_REJECT, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); /* disable OK button to begin with */ gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), GTK_RESPONSE_OK, FALSE); gtk_container_add(GTK_CONTAINER (gtk_dialog_get_content_area(GTK_DIALOG(dialog))), create_editor_widgets(conf)); /* this hacky-thing is to keep the dialog running in case the CLEAR button is plressed. OK and CANCEL will exit the loop */ while (!finished) { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_OK: if (apply_changes(conf)) finished = TRUE; else finished = FALSE; break; case GTK_RESPONSE_REJECT: /* CLEAR */ clear_widgets(); break; default: /* Everything else is considered CANCEL */ finished = TRUE; break; } } gtk_widget_destroy(dialog); }
static void gth_file_tool_adjust_contrast_apply_options (GthFileTool *base) { GthFileToolAdjustContrast *self; self = (GthFileToolAdjustContrast *) base; if (! self->priv->view_original) { self->priv->apply_to_original = TRUE; apply_changes (self); } }
/* called when the preview button is clicked. */ static void preview_cb (GtkWidget *widget, DialogData *data) { GdkPixbuf *preview; preview = gdk_pixbuf_copy (data->image); apply_changes (data, preview, preview, FALSE, TRUE); g_object_unref (preview); data->modified = TRUE; }
static void image_task_completed_cb (GthTask *task, GError *error, gpointer user_data) { GthFileToolAdjustContrast *self = user_data; GthImage *destination_image; self->priv->image_task = NULL; if (self->priv->closing) { g_object_unref (task); gth_image_viewer_page_tool_reset_image (GTH_IMAGE_VIEWER_PAGE_TOOL (self)); return; } if (error != NULL) { if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) apply_changes (self); g_object_unref (task); return; } destination_image = gth_image_task_get_destination (GTH_IMAGE_TASK (task)); if (destination_image == NULL) { g_object_unref (task); return; } cairo_surface_destroy (self->priv->destination); self->priv->destination = gth_image_get_cairo_surface (destination_image); self->priv->last_applied_method = self->priv->method; if (self->priv->apply_to_original) { if (self->priv->destination != NULL) { GtkWidget *window; GtkWidget *viewer_page; window = gth_file_tool_get_window (GTH_FILE_TOOL (self)); viewer_page = gth_browser_get_viewer_page (GTH_BROWSER (window)); gth_image_viewer_page_set_image (GTH_IMAGE_VIEWER_PAGE (viewer_page), self->priv->destination, TRUE); } gth_file_tool_hide_options (GTH_FILE_TOOL (self)); } else { if (! self->priv->view_original) gth_preview_tool_set_image (GTH_PREVIEW_TOOL (self->priv->preview_tool), self->priv->destination); } g_object_unref (task); }
static void filter_grid_activated_cb (GthFilterGrid *filter_grid, int filter_id, gpointer user_data) { GthFileToolAdjustContrast *self = user_data; self->priv->view_original = (filter_id == GTH_FILTER_GRID_NO_FILTER); if (self->priv->view_original) { gth_preview_tool_set_image (GTH_PREVIEW_TOOL (self->priv->preview_tool), self->priv->preview); } else if (filter_id == self->priv->last_applied_method) { gth_preview_tool_set_image (GTH_PREVIEW_TOOL (self->priv->preview_tool), self->priv->destination); } else { self->priv->method = filter_id; apply_changes (self); } }
void edit_interface_rep::handle_keypress (string key, time_t t) { bool started= false; #ifdef USE_EXCEPTIONS try { #endif if (DEBUG_KEYBOARD) { //for (int i=0; i<N(key); i++) // cout << ((int) (unsigned char) key[i]) << " "; //cout << "\n"; debug_keyboard << "Pressed " << key << " at " << t << "\n"; } //time_t t1= texmacs_time (); if (is_nil (eb)) apply_changes (); start_editing (); started= true; string zero= "a"; zero[0]= '\0'; string gkey= replace (key, zero, "<#0>"); call ("keyboard-press", object (gkey), object ((double) t)); update_focus_loci (); if (!is_nil (focus_ids)) call ("link-follow-ids", object (focus_ids), object ("focus")); notify_change (THE_DECORATIONS); end_editing (); //time_t t2= texmacs_time (); //if (t2 - t1 >= 10) cout << "handle_keypress took " << t2-t1 << "ms\n"; #ifdef USE_EXCEPTIONS } catch (string msg) { if (started) { cancel_editing (); interrupt_shortcut (); } } handle_exceptions (); #endif }
void dlg_hue_saturation (GthWindow *window) { DialogData *data; GtkWidget *ok_button; GtkWidget *reset_button; GtkWidget *cancel_button; GtkWidget *preview_button; GtkWidget *hbox; GtkWidget *reset_image; GdkPixbuf *image; int image_width, image_height; int preview_width, preview_height; data = g_new0 (DialogData, 1); data->window = window; data->gui = glade_xml_new (GTHUMB_GLADEDIR "/" GLADE_FILE, NULL, NULL); if (! data->gui) { g_warning ("Could not find " GLADE_FILE "\n"); g_free (data); return; } /* Get the widgets. */ data->dialog = glade_xml_get_widget (data->gui, "hue_saturation_dialog"); data->bc_preview_image = glade_xml_get_widget (data->gui, "hl_preview_image"); ok_button = glade_xml_get_widget (data->gui, "hl_ok_button"); reset_button = glade_xml_get_widget (data->gui, "hl_reset_button"); cancel_button = glade_xml_get_widget (data->gui, "hl_cancel_button"); preview_button = glade_xml_get_widget (data->gui, "hl_preview_button"); hbox = glade_xml_get_widget (data->gui, "hl_hue_hbox"); data->bc_hue_hscale = gimp_scale_entry_new (hbox, 0.0, -180.0, 180.0, 1.0, 15.0); hbox = glade_xml_get_widget (data->gui, "hl_lightness_hbox"); data->bc_lightness_hscale = gimp_scale_entry_new (hbox, 0.0, -100.0, 100.0, 1.0, 10.0); hbox = glade_xml_get_widget (data->gui, "hl_saturation_hbox"); data->bc_saturation_hscale = gimp_scale_entry_new (hbox, 0.0, -100.0, 100.0, 1.0, 10.0); data->viewer = gth_window_get_image_viewer (window); reset_image = glade_xml_get_widget (data->gui, "hl_reset_image"); gtk_image_set_from_stock (GTK_IMAGE (reset_image), GTHUMB_STOCK_RESET, GTK_ICON_SIZE_MENU); /**/ image = image_viewer_get_current_pixbuf (data->viewer); data->image = gdk_pixbuf_copy (image); image_width = gdk_pixbuf_get_width (image); image_height = gdk_pixbuf_get_height (image); preview_width = image_width; preview_height = image_height; scale_keepping_ratio (&preview_width, &preview_height, PREVIEW_SIZE, PREVIEW_SIZE); data->orig_pixbuf = gdk_pixbuf_scale_simple (image, preview_width, preview_height, GDK_INTERP_BILINEAR); data->new_pixbuf = gdk_pixbuf_copy (data->orig_pixbuf); gtk_image_set_from_pixbuf (GTK_IMAGE (data->bc_preview_image), data->new_pixbuf); /* Set widgets data. */ /* Set the signals handlers. */ g_signal_connect (G_OBJECT (data->dialog), "destroy", G_CALLBACK (destroy_cb), data); g_signal_connect (G_OBJECT (cancel_button), "clicked", G_CALLBACK (cancel_cb), data); g_signal_connect (G_OBJECT (ok_button), "clicked", G_CALLBACK (ok_cb), data); g_signal_connect (G_OBJECT (reset_button), "clicked", G_CALLBACK (reset_cb), data); g_signal_connect (G_OBJECT (preview_button), "clicked", G_CALLBACK (preview_cb), data); /* -- */ g_signal_connect (G_OBJECT (data->bc_hue_hscale), "value_changed", G_CALLBACK (range_value_changed), data); g_signal_connect (G_OBJECT (data->bc_lightness_hscale), "value_changed", G_CALLBACK (range_value_changed), data); g_signal_connect (G_OBJECT (data->bc_saturation_hscale), "value_changed", G_CALLBACK (range_value_changed), data); /* Run dialog. */ gtk_window_set_transient_for (GTK_WINDOW (data->dialog), GTK_WINDOW (window)); gtk_window_set_modal (GTK_WINDOW (data->dialog), TRUE); gtk_widget_show (data->dialog); apply_changes (data, data->orig_pixbuf, data->new_pixbuf, TRUE, FALSE); }
int main(int argc, const char **argv) { struct partition_metadata *md; const char *prompt; struct partedit_item *items = NULL; struct gmesh mesh; int i, op, nitems, nscroll; int error; if (strcmp(basename(argv[0]), "sade") == 0) sade_mode = 1; TAILQ_INIT(&part_metadata); init_fstab_metadata(); init_dialog(stdin, stdout); if (!sade_mode) dialog_vars.backtitle = __DECONST(char *, "FreeBSD Installer"); dialog_vars.item_help = TRUE; nscroll = i = 0; /* Revert changes on SIGINT */ signal(SIGINT, sigint_handler); if (strcmp(basename(argv[0]), "autopart") == 0) { /* Guided */ prompt = "Please review the disk setup. When complete, press " "the Finish button."; /* Experimental ZFS autopartition support */ if (argc > 1 && strcmp(argv[1], "zfs") == 0) { part_wizard("zfs"); } else { part_wizard("ufs"); } } else if (strcmp(basename(argv[0]), "scriptedpart") == 0) { error = scripted_editor(argc, argv); prompt = NULL; if (error != 0) { end_dialog(); return (error); } } else { prompt = "Create partitions for FreeBSD. No changes will be " "made until you select Finish."; } /* Show the part editor either immediately, or to confirm wizard */ while (prompt != NULL) { dlg_clear(); dlg_put_backtitle(); error = geom_gettree(&mesh); if (error == 0) items = read_geom_mesh(&mesh, &nitems); if (error || items == NULL) { dialog_msgbox("Error", "No disks found. If you need to " "install a kernel driver, choose Shell at the " "installation menu.", 0, 0, TRUE); break; } get_mount_points(items, nitems); if (i >= nitems) i = nitems - 1; op = diskeditor_show("Partition Editor", prompt, items, nitems, &i, &nscroll); switch (op) { case 0: /* Create */ gpart_create((struct gprovider *)(items[i].cookie), NULL, NULL, NULL, NULL, 1); break; case 1: /* Delete */ gpart_delete((struct gprovider *)(items[i].cookie)); break; case 2: /* Modify */ gpart_edit((struct gprovider *)(items[i].cookie)); break; case 3: /* Revert */ gpart_revert_all(&mesh); while ((md = TAILQ_FIRST(&part_metadata)) != NULL) { if (md->fstab != NULL) { free(md->fstab->fs_spec); free(md->fstab->fs_file); free(md->fstab->fs_vfstype); free(md->fstab->fs_mntops); free(md->fstab->fs_type); free(md->fstab); } if (md->newfs != NULL) free(md->newfs); free(md->name); TAILQ_REMOVE(&part_metadata, md, metadata); free(md); } init_fstab_metadata(); break; case 4: /* Auto */ part_wizard("ufs"); break; } error = 0; if (op == 5) { /* Finished */ dialog_vars.ok_label = __DECONST(char *, "Commit"); dialog_vars.extra_label = __DECONST(char *, "Revert & Exit"); dialog_vars.extra_button = TRUE; dialog_vars.cancel_label = __DECONST(char *, "Back"); op = dialog_yesno("Confirmation", "Your changes will " "now be written to disk. If you have chosen to " "overwrite existing data, it will be PERMANENTLY " "ERASED. Are you sure you want to commit your " "changes?", 0, 0); dialog_vars.ok_label = NULL; dialog_vars.extra_button = FALSE; dialog_vars.cancel_label = NULL; if (op == 0 && validate_setup()) { /* Save */ error = apply_changes(&mesh); if (!error) apply_workaround(&mesh); break; } else if (op == 3) { /* Quit */ gpart_revert_all(&mesh); error = -1; break; } } geom_deletetree(&mesh); free(items); }
/** Crée l'interface : boutons, intitulés, menus... */ void Ui_MainWindow::setupUi(QMainWindow *MainWindow) { if (MainWindow->objectName().isEmpty()) MainWindow->setObjectName(QString::fromUtf8("MainWindow")); actionQuitter = new QAction(MainWindow); actionQuitter->setObjectName(QString::fromUtf8("actionQuitter")); actionFichier = new QAction(MainWindow); actionFichier->setObjectName(QString::fromUtf8("actionFichier")); actionWebcam = new QAction(MainWindow); actionWebcam->setObjectName(QString::fromUtf8("actionWebcam")); centralwidget = new QWidget(MainWindow); centralwidget->setObjectName(QString::fromUtf8("centralwidget")); listWidget = new QListWidget(centralwidget); new QListWidgetItem(listWidget); listWidget->setObjectName(QString::fromUtf8("listWidget")); listWidget->setDragDropMode(QAbstractItemView::InternalMove); cvwidget = new QOpenCVWidget(this); cvwidget->setObjectName(QString::fromUtf8("cvwidget")); label_2 = new QLabel(centralwidget); label_2->setObjectName(QString::fromUtf8("label_2")); label_6 = new QLabel(centralwidget); label_6->setObjectName(QString::fromUtf8("label_6")); comboBox_4 = new QComboBox(centralwidget); comboBox_4->setObjectName(QString::fromUtf8("comboBox_4")); buttonBox_2 = new QDialogButtonBox(centralwidget); buttonBox_2->setObjectName(QString::fromUtf8("buttonBox_2")); apply_button = new QPushButton(tr("Appliquer")); delete_button = new QPushButton(tr("Supprimer")); buttonBox_2->addButton(apply_button, QDialogButtonBox::AcceptRole); buttonBox_2->addButton(delete_button, QDialogButtonBox::RejectRole); comboBox = new QComboBox(centralwidget); comboBox->setObjectName(QString::fromUtf8("comboBox")); MainWindow->setCentralWidget(centralwidget); menubar = new QMenuBar(MainWindow); menubar->setObjectName(QString::fromUtf8("menubar")); menubar->setGeometry(QRect(0, 0, 540, 25)); menuFichier = new QMenu(menubar); menuFichier->setObjectName(QString::fromUtf8("menuFichier")); menuOuvrir = new QMenu(menuFichier); menuOuvrir->setObjectName(QString::fromUtf8("menuOuvrir")); MainWindow->setMenuBar(menubar); statusbar = new QStatusBar(MainWindow); statusbar->setObjectName(QString::fromUtf8("statusbar")); MainWindow->setStatusBar(statusbar); menubar->addAction(menuFichier->menuAction()); menuFichier->addAction(menuOuvrir->menuAction()); menuFichier->addAction(actionQuitter); menuOuvrir->addAction(actionFichier); menuOuvrir->addAction(actionWebcam); may_the_force_be_with_you(); retranslateUi(MainWindow); QObject::connect(actionQuitter, SIGNAL(triggered()), MainWindow, SLOT(close())); QObject::connect(actionFichier, SIGNAL(triggered()), MainWindow, SLOT(select_file())); QObject::connect(buttonBox_2, SIGNAL(accepted()), MainWindow, SLOT(apply_changes())); QObject::connect(buttonBox_2, SIGNAL(rejected()), MainWindow, SLOT(delete_filter())); QObject::connect(actionWebcam, SIGNAL(triggered()), MainWindow, SLOT(select_camera())); QMetaObject::connectSlotsByName(MainWindow); }
static GtkWidget * gth_file_tool_grayscale_get_options (GthFileTool *base) { GthFileToolGrayscale *self; GtkWidget *window; GtkWidget *viewer_page; GtkWidget *viewer; cairo_surface_t *source; GtkWidget *options; int width, height; GtkAllocation allocation; self = (GthFileToolGrayscale *) base; window = gth_file_tool_get_window (base); viewer_page = gth_browser_get_viewer_page (GTH_BROWSER (window)); if (! GTH_IS_IMAGE_VIEWER_PAGE (viewer_page)) return NULL; cairo_surface_destroy (self->priv->destination); cairo_surface_destroy (self->priv->preview); viewer = gth_image_viewer_page_get_image_viewer (GTH_IMAGE_VIEWER_PAGE (viewer_page)); source = gth_image_viewer_page_tool_get_source (GTH_IMAGE_VIEWER_PAGE_TOOL (self)); if (source == NULL) return NULL; width = cairo_image_surface_get_width (source); height = cairo_image_surface_get_height (source); gtk_widget_get_allocation (GTK_WIDGET (viewer), &allocation); if (scale_keeping_ratio (&width, &height, PREVIEW_SIZE * allocation.width, PREVIEW_SIZE * allocation.height, FALSE)) self->priv->preview = _cairo_image_surface_scale_bilinear (source, width, height); else self->priv->preview = cairo_surface_reference (source); self->priv->destination = cairo_surface_reference (self->priv->preview); self->priv->apply_to_original = FALSE; self->priv->closing = FALSE; self->priv->builder = _gtk_builder_new_from_file ("grayscale-options.ui", "file_tools"); options = _gtk_builder_get_widget (self->priv->builder, "options"); gtk_widget_show (options); g_signal_connect (GET_WIDGET ("ok_button"), "clicked", G_CALLBACK (ok_button_clicked_cb), self); g_signal_connect_swapped (GET_WIDGET ("cancel_button"), "clicked", G_CALLBACK (gth_file_tool_cancel), self); g_signal_connect (GET_WIDGET ("brightness_radiobutton"), "clicked", G_CALLBACK (method_changed_cb), self); g_signal_connect (GET_WIDGET ("saturation_radiobutton"), "clicked", G_CALLBACK (method_changed_cb), self); g_signal_connect (GET_WIDGET ("average_radiobutton"), "clicked", G_CALLBACK (method_changed_cb), self); g_signal_connect (GET_WIDGET ("preview_checkbutton"), "toggled", G_CALLBACK (preview_checkbutton_toggled_cb), self); self->priv->preview_tool = gth_preview_tool_new (); gth_preview_tool_set_image (GTH_PREVIEW_TOOL (self->priv->preview_tool), self->priv->preview); gth_image_viewer_set_tool (GTH_IMAGE_VIEWER (viewer), self->priv->preview_tool); apply_changes (self); return options; }
/*------------------------------------------------*/ int main (int argc, char **argv) { int cols, rows, iter, particles, x, y; int *pic; PartStr *p, *changes, *totalChanges; int rank, num, i, numChanges, numTotalChanges; int *changesPerNode, *buffDispl; MPI_Init (&argc, &argv); MPI_Comm_rank (MPI_COMM_WORLD, &rank); MPI_Comm_size (MPI_COMM_WORLD, &num); if (argc < 2) // use default values if user does not specify anything { cols = PIC_SIZE + 2; rows = PIC_SIZE + 2; iter = MAX_ITER; particles = PARTICLES; } else { cols = atoi (argv[1]) + 2; rows = atoi (argv[2]) + 2; particles = atoi (argv[3]); iter = atoi (argv[4]); } // initialize the random number generator srand(rank); // srand(time(0)); // this should be used instead if the program runs on multiple hosts int particlesPerNode = particles / num; if (rank == num - 1) particlesPerNode = particles - particlesPerNode * (num - 1); // in case particles cannot be split evenly // printf("%i has %i\n", rank, particlesPerNode); pic = (int *) malloc (sizeof (int) * cols * rows); p = (PartStr *) malloc (sizeof (PartStr) * particlesPerNode); changes = (PartStr *) malloc (sizeof (PartStr) * particlesPerNode); totalChanges = (PartStr *) malloc (sizeof (PartStr) * particlesPerNode); changesPerNode = (int *) malloc (sizeof (int) * num); buffDispl = (int *) malloc (sizeof (int) * num); assert (pic != 0 && p != 0 && changes != 0 && totalChanges != 0 && changesPerNode != 0); // MPI user type declaration int lengths[2] = { 1, 1 }; MPI_Datatype types[2] = { MPI_INT, MPI_INT }; MPI_Aint add1, add2; MPI_Aint displ[2]; MPI_Datatype Point; MPI_Address (p, &add1); MPI_Address (&(p[0].y), &add2); displ[0] = 0; displ[1] = add2 - add1; MPI_Type_struct (2, lengths, displ, types, &Point); MPI_Type_commit (&Point); dla_init_plist (pic, rows, cols, p, particlesPerNode, 1); while (--iter) { dla_evolve_plist (pic, rows, cols, p, &particlesPerNode, changes, &numChanges); // printf("%i changed %i on iter %i : ",rank, numChanges, iter); // for(i=0;i<numChanges;i++) printf("(%i, %i) ", changes[i].x, changes[i].y); // printf("\n"); //exchange information with other nodes MPI_Allgather (&numChanges, 1, MPI_INT, changesPerNode, 1, MPI_INT, MPI_COMM_WORLD); //calculate offsets numTotalChanges = 0; for (i = 0; i < num; i++) { buffDispl[i] = numTotalChanges; numTotalChanges += changesPerNode[i]; } // if(rank==0) // { // for(i=0;i<num;i++) // printf("%i tries to send %i\n",i,changesPerNode[i]); // printf("-----------\n"); // } if(numTotalChanges >0) { MPI_Allgatherv (changes, numChanges, Point, totalChanges, changesPerNode, buffDispl, Point, MPI_COMM_WORLD); apply_changes (pic, rows, cols, totalChanges, numTotalChanges); // if(rank==0) // { // printf("Total changes %i : ", numTotalChanges); // for(i=0;i<numTotalChanges;i++) printf("(%i, %i) ", totalChanges[i].x, totalChanges[i].y); // // printf("\n"); // printf("-----------\n"); // } } } /* Print to stdout a PBM picture of the simulation space */ if (rank == 0) { printf ("P1\n%i %i\n", cols - 2, rows - 2); for (y = 1; y < rows - 1; y++) { for (x = 1; x < cols - 1; x++) { if (pic[y * cols + x] < 0) printf ("1 "); else printf ("0 "); } printf ("\n"); } } MPI_Reduce(&particlesPerNode, &particles, 1, MPI_INT, MPI_SUM, 0, MPI_COMM_WORLD); if(rank==0) fprintf(stderr, "Remaining particles %i\n", particles); free (pic); free (p); free (changes); free (changesPerNode); free (buffDispl); MPI_Finalize (); return 0; }
int not_main(char *rom_name, char *offset, char *bytes, int apply_or_check) { FILE* file = fopen(rom_name, "rb"); //printf("trying to open...\n"); if (file) { size_t size; //printf("file exists!\n"); unsigned char *buf; get_data("rom.smc", &buf, file, &size); fclose(file); //printf("file closed!\n"); //char input[30]; char to_use[30]; //printf("offset?\n"); //scanf("%s", input); //needed int num = strlen(bytes); //needed int offset_to_apply, bytes_to_apply, new_offset; int c = 0; int check_tweak = 0; sscanf(offset, "%x", &offset_to_apply); //printf("bytes? (offset is: %d)\n", offset_to_apply); //scanf("%s", input); //needed while (c < num) { //printf(">>>>>%d<<<<<<\n>>>>>%d<<<<<\n", c, num); strncpy(to_use, bytes+c, 2); sscanf(to_use, "%x", &bytes_to_apply); if ((make_changes(buf, offset_to_apply, bytes_to_apply, size, &check_tweak)==0)) { if (apply_or_check == 0) { //0 = apply /*switch(apply_changes(buf, rom_name, size)) { case 0: printf("success!\n"); break; case 1: printf("not success :(\n"); break; }*/ apply_changes(buf, rom_name, size); } } c += 2; offset_to_apply++; } free(buf); if (apply_or_check > 0) //if this is checking stuff //printf("number of bytes in the tweak: %d\nnumber of bytes that were the same: %d\n", c/2, check_tweak); if (check_tweak == (c/2)) return 1; else return 0; return 1; } else { fclose(file); printf("no such file???\n"); return 0; } }
Datum getHStoreDatum(lua_State *L, int index){ Lua_Hstore *strg = lua_touserdata(L, index); apply_changes(L, strg); strg->havetodel = 1; return strg->datum; }
static void range_value_changed (GtkRange *range, DialogData *data) { apply_changes (data, data->orig_pixbuf, data->new_pixbuf, TRUE, FALSE); }