void list_view::init() { init_grid(cast<listbox_definition::resolution>(config()).grid); set_single_child(find_widget<grid>(&get_grid(), "_list_grid", false), generator_); /* * These items should be managed by the new listbox class. * So make them invisible for now. */ grid* g = find_widget<grid>(&get_grid(), "_header_grid", false, false); if(g) g->set_visible(widget::visibility::invisible); g = find_widget<grid>(&get_grid(), "_footer_grid", false, false); if(g) g->set_visible(widget::visibility::invisible); g = find_widget<grid>(&get_grid(), "_vertical_scrollbar_grid", false, false); if(g) g->set_visible(widget::visibility::invisible); g = find_widget<grid>(&get_grid(), "_horizontal_scrollbar_grid", false, false); if(g) g->set_visible(widget::visibility::invisible); }
HIDDEN void get_cbar(void) { int eid, pid; int g1, g2; point_t pt1, pt2; fastf_t radius; vect_t height; struct pbar *pb; char cbar_name[NAMESIZE+1]; eid = atoi( curr_rec[1] ); pid = atoi( curr_rec[2] ); if ( !pid ) { if ( bar_def_pid ) pid = bar_def_pid; else pid = eid; } g1 = atoi( curr_rec[3] ); g2 = atoi( curr_rec[4] ); get_grid( g1, pt1 ); get_grid( g2, pt2 ); for ( BU_LIST_FOR( pb, pbar, &pbar_head.l ) ) { if ( pb->pid == pid ) break; } if ( BU_LIST_IS_HEAD( &pb->l, &pbar_head.l ) ) { log_line( "Non-existent PID referenced in CBAR" ); return; } VSCALE( pt1, pt1, conv[units] ); VSCALE( pt2, pt2, conv[units] ); radius = sqrt( pb->area/bn_pi ); radius = radius * conv[units]; VSUB2( height, pt2, pt1 ); sprintf( cbar_name, "cbar.%d", eid ); mk_rcc( fpout, cbar_name, pt1, height, radius ); mk_addmember( cbar_name, &pb->head.l, NULL, WMOP_UNION ); }
void list_view::layout_children(const bool force) { if(need_layout_ || force) { get_grid().place(get_grid().get_origin(), get_grid().get_size()); /* get_grid().set_visible_rectangle(content_visible_area_); */ need_layout_ = false; set_is_dirty(true); } }
point listbox::calculate_best_size() const { // Get the size from the base class, then add any extra space for the header and footer. point result = scrollbar_container::calculate_best_size(); if(const grid* header = find_widget<const grid>(&get_grid(), "_header_grid", false, false)) { result.y += header->get_best_size().y; } if(const grid* footer = find_widget<const grid>(&get_grid(), "_footer_grid", false, false)) { result.y += footer->get_best_size().y; } return result; }
ComplementarityRestraint::GridObject *ComplementarityRestraint::get_grid_object( core::RigidBody rb, const kernel::ParticlesTemp &a, ObjectKey ok, double thickness, double value, double interior_thickness, double voxel) const { IMP_USAGE_CHECK(!a.empty(), "No particles passed for excluded volume"); for (unsigned int i = 1; i < a.size(); ++i) { IMP_USAGE_CHECK(core::RigidMember(a[0]).get_rigid_body() == core::RigidMember(a[i]).get_rigid_body(), "Not all particles are from the same rigid body."); } if (!rb->has_attribute(ok)) { IMP_LOG_TERSE("Creating grid for rigid body " << rb->get_name() << std::endl); IMP::algebra::DenseGrid3D<float> grid = get_grid(a, thickness, value, interior_thickness, voxel); IMP_LOG_TERSE("Grid has size " << grid.get_number_of_voxels(0) << ", " << grid.get_number_of_voxels(1) << ", " << grid.get_number_of_voxels(2) << std::endl); base::Pointer<GridObject> n(new GridObject( GridPair(rb.get_reference_frame().get_transformation_to(), grid))); rb->add_cache_attribute(ok, n); } IMP_CHECK_OBJECT(rb->get_value(ok)); IMP_INTERNAL_CHECK(dynamic_cast<GridObject *>(rb->get_value(ok)), "The saved grid is not a grid."); return dynamic_cast<GridObject *>(rb->get_value(ok)); }
int main(int argc, char **argv) { int *grid[9][9]; get_grid(argc - 1, argv + 1, *grid); return (0); }
static int get_data_grid (Isis_Rmf_t *rmf, double **lo, double **hi, unsigned int *n, int *eoeb) /*{{{*/ { Client_Data_t *cl = (Client_Data_t *)rmf->client_data; *eoeb = 0; return get_grid (cl->ebounds, lo, hi, n); }
/* Sauvegarde d'un grille @params p_widget Elément ayant déclencher la fonction @params user_data Données transmis au callback */ void cb_save_file(GtkWidget *p_widget, gpointer user_data){ GtkWidget *p_dialog_save; p_dialog_save = gtk_file_chooser_dialog_new ("Enregistrer un fichier", GTK_WINDOW(widgetCallback.entry1), GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL); gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(p_dialog_save), TRUE); if (gtk_dialog_run(GTK_DIALOG(p_dialog_save)) == GTK_RESPONSE_ACCEPT){ //Nom du fichier a été choisi char *filename; filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(p_dialog_save)); int grid[9][9] = {{0}}; int grid_fixes[9][9] = {{0}}; //On récupère la grille get_grid(grid); get_fixed_grid(grid_fixes); save_grid_in_file(grid, grid_fixes, filename); //On sauvegarde } gtk_widget_destroy(p_dialog_save); //Parametres inutilises (void)p_widget; }
void listbox::finalize(builder_grid_const_ptr header, builder_grid_const_ptr footer, const std::vector<std::map<std::string, string_map>>& list_data) { // "Inherited." scrollbar_container::finalize_setup(); assert(generator_); if(header) { swap_grid(&get_grid(), content_grid(), header->build(), "_header_grid"); } grid& p = find_widget<grid>(this, "_header_grid", false); for(unsigned i = 0, max = std::max(p.get_cols(), p.get_rows()); i < max; ++i) { // // TODO: I had to change this to case to a toggle_button in order to use a signal handler. // Should probably look into a way to make it more general like it was before (used to be // cast to selectable_item). // // - vultraz, 2017-08-23 // if(toggle_button* selectable = find_widget<toggle_button>(&p, "sort_" + std::to_string(i), false, false)) { // Register callback to sort the list. connect_signal_notify_modified(*selectable, std::bind(&listbox::order_by_column, this, i, _1)); if(orders_.size() < max) { orders_.resize(max); } orders_[i].first = selectable; } } if(footer) { swap_grid(&get_grid(), content_grid(), footer->build(), "_footer_grid"); } generator_->create_items(-1, list_builder_, list_data, std::bind(&listbox::list_item_clicked, this, _1)); swap_grid(nullptr, content_grid(), generator_, "_list_grid"); }
int main() { int **power = NULL, i; power = (int**)malloc( 3 * sizeof( int* ) ); // for the rows for ( i = 0; i < 3; i++ ) // for every row, you want get 4 addresses power[i] = (int*)malloc(4 * sizeof (int) ); get_grid(power); return 0; }//main()
grid box_rep::find_grid (path bp) { box b= this; grid g= get_grid (); while (!is_nil (bp)) { b = b->subbox (bp->item); bp = bp->next; grid g2= b->get_grid (); if (!is_nil (g2)) g= g2; } return g; }
void stacked_widget::finalize(std::vector<builder_grid_const_ptr> widget_builder) { assert(generator_); string_map empty_data; for(const auto & builder : widget_builder) { generator_->create_item(-1, builder, empty_data, nullptr); } swap_grid(nullptr, &get_grid(), generator_, "_content_grid"); select_layer(-1); }
int Get_slope_grid(double resolution, double xmin, double xmax, double ymin, double ymax, double* slope) { int status; if ( gis_grid.slope == 0 ) { status = calculate_slope(); if ( status != 0 ) return status; } get_grid( resolution, xmin, xmax, ymin, ymax, gis_grid.slope, slope); return 0; }
int Get_elevation_grid(double resolution, double xmin, double xmax, double ymin, double ymax, double* elev) { int status; if ( gis_grid.elev == 0 ) { status = load_GIS_data(); if ( status != 0 ) return status; } get_grid( resolution, xmin, xmax, ymin, ymax, gis_grid.elev, elev); return 0; }
int Get_curvature_grid(double resolution, double xmin, double xmax, double ymin, double ymax, double* xcurv, double* ycurv) { int status; if ( gis_grid.slope == 0 ) { status = calculate_slope(); if ( status != 0 ) return status; } if ( gis_grid.xcurv == 0 ) { status = calculate_curvature(); if ( status != 0 ) return status; } get_grid( resolution, xmin, xmax, ymin, ymax, gis_grid.xcurv, xcurv); get_grid( resolution, xmin, xmax, ymin, ymax, gis_grid.ycurv, ycurv); return 0; }
void mu_msg_header_view_set_message (MuMsgHeaderView *self, MuMsg *msg) { g_return_if_fail (MU_IS_MSG_HEADER_VIEW(self)); if (self->_priv->_grid) { gtk_container_remove (GTK_CONTAINER(self), self->_priv->_grid); self->_priv->_grid = NULL; } if (msg) { self->_priv->_grid = get_grid (msg); gtk_box_pack_start (GTK_BOX(self), self->_priv->_grid, TRUE, TRUE, 0); gtk_widget_show_all (self->_priv->_grid); } }
/* 16Feb07 Phil McDonald */ int volume_colors (Context data_ctx, int itime, int ivar) { int ixyz, nxyz; float *data, datmin, datmax, datfac, val, *p_xyz; uint_1 *p_ind; struct volume *v; if ((data = get_grid (data_ctx, itime, ivar)) == NULL) return 0; datmin = data_ctx->Variable[ivar]->MinVal; datmax = data_ctx->Variable[ivar]->MaxVal; datfac = (datmin == datmax) ? 0.0 : 254.0 / (datmax - datmin); v = data_ctx->Volume; nxyz = v->nx * v->ny * v->nz; p_xyz = v->vertex; p_ind = v->index; for (ixyz = 0; ixyz < nxyz; ixyz++) { val = volume_interp_val (data_ctx, itime, ivar, data, p_xyz); if (IS_MISSING (val)) { *p_ind = 255; } else if (val <= datmin) { *p_ind = 0; } else if (val >= datmax) { *p_ind = 254; } else { *p_ind = (val - datmin) * datfac; } p_ind++; p_xyz += 3; } release_grid (data_ctx, itime, ivar, data); return 1; }
/* Affichage de la solution de la grille @params p_widget Elément ayant déclencher la fonction @params user_data Données transmis au callback */ void cb_resolve(GtkWidget *p_widget, gpointer user_data){ int i,row,col; //On récupère la grille int grid[9][9] = {{0}}; get_grid(grid); int grid_fixes[9][9] = {{0}}; get_fixed_grid(grid_fixes); //On vérifit si grid_fixes est vide int emptyGridFixes = 1; for(i=0;i<=80;i++){ row = floor(i/9); col = i%9; if(grid_fixes[col][row] != 0){emptyGridFixes = 0;break;} } if(!emptyGridFixes){ //On récupère la base de la grille for(i=0;i<=80;i++){ row = floor(i/9); col = i%9; if(grid_fixes[col][row] == 0){grid[col][row] = 0;} } } else{ //On remplit grid_fixes(grille saisi par user) for(i=0;i<=80;i++){ row = floor(i/9); col = i%9; if(grid[col][row] != 0){grid_fixes[col][row] = 1;} } } //On résout et on affiche if(is_grid_valid(grid)){ resolve(grid, 0, 0); fill_grid(grid, grid_fixes); } (void)p_widget; (void)user_data; }
int my_errors(unsigned char grille[9][9]) { static t_bool e; char *line; int i; size_t len; ssize_t read; line = NULL; i = -1; len = 0; while (i < 10 && (read = getline(&line, &len, stdin)) != -1) if (get_grid(grille, line, ++i)) { free(line); return (0); } if (e == true && i == 10) printf("####################\n"); e = true; free(line); return (i == 10 || i == -1) ? (1 + (i == 10)) : (0); }
/*! * \brief Affichage de la grille * \note Pour le mode console */ void World::display() { for (unsigned i = 0 ; i < len() +2 ; i++) cout << "-"; cout << endl; cout << "x|"; for (unsigned i = 0 ; i < len() ; i++) cout << i%10 << "|"; cout << endl; for (unsigned i = 0 ; i < hei() ; i++) { cout << i%10 << "|"; for (unsigned j = 0 ; j < len() ; j++) { cout << get_grid(j,i)->display(); cout << "|"; } cout << endl; } for (unsigned i = 0 ; i < len() + 2 ; i++) cout << "-"; cout << endl << endl; cout << "Stats faction :" << endl; for (list<Faction>::iterator it = factions_.begin() ; it!=factions_.end() ; it++) { cout << it->toString(); } cout << endl << endl; }
HIDDEN void get_coord_sys(void) { int form; char type; char *ptr; struct coord_sys *cs; int i, gid; double tmp[3]; point_t tmp_pt; form = atoi(&curr_rec[0][4]); if (form != 1 && form != 2) { bu_log("unrecognized form for coordinate system definition (%d):\n", form); bu_log("%s\n", line); return; } type = curr_rec[0][5]; if (type != CORD_CYL && type != CORD_RECT && type != CORD_SPH) { bu_log("unrecognized coordinate system type (%c):\n", type); bu_log("%s\n", line); return; } (void)strtok(line, delims); ptr = strtok((char *)NULL, delims); if (!ptr) { log_line("Incomplete coordinate system definition"); return; } BU_ALLOC(cs, struct coord_sys); switch (form) { case 1: cs->type = type; cs->cid = atoi(curr_rec[1]); gid = atoi(curr_rec[2]); get_grid(gid, cs->origin); gid = atoi(curr_rec[3]); get_grid(gid, tmp_pt); VSUB2(cs->v3, tmp_pt, cs->origin); VUNITIZE(cs->v3); gid = atoi(curr_rec[4]); get_grid(gid, tmp_pt); VSUB2(cs->v1, tmp_pt, cs->origin); VCROSS(cs->v2, cs->v3, cs->v1); VUNITIZE(cs->v2); VCROSS(cs->v1, cs->v2, cs->v3); BU_LIST_INSERT(&coord_head.l, &cs->l); if (!strlen(curr_rec[5])) break; BU_ALLOC(cs, struct coord_sys); cs->type = type; cs->cid = atoi(curr_rec[5]); gid = atoi(curr_rec[6]); get_grid(gid, cs->origin); gid = atoi(curr_rec[7]); get_grid(gid, tmp_pt); VSUB2(cs->v3, tmp_pt, cs->origin); VUNITIZE(cs->v3); gid = atoi(curr_rec[8]); get_grid(gid, tmp_pt); VSUB2(cs->v1, tmp_pt, cs->origin); VCROSS(cs->v2, cs->v3, cs->v1); VUNITIZE(cs->v2); VCROSS(cs->v1, cs->v2, cs->v3); BU_LIST_INSERT(&coord_head.l, &cs->l); break; case 2: cs->type = type; cs->cid = atoi(curr_rec[1]); cs->rid = atoi(curr_rec[2]); for (i=0; i<3; i++) tmp[i] = atof(curr_rec[3+i]); VMOVE(cs->origin, tmp); for (i=0; i<3; i++) tmp[i] = atof(curr_rec[6+i]); VMOVE(cs->v1, tmp); for (i=0; i<3; i++) tmp[i] = atof(curr_rec[9+i]); VMOVE(cs->v2, tmp); if (!cs->rid) { point_t tmp_pt1, tmp_pt2; /* this coordinate system is defined in terms of the default */ VMOVE(tmp_pt1, cs->v1); VMOVE(tmp_pt2, cs->v2); VSUB2(cs->v3, tmp_pt1, cs->origin); VUNITIZE(cs->v3); VSUB2(cs->v1, tmp_pt2, cs->origin); VCROSS(cs->v2, cs->v3, cs->v1); VUNITIZE(cs->v2); VCROSS(cs->v1, cs->v3, cs->v2); } BU_LIST_INSERT(&coord_head.l, &cs->l); break; } }
void draw_volume( Context ctx, int it, int ip, unsigned int *ctable ) { float *data; static int prev_it[VIS5D_MAX_CONTEXTS]; static int prev_ip[VIS5D_MAX_CONTEXTS]; static int do_once = 1; int dir; float x, y, z, ax, ay, az; float xyz[3], xy[3][2], xy0[2]; Display_Context dtx; dtx = ctx->dpy_ctx; if (do_once){ int yo; for (yo=0; yo<VIS5D_MAX_CONTEXTS; yo++){ prev_it[yo] = -1; prev_ip[yo] = -1; } do_once = 0; } xyz[0] = xyz[1] = xyz[2] = 0.0; project (xyz, &xy0[0], &xy0[1]); xyz[0] = 1.0, xyz[1] = xyz[2] = 0.0; project (xyz, &xy[0][0], &xy[0][1]); xy[0][0] -= xy0[0], xy[0][1] -= xy0[1]; xyz[1] = 1.0, xyz[0] = xyz[2] = 0.0; project (xyz, &xy[1][0], &xy[1][1]); xy[1][0] -= xy0[0], xy[1][1] -= xy0[1]; xyz[2] = 1.0, xyz[0] = xyz[1] = 0.0; project (xyz, &xy[2][0], &xy[2][1]); xy[2][0] -= xy0[0], xy[2][1] -= xy0[1]; ax = (xy[0][0] * xy[0][0]) + (xy[0][1] * xy[0][1]); ay = (xy[1][0] * xy[1][0]) + (xy[1][1] * xy[1][1]); az = (xy[2][0] * xy[2][0]) + (xy[2][1] * xy[2][1]); if ((ax <= ay) && (ax <= az)) { x = (xy[1][1] * xy[2][0]) - (xy[1][0] * xy[2][1]); dir = (x > 0.0) ? WEST_TO_EAST : EAST_TO_WEST; } else if ((ay <= ax) && (ay <= az)) { x = (xy[2][1] * xy[0][0]) - (xy[2][0] * xy[0][1]); dir = (x > 0.0) ? SOUTH_TO_NORTH : NORTH_TO_SOUTH; } else { x = (xy[0][1] * xy[1][0]) - (xy[0][0] * xy[1][1]); dir = (x > 0.0) ? BOTTOM_TO_TOP : TOP_TO_BOTTOM; } /* If this is a new time step or variable then invalidate old volumes */ if (it!=prev_it[ctx->context_index] || ip!=prev_ip[ctx->context_index]) { ctx->Volume->valid = 0; prev_it[ctx->context_index] = it; prev_ip[ctx->context_index] = ip; } /* Determine if we have to compute a set of slices for the direction. */ if (ctx->Volume->dir!=dir || ctx->Volume->valid==0) { data = get_grid( ctx, it, ip ); if (data) { if (ctx->GridSameAsGridPRIME){ compute_volume( ctx, data, it, ip, ctx->Nr, ctx->Nc, ctx->Nl[ip], ctx->Variable[ip]->LowLev, ctx->Variable[ip]->MinVal, ctx->Variable[ip]->MaxVal, dir, ctx->Volume ); } else{ compute_volumePRIME( ctx, data, it, ip, dtx->Nr, dtx->Nc, dtx->Nl, dtx->LowLev, ctx->Variable[ip]->MinVal, ctx->Variable[ip]->MaxVal, dir, ctx->Volume ); } release_grid( ctx, it, ip, data ); } } render_volume( ctx, ctx->Volume, ctable ); }
/* * Draw a volumetric rendering of the grid for timestep it and variable ip. * Input: it - timestep * ip - variable */ void draw_volume( Context ctx, int it, int ip, unsigned int *ctable ) { float *data; static int prev_it[VIS5D_MAX_CONTEXTS]; static int prev_ip[VIS5D_MAX_CONTEXTS]; static int do_once = 1; int dir; float x, y, z, ax, ay, az; MATRIX ctm, proj; Display_Context dtx; dtx = ctx->dpy_ctx; if (do_once){ int yo; for (yo=0; yo<VIS5D_MAX_CONTEXTS; yo++){ prev_it[yo] = -1; prev_ip[yo] = -1; } do_once = 0; } /* Get 3rd column values from transformation matrix */ #if defined (HAVE_SGI_GL) || defined (DENALI) /* Compute orientation of 3-D box with respect to current matrices */ /* with no assumptions about the location of the camera. This was */ /* done for the CAVE. */ mmode( MPROJECTION ); getmatrix( proj ); mmode( MVIEWING ); getmatrix( ctm ); #endif #if defined(HAVE_OPENGL) glGetFloatv( GL_PROJECTION_MATRIX, (GLfloat *) proj ); glGetFloatv( GL_MODELVIEW_MATRIX, (GLfloat *) ctm ); check_gl_error( "draw_volume" ); #endif /* compute third column values in the product of ctm*proj */ x = ctm[0][0]*proj[0][2] + ctm[0][1]*proj[1][2] + ctm[0][2]*proj[2][2] + ctm[0][3]*proj[3][2]; y = ctm[1][0]*proj[0][2] + ctm[1][1]*proj[1][2] + ctm[1][2]*proj[2][2] + ctm[1][3]*proj[3][2]; z = ctm[2][0]*proj[0][2] + ctm[2][1]*proj[1][2] + ctm[2][2]*proj[2][2] + ctm[2][3]*proj[3][2]; /* examine values to determine how to draw slices */ ax = ABS(x); ay = ABS(y); az = ABS(z); if (ax>=ay && ax>=az) { /* draw x-axis slices */ dir = (x<0.0) ? WEST_TO_EAST : EAST_TO_WEST; } else if (ay>=ax && ay>=az) { /* draw y-axis slices */ dir = (y<0.0) ? SOUTH_TO_NORTH : NORTH_TO_SOUTH; } else { /* draw z-axis slices */ dir = (z<0.0) ? BOTTOM_TO_TOP : TOP_TO_BOTTOM; } /* If this is a new time step or variable then invalidate old volumes */ if (it!=prev_it[ctx->context_index] || ip!=prev_ip[ctx->context_index]) { ctx->Volume->valid = 0; prev_it[ctx->context_index] = it; prev_ip[ctx->context_index] = ip; } /* Determine if we have to compute a set of slices for the direction. */ if (ctx->Volume->dir!=dir || ctx->Volume->valid==0) { data = get_grid( ctx, it, ip ); if (data) { if (ctx->GridSameAsGridPRIME){ compute_volume( ctx, data, it, ip, ctx->Nr, ctx->Nc, ctx->Nl[ip], ctx->Variable[ip]->LowLev, ctx->Variable[ip]->MinVal, ctx->Variable[ip]->MaxVal, dir, ctx->Volume ); } else{ compute_volumePRIME( ctx, data, it, ip, dtx->Nr, dtx->Nc, dtx->Nl, dtx->LowLev, ctx->Variable[ip]->MinVal, ctx->Variable[ip]->MaxVal, dir, ctx->Volume ); } release_grid( ctx, it, ip, data ); } } render_volume( ctx, ctx->Volume, ctable ); }
/* * Compute a new variable by evaluating an expression in terms of other * variables. This is called from gui.c after the user has typed in * an expression. * Input: expression - the character string expression as type in by * the user. Ex: "SPD = SQRT( U*U + V*V + W*W )" * Return: number of variable computed or -1 if error */ int compute_var( Display_Context dtx, const char *expression, int *expressionowner, char name[100], char mess[100], int *recompute ) { int time, var, nl, lowlev, toplev, length, layer, offset, i; float *g, *a, *b, *f[MAXOPS]; int numops; int ftype, arg_count; Context ctx; struct compute_state fixed_state, *state; state = &fixed_state; strcpy(mess, ""); /* parse the expression to build a tree, return -1 if error */ if (parse(dtx, state, expression, name, expressionowner, &var, recompute, mess) < 0){ return -1; } { int ahh; for (ahh=0; ahh< dtx->numofctxs; ahh++){ if (*expressionowner == dtx->ctxpointerarray[ahh]->context_index){ ctx = dtx->ctxpointerarray[ahh]; ahh = dtx->numofctxs; } } } numops = state->curop; /* length of "program" to compute new variable */ /* Determine how many levels in output grid (nl) */ toplev = ctx->MaxNl; lowlev = 0; /* just look at the var that belong to that data ctx though */ for (i=0; i<state->numvars; i++) { if (state->varlist[i] == USETIME){ toplev = ctx->MaxNl; lowlev = 0; } else if (state->varownerlist[i] == ctx->context_index){ if (ctx->Nl[state->varlist[i]] + ctx->Variable[state->varlist[i]]->LowLev < toplev) { toplev = ctx->Nl[state->varlist[i]] + ctx->Variable[state->varlist[i]]->LowLev; } if (ctx->Variable[state->varlist[i]]->LowLev > lowlev) { lowlev = ctx->Variable[state->varlist[i]]->LowLev; } } } nl = toplev - lowlev; if (nl < 1) { strcpy(mess, "Error: grids don't overlap in the vertical"); return -1; } layer = ctx->Nr * ctx->Nc; length = layer * nl; /* Evaluate the tree for each timestep */ for (time=0;time<ctx->NumTimes;time++) { printf(" Creating Variable %s for Time %d\n", name, time); /* run program for one time step */ state->stop = 0; for (state->curop=0; state->curop<numops; state->curop++) { switch (state->ops[state->curop]) { case PUSH_VAR_OP: if (state->args2[state->curop] != ctx->context_index){ int dd1, tt1; int ahh, time2; Context tctx; for (ahh=0; ahh< ctx->dpy_ctx->numofctxs; ahh++){ if (state->args2[state->curop] == ctx->dpy_ctx->ctxpointerarray[ahh]->context_index){ tctx = ctx->dpy_ctx->ctxpointerarray[ahh]; ahh = ctx->dpy_ctx->numofctxs; } } vis5d_get_ctx_time_stamp( ctx->context_index, time, &dd1, &tt1); time2 = return_closes_timestep( tctx, dd1, tt1); if (time2 < 0){ a = (float *) allocate(ctx, length * sizeof(float)); for (i=0; i<length; i++){ a[i] = MISSING; } } else{ g = get_grid2( ctx, tctx, time2, state->args[state->curop], nl); a = (float *) allocate(ctx, length * sizeof(float)); for (i=0; i<length; i++){ a[i] = g[i]; } release_grid2(ctx, time2, state->args[state->curop], nl, g); } state->sgrid[state->stop] = a; state->stop++; } else{ if (state->args3[state->curop] != 0){ if (time+state->args3[state->curop] < ctx->NumTimes && time+state->args3[state->curop] >= 0){ if (state->args[state->curop] == USETIME){ int jj, daze, minz; a = (float *) allocate(ctx, length * sizeof(float)); /* get time in seconds since first time step*/ if (time+state->args3[state->curop] == 0){ jj = 0; } else{ daze = ctx->DayStamp[time+state->args3[state->curop]] - ctx->DayStamp[0]; minz = ctx->TimeStamp[time+state->args3[state->curop]] - ctx->TimeStamp[0]; jj = (86400*daze)+minz; } for (i=0; i<length; i++){ a[i] = (float) jj; } state->sgrid[state->stop] = a; state->stop++; } else{ g = get_grid(ctx, time+state->args3[state->curop], state->args[state->curop]); a = (float *) allocate(ctx, length * sizeof(float)); /* adjust to align lowest levels of grids */ offset = (lowlev - ctx->Variable[state->args[state->curop]]->LowLev) * layer; for (i=0; i<length; i++) a[i] = g[i + offset]; release_grid(ctx, time+state->args3[state->curop], state->args[state->curop], g); state->sgrid[state->stop] = a; state->stop++; } } else{ a = (float *) allocate(ctx, length * sizeof(float)); for (i=0; i<length; i++){ a[i] = MISSING; } state->sgrid[state->stop] = a; state->stop++; } } else{ if (state->args[state->curop] == USETIME){ int jj, daze, minz; /* get time in seconds since first time step*/ a = (float *) allocate(ctx, length * sizeof(float)); if (time+state->args3[state->curop] == 0){ jj = 0; } else{ daze = ctx->DayStamp[time+state->args3[state->curop]] - ctx->DayStamp[0]; minz = ctx->TimeStamp[time+state->args3[state->curop]] - ctx->TimeStamp[0]; jj = (86400*daze)+minz; } for (i=0; i<length; i++){ a[i] = (float) jj; } state->sgrid[state->stop] = a; state->stop++; } else{ g = get_grid(ctx, time, state->args[state->curop]); a = (float *) allocate(ctx, length * sizeof(float)); /* adjust to align lowest levels of grids */ offset = (lowlev - ctx->Variable[state->args[state->curop]]->LowLev) * layer; for (i=0; i<length; i++) a[i] = g[i + offset]; release_grid(ctx, time, state->args[state->curop], g); state->sgrid[state->stop] = a; state->stop++; } } } break; case PUSH_NUM_OP: a = (float *) allocate(ctx,length * sizeof(float)); for (i=0; i<length; i++) a[i] = state->nums[state->curop]; state->sgrid[state->stop] = a; state->stop++; break; case ADD_OP: a = state->sgrid[state->stop - 1]; b = state->sgrid[state->stop - 2]; for (i=0; i<length; i++) { if (IS_MISSING(a[i]) || IS_MISSING(b[i])) a[i] = MISSING; else a[i] = a[i] + b[i]; } deallocate(ctx,b, length * sizeof(float)); state->sgrid[state->stop - 2] = a; state->stop--; break; case SUB_OP: a = state->sgrid[state->stop - 1]; b = state->sgrid[state->stop - 2]; for (i=0; i<length; i++) { if (IS_MISSING(a[i]) || IS_MISSING(b[i])) a[i] = MISSING; else a[i] = b[i] - a[i]; } deallocate(ctx,b, length * sizeof(float)); state->sgrid[state->stop - 2] = a; state->stop--; break; case MUL_OP: a = state->sgrid[state->stop - 1]; b = state->sgrid[state->stop - 2]; for (i=0; i<length; i++) { if (IS_MISSING(a[i]) || IS_MISSING(b[i])) a[i] = MISSING; else a[i] = a[i] * b[i]; } deallocate(ctx,b, length * sizeof(float)); state->sgrid[state->stop - 2] = a; state->stop--; break; case DIV_OP: a = state->sgrid[state->stop - 1]; b = state->sgrid[state->stop - 2]; for (i=0; i<length; i++) { if (IS_MISSING(a[i]) || IS_MISSING(b[i])) a[i] = MISSING; else a[i] = b[i] / a[i]; } deallocate(ctx,b, length * sizeof(float)); state->sgrid[state->stop - 2] = a; state->stop--; break; case POWER_OP: a = state->sgrid[state->stop - 1]; b = state->sgrid[state->stop - 2]; for (i=0; i<length; i++) { if (IS_MISSING(a[i]) || IS_MISSING(b[i])) a[i] = MISSING; else a[i] = pow(b[i], a[i]); } deallocate(ctx,b, length * sizeof(float)); state->sgrid[state->stop - 2] = a; state->stop--; break; case NEGATE_OP: a = state->sgrid[state->stop - 1]; for (i=0; i<length; i++) { if (IS_MISSING(a[i])) a[i] = MISSING; else a[i] = -a[i]; } state->sgrid[state->stop - 1] = a; break; case FUNC_OP: ftype = state->args[state->curop]; arg_count = numargs[ftype]; for (i=0; i<arg_count; i++) { state->stop--; f[arg_count - 1 - i] = state->sgrid[state->stop]; } a = f[0]; switch (ftype) { case SQRT_FUNC: for (i=0; i<length; i++) { if (IS_MISSING(a[i])) a[i] = MISSING; else a[i] = sqrt(a[i]); } break; case EXP_FUNC: for (i=0; i<length; i++) { if (IS_MISSING(a[i])) a[i] = MISSING; else a[i] = exp(a[i]); } break; case LOG_FUNC: for (i=0; i<length; i++) { if (IS_MISSING(a[i])) a[i] = MISSING; else a[i] = log(a[i]); } break; case SIN_FUNC: for (i=0; i<length; i++) { if (IS_MISSING(a[i])) a[i] = MISSING; else a[i] = sin(a[i]); } break; case COS_FUNC: for (i=0; i<length; i++) { if (IS_MISSING(a[i])) a[i] = MISSING; else a[i] = cos(a[i]); } break; case TAN_FUNC: for (i=0; i<length; i++) { if (IS_MISSING(a[i])) a[i] = MISSING; else a[i] = tan(a[i]); } break; case ATAN_FUNC: for (i=0; i<length; i++) { if (IS_MISSING(a[i])) a[i] = MISSING; else a[i] = atan(a[i]); } break; case ABS_FUNC: for (i=0; i<length; i++) { if (IS_MISSING(a[i])) a[i] = MISSING; else a[i] = fabs(a[i]); } break; case MIN_FUNC: b = f[1]; for (i=0; i<length; i++) { if (IS_MISSING(a[i]) || IS_MISSING(b[i])) a[i] = MISSING; else a[i] = a[i] < b[i] ? a[i] : b[i]; } break; case MAX_FUNC: b = f[1]; for (i=0; i<length; i++) { if (IS_MISSING(a[i]) || IS_MISSING(b[i])) a[i] = MISSING; else a[i] = a[i] > b[i] ? a[i] : b[i]; } break; default: strcpy(mess, "Error: illegal program step"); return -1; } for (i=1; i<arg_count; i++) { deallocate(ctx,f[i], length * sizeof(float)); } state->sgrid[state->stop] = a; state->stop++; break; default: strcpy(mess, "Error: illegal program step"); return -1; } } if (state->stop != 1) return -1; /* save/compress the result grid */ install_new_grid( ctx, time, var, state->sgrid[0], nl, lowlev ); deallocate(ctx,state->sgrid[0], length * sizeof(float)); } return var; }
void Editor::calc_self() { // Aendert die Mauskoordinaten ggf., also frueh aufrufen! map.calc_scrolling(); // Wo ist die Maus auf dem Land? mx = map.get_mouse_x(); my = map.get_mouse_y(); const bool mouse_on_panel = hardware.get_my() > map.get_screen_yl(); const int grid = get_grid(); const int mx_grid = (mx + grid/2) - Help::mod(mx, grid); const int my_grid = (my + grid/2) - Help::mod(my, grid); // Maus wird erst beim Zeichnen positioniert, damit auch die Unterfenster // davon profitieren, denn bei ihnen wird dieser main_loop uebersprungen. mouse_cursor.set_x_frame(0); mouse_cursor.set_y_frame(0); if (map.get_scrollable() && ((useR->scroll_right && hardware.get_mrh()) || (useR->scroll_middle && hardware.get_mmh()))) mouse_cursor.set_x_frame(3); hover.clear(); // Hotkey ohne Button: Cycle around all the buttons, and every button off if (hardware.key_once(useR->key_ed_grid)) { if (!panel[GRID_2 ].get_on() && !panel[GRID_CUSTOM].get_on() && !panel[GRID_16].get_on()) panel[GRID_2].set_on(); else if (panel[GRID_2].get_on()) { panel[GRID_2 ].set_off(); panel[GRID_CUSTOM].set_on(); } else if (panel[GRID_CUSTOM].get_on()) { panel[GRID_CUSTOM].set_off(); panel[GRID_16].set_on(); } else panel[GRID_16].set_off(); } // Moving objects with the arrow keys. This doesn't have an OSD button. // Testing for key_hold is good for this: If the drawing of the level is // slow, lots of keypresses get stuck in the buffer and the object(s) will // move on despite you've let got. Only moving the object(s) when you // first press the key (one could write a new function in Hardware for // this, of course) is also bad if the drawing is quick, because // you'd have to repeatedly tap the key to move it a distance. if (hardware.key_once(useR->key_ed_up) && hardware.key_hold(useR->key_ed_up)) { for (SelIt i = selection.begin(); i != selection.end(); ++i) i->o->set_y(i->o->get_y() - grid); if (!selection.empty()) draw_required = true; } else if (hardware.key_once(useR->key_ed_right) && hardware.key_hold(useR->key_ed_right)) { for (SelIt i = selection.begin(); i != selection.end(); ++i) i->o->set_x(i->o->get_x() + grid); if (!selection.empty()) draw_required = true; } else if (hardware.key_once(useR->key_ed_down) && hardware.key_hold(useR->key_ed_down)) { for (SelIt i = selection.begin(); i != selection.end(); ++i) i->o->set_y(i->o->get_y() + grid); if (!selection.empty()) draw_required = true; } else if (hardware.key_once(useR->key_ed_left) && hardware.key_hold(useR->key_ed_left)) { for (SelIt i = selection.begin(); i != selection.end(); ++i) i->o->set_x(i->o->get_x() - grid); if (!selection.empty()) draw_required = true; } // Buttons mit Hotkeys, die aber nicht auf normale Weise damit // assoziiert sind, werden jetzt speziell behandelt. // Es gibt bloede Ueberschneidungen mit dem Druecken und Loslassen von // Shift waehrend einer Mauszieh-Aktion, daher beheben wir das hier // von vornherein und nicht unten im Maus-Code. if (hardware.key_hold(useR->key_ed_sel_frame) && ! hardware.get_mlh()) panel[SELECT_FRAME].set_on(); if (hardware.key_release(useR->key_ed_sel_frame) && ! hardware.get_mlh()) panel[SELECT_FRAME].set_off(); if (hardware.key_hold(useR->key_ed_sel_add)) panel[SELECT_ADD].set_on(); if (hardware.key_release(useR->key_ed_sel_add)) panel[SELECT_ADD].set_off(); // Das Eindruecken von Buttons sperren, solange etwas umhergezogen wird: // Ansonsten wird die For-Schleife durchlaufen. if ((!hardware.get_mlh() && !hardware.get_mlr()) || !mouse_hold_started_outside_panel || !mouse_on_panel) // Steuerleisten-Buttons abfragen for (unsigned int i = 0; i < panel.size(); ++i) { Api::BitmapButton& b = panel[i]; if (b.get_clicked()) switch (i) { case FILE_NEW: case FILE_EXIT: save_lists(); if (Level(useR->single_last_level) != level) { box_unsaved_data = new_box_unsaved_data(level); Api::Manager::add_focus(box_unsaved_data); b.set_on(); } else if (i == FILE_NEW) delete_everything(); else exit = true; break; case FILE_SAVE: if (useR->single_last_level.get_file().empty()) { // same as FILE_SAVE_AS b.set_on(); browser_save = new Api::SaveBrowser(gloB->dir_levels, gloB->ext_level, useR->single_last_level, Api::SaveBrowser::search_criterion_level, Api::SaveBrowser::new_box_overwrite_level); browser_save->set_info_level_name(level.get_name()); browser_save->set_info_filename(useR->single_last_level); Api::Manager::add_focus(browser_save); } else save_lists_and_level(); break; case FILE_SAVE_AS: b.set_on(); browser_save = new Api::SaveBrowser(gloB->dir_levels, gloB->ext_level, useR->single_last_level, Api::SaveBrowser::search_criterion_level, Api::SaveBrowser::new_box_overwrite_level); browser_save->set_info_level_name(level.get_name()); browser_save->set_info_filename(useR->single_last_level); Api::Manager::add_focus(browser_save); break; case GRID_2: case GRID_CUSTOM: case GRID_16: { bool was_on = b.get_on(); panel[GRID_2 ].set_off(); panel[GRID_CUSTOM].set_off(); panel[GRID_16].set_off(); panel[i].set_on(!was_on); } break; case SELECT_ALL: selection.clear(); for (int type = Object::TERRAIN; type != Object::MAX; ++type) for (GraIt i = object[type].begin(); i != object[type].end(); ++i) selection.push_back(Selection(&object[type], i)); break; case SELECT_FRAME: case SELECT_ADD: b.set_on(!b.get_on()); // Der Maus-Code kontrolliert, ob diese break; // Buttons eingeschaltet sind case SELECT_COPY: for (SelIt i = selection.begin(); i != selection.end(); ++i) { int offset = grid; while (offset < 8) offset *= 2; i->l->push_back(*i->o); // An einem Listenende anhaengen i->o = --i->l->end(); // Neue Position fuer den Auswahliter. i->o->set_x(i->o->get_x() + offset); i->o->set_y(i->o->get_y() + offset); } if (!selection.empty()) draw_required = true; break; case SELECT_DELETE: for (SelIt i = selection.begin(); i != selection.end(); ++i) { i->l->erase(i->o); } if (!selection.empty()) draw_required = true; selection.clear(); break; case SELECT_MINUS: selection_fore_background(true, false); break; case SELECT_PLUS: selection_fore_background(false, false); break; case SELECT_BACK: selection_fore_background(true, true ); break; case SELECT_FRONT: selection_fore_background(false, true ); break; case SELECT_FLIP: flip_selection(); if (!selection.empty()) draw_required = true; break; case SELECT_ROTATE: rotate_selection(); if (!selection.empty()) draw_required = true; break; case SELECT_DARK: for (SelIt i = selection.begin(); i != selection.end(); ++i) if (i->l == &object[Object::TERRAIN]) i->o->set_mode(i->o->get_mode() == Cutbit::DARK_EDITOR ? Cutbit::NORMAL : Cutbit::DARK_EDITOR); if (!selection.empty()) draw_required = true; break; case SELECT_NOOW: for (SelIt i = selection.begin(); i != selection.end(); ++i) if (i->l == &object[Object::TERRAIN]) i->o->set_mode(i->o->get_mode() == Cutbit::NOOW_EDITOR ? Cutbit::NORMAL : Cutbit::NOOW_EDITOR); if (!selection.empty()) draw_required = true; break; case VIEW_ZOOM: b.set_on(!b.get_on()); map.set_zoom(b.get_on()); break; case MENU_SIZE: b.set_on(); window_size = new Api::WindowSize(level, map); Api::Manager::add_focus(window_size); break; case MENU_SCROLL: b.set_on(); window_scroll = new Api::WindowScroll(level, map); Api::Manager::add_focus(window_scroll); break; case MENU_VARS: b.set_on(); window_variable = new Api::WindowVariables(level); Api::Manager::add_focus(window_variable); break; case MENU_SKILL: b.set_on(); window_skill = new Api::WindowSkill(level); Api::Manager::add_focus(window_skill); break; case HELP: b.set_on(!b.get_on()); break; case ADD_TERRAIN: b.set_on(); browser_bitmap = new Api::BitmapBrowser( search_criterion_terrain, useR->editor_last_dir_terrain, Language::add_terrain, browser_terrain_last_page); Api::Manager::add_focus(browser_bitmap); break; case ADD_STEEL: b.set_on(); browser_bitmap = new Api::BitmapBrowser( search_criterion_steel, useR->editor_last_dir_steel, Language::add_steel); Api::Manager::add_focus(browser_bitmap); break; case ADD_HATCH: b.set_on(); browser_bitmap = new Api::BitmapBrowser( search_criterion_hatch, useR->editor_last_dir_hatch, Language::add_hatch); Api::Manager::add_focus(browser_bitmap); break; case ADD_GOAL: b.set_on(); browser_bitmap = new Api::BitmapBrowser( search_criterion_goal, useR->editor_last_dir_goal, Language::add_goal); Api::Manager::add_focus(browser_bitmap); break; case ADD_DECO: b.set_on(); browser_bitmap = new Api::BitmapBrowser( search_criterion_deco, useR->editor_last_dir_deco, Language::add_deco); Api::Manager::add_focus(browser_bitmap); break; case ADD_HAZARD: b.set_on(); browser_bitmap = new Api::BitmapBrowser( search_criterion_hazard, useR->editor_last_dir_hazard, Language::add_hazard); Api::Manager::add_focus(browser_bitmap); break; default: break; } } // Dies verhindert Umherziehen und dergleichen, wenn das Maushalten // nicht im Spielfeld mit Objektwahl o. Ae. begann if (hardware.get_ml() && mouse_on_panel) { mouse_hold_started_outside_panel = false; } // Determine hover objects. // (Allerdings Hoverobjekt nicht beim Umherziehen waehlen.) // If no hover object found, then ignore transparency and go just by // the objects' selection boxes' sizes. if (! mouse_on_panel && hardware.get_mlh() < 2 && ! panel[SELECT_FRAME].get_on()) { Selection s = find_under_mouse_cursor(FIND_BY_TRANSP); if (! s.is_valid()) s = find_under_mouse_cursor(FIND_BY_SELBOX); if (s.is_valid()) hover.push_back(s); } // Vielleicht doch klicken und Rahmen ziehen? Wenn man ins Nirvana // klickt, dann noch schnell den Button aktivieren if (!mouse_on_panel && !panel[SELECT_FRAME].get_on() && hardware.get_ml() && hover.empty()) { panel[SELECT_FRAME].set_on(); } // Mehrere grosse Moeglichkeiten zur Auswahl // Moeglichkeit: Rahmen ziehen if (panel[SELECT_FRAME].get_on()) { // Rahmenziehen beginnt if (hardware.get_ml() && !mouse_on_panel) { mouse_hold_started_outside_panel = true; frame_start_x = mx; frame_start_y = my; } // Beim Rahmenziehen Objekte markieren, auch beim Loslassen diesen // Code nutzen, denn beim Loslassen wird einfach alles aus der // Hover-Liste in die Auswahl uebernommen! if ((hardware.get_mlh() || hardware.get_mlr()) && mouse_hold_started_outside_panel) { int x1 = (frame_start_x < mx) ? frame_start_x : mx; int y1 = (frame_start_y < my) ? frame_start_y : my; int x2 = (frame_start_x > mx) ? frame_start_x : mx; int y2 = (frame_start_y > my) ? frame_start_y : my; // // Rahmen ueber dem Panel lassen, gaebe beim Torus sonst Kaese // if (hardware.is_mouse_over_panel()) { // y1 = frame_start_y; // y2 = map.get_screen_y() // + (map.get_zoom() ? Level::min_y*3/4 : Level::min_y) - 2; // if (level.torus_y) y2 = Help::mod(y2, map.get_yl()); // if (y1 < y2) std::swap(y1, y2); // } // Bei Toruskarten sollte der Rahmen so gezogen werden, dass er // nur im sichtbaren Bereich verlaeuft. Dieser Test funktioniert // auch, wenn der Zoom an ist! if (level.torus_x && x1 < map.get_screen_x() && x2 > map.get_screen_x()) frame_torus_x=true; else frame_torus_x=false; if (level.torus_y && y1 < map.get_screen_y() && y2 > map.get_screen_y()) frame_torus_y=true; else frame_torus_y=false; // Stopfe Gefundenes in die Hoverliste for (int type = Object::TERRAIN; type != Object::MAX; ++type) find_check_frame(object[Object::perm(type)], x1, y1, x2, y2); frame_draw_x1 = x1; frame_draw_y1 = y1; frame_draw_x2 = x2; frame_draw_y2 = y2; // Beim Loslassen alles aus der Hover-Liste in die Auswahl setzen if (hardware.get_mlr()) { if (!hardware.get_shift()) panel[SELECT_FRAME].set_off(); // Kein CTRL gedrueckt - genau alles im Hover wird zur Auswahl if (!panel[SELECT_ADD].get_on()) selection.clear(); for (SelIt i = hover.begin(); i != hover.end(); ++i) { selection.push_back(*i); } // Radikal auf Dubletten ueberpruefen - zuvor hatte ich hier // etwas schlankeren Code stehen fuer CTRL-Auswahl, mit Ein- // fuehrung der Toruskarten kommen wir glaube ich nicht mehr // unter der O(n^2)-Loesung weg. // Kommen wir doch, die CTRL-Loesung von damals sollte reichen. // Mache ich aber (noch) nicht, kostet bisher noch nix. delete_dublicates_from_selection(); } // Fertig mit dem Uebertragen in die Auswahl } // Rahmen fertig gezogen } // Weitere grosse Moeglichkeit: // Keinen Rahmen ziehen else { // Neuauswahl der Grafikobjekte if (hardware.get_ml() && !mouse_on_panel) { mouse_hold_started_outside_panel = true; // Wir haben hier garantiert etwas angeklickt, denn sonst // haette eine Abfrage oben bereits den SELECT_FRAME-Button // aktiviert. // Soll zur Auswahl hinzugefuegt werden (CTRL/entspr. Button)? // Falls das Element bereits in der Auswahl ist, wird es // wieder hieraus entfernt. if (panel[SELECT_ADD].get_on()) { bool is_already_in_selection = false; for (SelIt i = selection.begin(); i!=selection.end(); ++i){ if (*i == *hover.begin()) { selection.erase(i); is_already_in_selection = true; hover.clear(); // Verhindert dunklen Rahmen, weil im // naechsten Tick umhergezogen wird break; } } if (!is_already_in_selection) { selection.push_back(*hover.begin()); } } // Nicht CTRL gedrueckt: // - Wenn in eine Auswahl geklickt, passiert nichts, denn man // will ja moeglicherweise umherziehen // - Wenn noch nicht ausgewaehlt, dies als neue Auswahl nehmen else { bool is_already_in_selection = false; for (SelIt i = selection.begin(); i!=selection.end(); ++i){ if (*i == *hover.begin()) { is_already_in_selection = true; break; } } if (!is_already_in_selection) { selection.clear(); selection.push_back(*hover.begin()); } } // Andere Dinge bei Mausklick mx_grid_last = mx_grid; my_grid_last = my_grid; } // Umherziehen von Objekten mit der Maus else if (hardware.get_mlh() && mouse_hold_started_outside_panel) { if (mx_grid != mx_grid_last || my_grid != my_grid_last) { for (SelIt i = selection.begin(); i != selection.end(); ++i) { const int iox = i->o->get_x() + grid/2; const int ioy = i->o->get_y() + grid/2; i->o->set_x( iox - Help::mod(iox, grid) - mx_grid_last + mx_grid ); i->o->set_y( ioy - Help::mod(ioy, grid) - my_grid_last + my_grid ); } if (!selection.empty()) draw_required = true; } mx_grid_last = mx_grid; my_grid_last = my_grid; if (selection.size() > 0 && mouse_on_panel) { mouse_cursor.set_y_frame(2); } } // Loslassen von umhergezogenen Objekten - nur wichtig fuer's // Wegschmeissen in das ewige Nirwana am unteren Bildschirmrand :-D else if (hardware.get_mlr() && mouse_hold_started_outside_panel) { if (mouse_on_panel) { // Komplette Auswahl loeschen for (SelIt i = selection.begin(); i != selection.end(); ++i) { i->l->erase(i->o); } if (!selection.empty()) draw_required = true; selection.clear(); } } // Ende Loslassen } // Ende der grossen Moeglichkeit fuer "Keinen Rahmen ziehen" }
/* Evènement lors du changement d'une case de la grille @params p_widget Elément ayant déclencher la fonction @params user_data Données transmis au callback */ void cb_entry_modified(GtkWidget *p_widget, gpointer user_data){ int i,row,col, value, incorrect = 0; char entry_value = *gtk_entry_get_text(GTK_ENTRY(p_widget)); if(!isdigit(entry_value)){ //On empêche l'user de saisir autre chose que des chiffres gtk_entry_set_text(GTK_ENTRY(p_widget), ""); } int grid[9][9] = {{0}}; get_grid(grid); int grid_fixes[9][9] = {{0}}; get_fixed_grid(grid_fixes); //On vérifit si grid_fixes est vide int emptyGridFixes = 1; for(i=0;i<=80;i++){ row = floor(i/9); col = i%9; if(grid_fixes[col][row] != 0){emptyGridFixes = 0;break;} } for(i=0;i<81;i++){ value = *gtk_entry_get_text(GTK_ENTRY(widgetCallback.entry3[i])) - '0'; //On récupère le char de la case if(value == -48) value = 0; //" " => 0 row = floor(i/9); col = i%9; grid[col][row] = 0; if((!absentDeBloc(value, grid, col, row) || !absentDeColonne(value, grid, row) || !absentDeLigne(value, grid, col)) && grid_fixes[col][row] != 1 && value != 0){ //La valeur n'est pas valide => on change le style de la case GdkColor red; gdk_color_parse("#d34836", &red); gtk_widget_modify_text(GTK_WIDGET(widgetCallback.entry3[i]), GTK_STATE_NORMAL, &red); incorrect++; } else if(grid_fixes[col][row] == 1 || emptyGridFixes){ //Base de la grille => style noir GdkColor black; gdk_color_parse ("#000000", &black); gtk_widget_modify_text(GTK_WIDGET(widgetCallback.entry3[i]), GTK_STATE_NORMAL, &black); } else{ //Case valide => style bleu GdkColor blue; gdk_color_parse ("#335D6A", &blue); gtk_widget_modify_text(GTK_WIDGET(widgetCallback.entry3[i]), GTK_STATE_NORMAL, &blue); } grid[col][row] = value; } if(incorrect == 0){ //Pas d'erreur //On vérifit si la grille est remplie int filledGrid = 1; for(i=0;i<=80;i++){ row = floor(i/9); col = i%9; if(grid[col][row] == 0){filledGrid = 0;break;} } if(filledGrid){ //Rempli + pas d'erreur => grille résolue GtkWidget *p_dialog = gtk_message_dialog_new(GTK_WINDOW(widgetCallback.entry1), GTK_DIALOG_DESTROY_WITH_PARENT, GTK_MESSAGE_INFO, GTK_BUTTONS_CLOSE, g_locale_to_utf8("Bravo la grille est résolue !", -1, NULL, NULL, NULL), NULL); gtk_dialog_run (GTK_DIALOG (p_dialog)); gtk_widget_destroy (p_dialog); } } //Parametres inutilises (void)p_widget; (void)user_data; }
static int get_arf_grid (Isis_Rmf_t *rmf, double **lo, double **hi, unsigned int *n) /*{{{*/ { Client_Data_t *cl = (Client_Data_t *)rmf->client_data; return get_grid (cl->arf, lo, hi, n); }