static void get_alpha_mask(float_shape_t *shape) { GdkColormap *colormap; GdkColor black; GdkColor white; GdkGC *gc; int rowstride, nchannels, x, y; guchar *pixels, *p; bool bright_green, has_alpha; colormap = gdk_colormap_get_system(); gdk_color_black(colormap, &black); gdk_color_white(colormap, &white); shape->mask_bitmap = (GdkDrawable*)gdk_pixmap_new(NULL, shape->width, shape->height, 1); gc = gdk_gc_new(shape->mask_bitmap); gdk_gc_set_foreground(gc, &black); gdk_gc_set_background(gc, &white); gdk_draw_rectangle(shape->mask_bitmap, gc, TRUE, 0, 0, shape->width, shape->height); nchannels = gdk_pixbuf_get_n_channels(shape->pixbuf); g_assert(gdk_pixbuf_get_colorspace(shape->pixbuf) == GDK_COLORSPACE_RGB); g_assert(gdk_pixbuf_get_bits_per_sample(shape->pixbuf) == 8); has_alpha = gdk_pixbuf_get_has_alpha(shape->pixbuf); rowstride = gdk_pixbuf_get_rowstride(shape->pixbuf); pixels = gdk_pixbuf_get_pixels(shape->pixbuf); gdk_gc_set_foreground(gc, &white); gdk_gc_set_background(gc, &black); for (y = 0; y < shape->height; y++) { for (x = 0; x < shape->width; x++) { p = pixels + y*rowstride + x*nchannels; bright_green = 0 == p[0] && 255 == p[1] && 0 == p[2]; if (has_alpha) { if (255 == p[3]) // p[3] is alpha channel gdk_draw_point(shape->mask_bitmap, gc, x, y); } else if (!bright_green) { // Bright green is alpha for RGB images gdk_draw_point(shape->mask_bitmap, gc, x, y); } } } }
static void cdpattern(cdCtxCanvas *ctxcanvas, int w, int h, const long int *colors) { int x, y; GdkColor color; if (ctxcanvas->last_pattern == 0 || (ctxcanvas->last_pattern_w != w || ctxcanvas->last_pattern_h != h)) { if (ctxcanvas->last_pattern != 0) { g_object_unref(ctxcanvas->last_pattern); g_object_unref(ctxcanvas->last_pattern_gc); } ctxcanvas->last_pattern = gdk_pixmap_new(ctxcanvas->wnd, w, h, ctxcanvas->depth); if (!ctxcanvas->last_pattern) return; ctxcanvas->last_pattern_gc = gdk_gc_new((GdkDrawable*)ctxcanvas->last_pattern); ctxcanvas->last_pattern_w = w; ctxcanvas->last_pattern_h = h; } for (y = 0; y < h; y++) { for (x = 0; x < w; x++) { color = cdColorToGdk(colors[y*w+x]); gdk_gc_set_rgb_fg_color(ctxcanvas->last_pattern_gc, &color); gdk_draw_point(ctxcanvas->last_pattern, ctxcanvas->last_pattern_gc, x, h-y-1); } } cdinteriorstyle(ctxcanvas, CD_PATTERN); }
static VALUE rg_draw_point(VALUE self, VALUE gc, VALUE x, VALUE y) { gdk_draw_point(_SELF(self), GDK_GC(RVAL2GOBJ(gc)), NUM2INT(x), NUM2INT(y)); return self; }
/*! Display a point at the image point \e ip location. \param ip : Point location. \param color : Point color. */ void vpDisplayGTK::displayPoint ( const vpImagePoint &ip, const vpColor &color ) { if (displayHasBeenInitialized) { if (color.id < vpColor::id_unknown) gdk_gc_set_foreground(gc, col[color.id]); else { gdkcolor.red = 256 * color.R; gdkcolor.green = 256 * color.G; gdkcolor.blue = 256 * color.B; gdk_colormap_alloc_color(colormap,&gdkcolor,FALSE,TRUE); gdk_gc_set_foreground(gc, &gdkcolor); } gdk_draw_point(background,gc, vpMath::round( ip.get_u() ), vpMath::round( ip.get_v() ) ); } else { vpERROR_TRACE("GTK not initialized " ) ; throw(vpDisplayException(vpDisplayException::notInitializedError, "GTK not initialized")) ; } }
static GdkPixmap * scale_pixmap (GdkWindow *window, GdkPixmap *pixmap, gdouble scale_x, gdouble scale_y) { GdkGC *gc; GdkColormap *colormap; GdkColorContext *cc; GdkVisual *visual; GdkImage *image; GdkPixmap *new_pixmap; gint x, y, width, height, new_width, new_height; if(!pixmap) return NULL; if(!window) return NULL; gc = gdk_gc_new(pixmap); colormap = gdk_colormap_get_system (); visual = gdk_visual_get_system (); cc = gdk_color_context_new(visual, colormap); gdk_window_get_size(pixmap, &width, &height); if(scale_x == 1.0 && scale_y == 1.0){ new_pixmap = gdk_pixmap_new(window, width, height, -1); gdk_draw_pixmap(new_pixmap, gc, pixmap, 0, 0, 0, 0, width, height); return new_pixmap; } new_width = roundint(width * scale_x); new_height = roundint(height * scale_y); new_pixmap = gdk_pixmap_new(window, new_width, new_height, -1); image = gdk_image_get(pixmap, 0, 0, width, height); for(x = 0; x < new_width; x++){ for(y = 0; y < new_height; y++){ GdkColor color; gint px, py; px = MIN(roundint(x / scale_x), width - 1); py = MIN(roundint(y / scale_y), height - 1); color.pixel = gdk_image_get_pixel(image, px, py); gdk_color_context_query_color(cc, &color); gdk_gc_set_foreground(gc, &color); gdk_draw_point(new_pixmap, gc, x, y); } } gdk_image_destroy(image); gdk_color_context_free(cc); return new_pixmap; }
void SDC::DrawPoint(int x, int y) { #ifdef __WXGTK__ gdk_draw_point(m_gdkbmp, m_gc, x, y); #else Select(); LOGPEN lp; GetObject((HPEN)m_pen.GetResourceHandle(), sizeof(lp), &lp); SetPixel(m_gc, x, y, lp.lopnColor); #endif }
static void gtk_plot_gdk_draw_point (GtkPlotPC *pc, gdouble x, gdouble y) { if(!GTK_PLOT_GDK(pc)->gc) return; if(!GTK_PLOT_GDK(pc)->drawable) return; gdk_draw_point(GTK_PLOT_GDK(pc)->drawable, GTK_PLOT_GDK(pc)->gc, roundint(x), roundint(y)); }
/** * gimp_canvas_draw_point: * @canvas: a #GimpCanvas widget * @style: one of the enumerated #GimpCanvasStyle's. * @x: x coordinate * @y: y coordinate * * Draw a single pixel at the specified location in the specified * style. **/ void gimp_canvas_draw_point (GimpCanvas *canvas, GimpCanvasStyle style, gint x, gint y) { if (! gimp_canvas_ensure_style (canvas, style)) return; gdk_draw_point (GTK_WIDGET (canvas)->window, canvas->gc[style], x, y); }
static void draw (QCADDesignObject *obj, GdkDrawable *dst, GdkFunction rop, GdkRectangle *rcClip) { int Nix, Nix1 ; GdkGC *gc = NULL ; GdkRectangle rcReal ; GdkPoint ptSrc, ptDst ; QCADRectangleElectrode *rc_electrode = QCAD_RECTANGLE_ELECTRODE (obj) ; GdkColor *clr = NULL ; world_to_real_rect (&(obj->bounding_box), &rcReal) ; if (!RECT_INTERSECT_RECT (rcReal.x, rcReal.y, rcReal.width, rcReal.height, rcClip->x, rcClip->y, rcClip->width, rcClip->height)) return ; clr = obj->bSelected ? clr_idx_to_clr_struct (RED) : &(obj->clr) ; gc = gdk_gc_new (dst) ; gdk_gc_set_foreground (gc, clr) ; gdk_gc_set_background (gc, clr) ; gdk_gc_set_function (gc, rop) ; gdk_gc_set_clip_rectangle (gc, rcClip) ; ptSrc.x = world_to_real_x (rc_electrode->precompute_params.pt[0].xWorld) ; ptSrc.y = world_to_real_y (rc_electrode->precompute_params.pt[0].yWorld) ; ptDst.x = world_to_real_x (rc_electrode->precompute_params.pt[1].xWorld) ; ptDst.y = world_to_real_y (rc_electrode->precompute_params.pt[1].yWorld) ; gdk_draw_line (dst, gc, ptSrc.x, ptSrc.y, ptDst.x, ptDst.y) ; ptSrc = ptDst ; ptDst.x = world_to_real_x (rc_electrode->precompute_params.pt[2].xWorld) ; ptDst.y = world_to_real_y (rc_electrode->precompute_params.pt[2].yWorld) ; gdk_draw_line (dst, gc, ptSrc.x, ptSrc.y, ptDst.x, ptDst.y) ; ptSrc = ptDst ; ptDst.x = world_to_real_x (rc_electrode->precompute_params.pt[3].xWorld) ; ptDst.y = world_to_real_y (rc_electrode->precompute_params.pt[3].yWorld) ; gdk_draw_line (dst, gc, ptSrc.x, ptSrc.y, ptDst.x, ptDst.y) ; ptSrc = ptDst ; ptDst.x = world_to_real_x (rc_electrode->precompute_params.pt[0].xWorld) ; ptDst.y = world_to_real_y (rc_electrode->precompute_params.pt[0].yWorld) ; gdk_draw_line (dst, gc, ptSrc.x, ptSrc.y, ptDst.x, ptDst.y) ; for (Nix = 0 ; Nix < rc_electrode->n_x_divisions ; Nix++) for (Nix1 = 0 ; Nix1 < rc_electrode->n_y_divisions ; Nix1++) { ptSrc.x = world_to_real_x (exp_array_index_2d (rc_electrode->precompute_params.pts, WorldPoint, Nix1, Nix).xWorld) ; ptSrc.y = world_to_real_y (exp_array_index_2d (rc_electrode->precompute_params.pts, WorldPoint, Nix1, Nix).yWorld) ; if (PT_IN_RECT (ptSrc.x, ptSrc.y, rcClip->x, rcClip->y, rcClip->width, rcClip->height)) gdk_draw_point (dst, gc, ptSrc.x, ptSrc.y) ; } g_object_unref (gc) ; }
/* FIXME Draw a dotted grid over the specified area to make it look * insensitive. Actually, we should generate that pixbuf once and * just render it over later... */ static void draw_grid (GdkDrawable *drawable, GdkGC *gc, int x, int y, gint w, gint h) { int currentx; int currenty; for (currenty = y; currenty <= h; currenty++) for (currentx = ((currenty % 2 == 0) ? x : x + 1); currentx <= w; currentx += 2) gdk_draw_point (drawable, gc, currentx, currenty); }
static void draw_brush (GtkWidget *widget, gint x, gint y) { //GdkRectangle update_rect; //update_rect.x = x; //update_rect.y = y; //update_rect.width = 1; //update_rect.height = 1; /* Paint to the pixmap, where we store our state */ if (g_map[y][x]) { gdk_draw_point(pixmap, widget->style->black_gc, x, y); //gdk_draw_rectangle (pixmap, //widget->style->black_gc, //TRUE, //update_rect.x, update_rect.y, //update_rect.width, update_rect.height); } else { gdk_draw_point(pixmap, widget->style->white_gc, x, y); //gdk_draw_rectangle (pixmap, //widget->style->white_gc, //TRUE, //update_rect.x, update_rect.y, //update_rect.width, update_rect.height); } /* Now invalidate the affected region of the drawing area. */ //gdk_window_invalidate_rect (widget->window, //&update_rect, //FALSE); }
void dessiner_balise(balise* pt_balise,file_opener* donnees) { GdkDrawable* cartew=donnees->carte->window; if(pt_balise->affichage==1) { // printf("IF balise : Je change car affichage = %d\n", pt_balise->affichage); double x=conversion_longitude(pt_balise->longitude,donnees); double y=conversion_lat(pt_balise->latitude,donnees); gdk_draw_string(cartew,donnees->font,donnees->gc, donnees->xcarte*x+2,donnees->ycarte*y + 7, pt_balise->nom); gdk_draw_point(cartew,donnees->gc, donnees->xcarte*x,donnees->ycarte*y); } else { // printf("ELSE balise : Je change pas car affichage = %d\n", pt_balise->affichage); } }
/*! \brief Records a new point for the stroke. * \par Function Description * This function adds the point (<B>x</B>,<B>y</B>) as a new point in * the stroke. * * The footprint is updated and the new point is drawn on the drawing area. * * \param [in] w_current The GSCHEM_TOPLEVEL object. * \param [in] x The X coord of the new point. * \param [in] Y The X coord of the new point. */ void x_stroke_record (GSCHEM_TOPLEVEL *w_current, gint x, gint y) { g_assert (stroke_points != NULL); stroke_record (x, y); if (stroke_points->len < STROKE_MAX_POINTS) { StrokePoint point = { x, y }; g_array_append_val (stroke_points, point); gdk_gc_set_foreground (w_current->gc, x_get_color (STROKE_COLOR)); gdk_draw_point (w_current->window, w_current->gc, x, y); } }
static void cdpixel(cdCtxCanvas *ctxcanvas, int x, int y, long int color) { if (ctxcanvas->canvas->foreground != color) { GdkColor clr = cdColorToGdk(color); gdk_gc_set_rgb_fg_color(ctxcanvas->gc, &clr); } if (ctxcanvas->canvas->use_matrix) cdMatrixTransformPoint(ctxcanvas->xmatrix, x, y, &x, &y); /* Draw pixel */ gdk_draw_point(ctxcanvas->wnd, ctxcanvas->gc, x, y); if (ctxcanvas->canvas->foreground != color) gdk_gc_set_rgb_fg_color(ctxcanvas->gc, &ctxcanvas->fg); }
static void draw_point(GtkWidget* widget, int x, int y) { //GdkRectangle update_rect; //update_rect.x = x; //update_rect.y = y; //update_rect.width = 1; //update_rect.height = 1; //gdk_draw_rectangle (pixmap, //widget->style->dark_gc[1], //TRUE, //update_rect.x, update_rect.y, //update_rect.width, update_rect.height); gdk_draw_point(pixmap, widget->style->dark_gc[1], x, y); }
void on_edge1_menu_activate (const gchar *handler_name, GObject *object, const gchar *signal_name, const gchar *signal_data, GObject *connect_object, gboolean after, gpointer user_data) { GtkWidget *view; GtkWidget *draw; int i; gint width; gint height; START; i = 0; if(!vue_is_displayed[0]) { vue_is_displayed[0] = 1; uv_gtk_env->quasar_proj[0] = set_quasar_proj(uv_gtk_env, uv_gtk_env->quasar_pos,0); view = deglade("uv_view.glade", "uv_view"); draw = get_child(view, "uv_draw"); if (draw != NULL) { gtk_widget_show(draw); gtk_widget_get_size_request(draw, &width, &height); width = width/2; height = height/2; for(i = 0; i < uv_gtk_env->data_lenght; i++) { gdk_draw_point(draw->window, draw->style->black_gc, (int) (uv_gtk_env->quasar_proj[0][i].x*width+width), (int) (height-uv_gtk_env->quasar_proj[0][i].y*height) ); } gtk_widget_show(view); } else printf("GTK de merde !\n"); } }
void dessiner_aerodromes(aerodrome* pt_aero,file_opener* donnees) { GdkDrawable* cartew=donnees->carte->window; // Si l'affichage est autorisé if(pt_aero->affichage==1) { // On récupère on on converti les points double x=conversion_longitude(pt_aero->longitude,donnees); double y=conversion_lat(pt_aero->latitude,donnees); // On trace le point et le nom gdk_draw_string(cartew,donnees->font,donnees->gc, donnees->xcarte*x+2,donnees->ycarte*y + 7, pt_aero->oaci); gdk_draw_point(cartew,donnees->gc, donnees->xcarte*x,donnees->ycarte*y); } else { // printf("ELSE aero : Je change pas car affichage = %d\n", pt_aero->affichage); } }
gboolean draw_city_dots_timezone_map() { int i; GtkWidget *drawarea = lookup_widget(MainWindow,"drawingarea1"); GdkGC *gc = gdk_gc_new(drawarea->window); GdkColor color; gdk_color_parse("yellow",&color); gdk_colormap_alloc_color(gdk_colormap_get_system(),&color,TRUE,TRUE); gtk_widget_modify_fg(drawarea,GTK_STATE_NORMAL,&color); gdk_gc_set_foreground(gc,&color); for (i = 0; i < timezones_count; i++) { // debug("Drawing point %d %d of %s\n", // map2canvas_lon(timezones[i].lon,MAP_WIDTH), // map2canvas_lat(timezones[i].lat,MAP_HEIGHT), // timezones[i].tz); gdk_draw_point(drawarea->window,gc, map2canvas_lon(timezones[i].lon,MAP_WIDTH), map2canvas_lat(timezones[i].lat,MAP_HEIGHT)); } g_object_unref(gc); return TRUE; }
static void cdstipple(cdCtxCanvas *ctxcanvas, int w, int h, const unsigned char *data) { int x, y; if (ctxcanvas->last_stipple == 0 || (ctxcanvas->last_stipple_w != w || ctxcanvas->last_stipple_h != h)) { if (ctxcanvas->last_stipple != 0) { g_object_unref(ctxcanvas->last_stipple); g_object_unref(ctxcanvas->last_stipple_gc); } ctxcanvas->last_stipple = gdk_pixmap_new(ctxcanvas->wnd, w, h, 1); if (!ctxcanvas->last_stipple) return; ctxcanvas->last_stipple_gc = gdk_gc_new((GdkDrawable*)ctxcanvas->last_stipple); ctxcanvas->last_stipple_w = w; ctxcanvas->last_stipple_h = h; } for (y = 0; y < h; y++) { for (x = 0; x < w; x++) { GdkColor clr; if(data[y*w+x]) clr.pixel = 1; else clr.pixel = 0; gdk_gc_set_foreground(ctxcanvas->last_stipple_gc, &clr); gdk_draw_point(ctxcanvas->last_stipple, ctxcanvas->last_stipple_gc, x, h-y-1); } } cdinteriorstyle(ctxcanvas, CD_STIPPLE); }
/*! \brief Records a new point for the stroke. * \par Function Description * This function adds the point (<B>x</B>,<B>y</B>) as a new point in * the stroke. * * The footprint is updated and the new point is drawn on the drawing area. * * \param [in] w_current The GschemToplevel object. * \param [in] x The X coord of the new point. * \param [in] Y The X coord of the new point. */ void x_stroke_record (GschemToplevel *w_current, gint x, gint y) { GschemPageView *view = gschem_toplevel_get_current_page_view (w_current); g_return_if_fail (view != NULL); GdkGC *view_gc = gschem_page_view_get_gc (view); g_assert (stroke_points != NULL); stroke_record (x, y); if (stroke_points->len < STROKE_MAX_POINTS) { StrokePoint point = { x, y }; g_array_append_val (stroke_points, point); gdk_gc_set_foreground (view_gc, x_get_color (STROKE_COLOR)); gdk_draw_point (gtk_widget_get_window (GTK_WIDGET(view)), view_gc, x, y); } }
void ugui_putpixel(int x, int y, unsigned int color) { int dx,dy; GdkColor rgb; x += bound_x1; y += bound_y1; if (x > bound_x2 || y > bound_y2) return; gdk_threads_enter(); rgb.red = ((color >> 16) & 0xFF) * 0x101; rgb.green = ((color >> 8) & 0xFF) * 0x101; rgb.blue = ((color >> 0) & 0xFF) * 0x101; gdk_gc_set_rgb_fg_color(drawing_area->style->fg_gc[GTK_WIDGET_STATE (drawing_area)], &rgb ); for (dx = 0; dx<SCALE; dx++) for (dy = 0; dy<SCALE; dy++) gdk_draw_point(pixmap, drawing_area->style->fg_gc[GTK_WIDGET_STATE (drawing_area)], x*SCALE + dx, y*SCALE + dy); gdk_threads_leave(); }
void dessiner_pdv(pdv* pt_pdv_current, file_opener* donnees) { GdkDrawable* cartew=donnees->carte->window; if(pt_pdv_current->affichage==1) // Vérifie si le plan de vol doit être affiché { position* loc_avion=malloc(sizeof(position)); // Position_avion(donnees,pt_pdv_current,loc_avion); get_position_avion(loc_avion,pt_pdv_current,donnees->temps); loc_avion->y=conversion_lat(loc_avion->y,donnees)*donnees->ycarte; loc_avion->x=conversion_longitude(loc_avion->x,donnees)*donnees->xcarte; // On change la couleur du tracé pour le carré et le nom de l'avion couleur(donnees->gc,donnees->c,donnees->couleur_avion); gdk_draw_rectangle(cartew,donnees->gc,TRUE,loc_avion->x-2,loc_avion->y-2,5,5); gdk_draw_string(cartew,donnees->font,donnees->gc,loc_avion->x+3,loc_avion->y-2,pt_pdv_current->nom); couleur(donnees->gc,donnees->c,10); int x1=-9,x2=0,y1=0,y2=0; // Variables de stockage des coordonnées pour les points de passage pt_pass * pt_pass_current = pt_pdv_current->pass_debut; if(x1==-9 && pt_pass_current->ptsuiv!=NULL) // Cas du premier point { if(pt_pass_current->type_point==0) // Si le point est un aérodrome { aerodrome * pass_aerodrome = pt_pass_current->point; //printf("\n AERODROME 1 \n"); x1=conversion_longitude(pass_aerodrome->longitude,donnees)* donnees->xcarte; y1=conversion_lat(pass_aerodrome->latitude,donnees)* donnees->ycarte; // Affichage de l'aérodrome pass_aerodrome->affichage=1; dessiner_aerodromes(pass_aerodrome,donnees); } if(pt_pass_current->type_point==1) // Si le point est une balise { balise * pass_balise = pt_pass_current->point; // printf("\n BALISE 1 \n"); x1=conversion_longitude(pass_balise->longitude,donnees)* donnees->xcarte; y1=conversion_lat(pass_balise->latitude,donnees)* donnees->ycarte; // Affichage de la balise pass_balise->affichage=1; dessiner_balise(pass_balise,donnees); } if(pt_pass_current->type_point==2) // Si le point est une ptgpx { ptgpx * pass = pt_pass_current->point; // printf("\n BALISE 1 \n"); x1=conversion_longitude(pass->longitude,donnees)* donnees->xcarte; y1=conversion_lat(pass->latitude,donnees)* donnees->ycarte; // Affichage de la balise //gdk_draw_string(carte,font,gc, x1 + 2,y1 + 7, pass_balise->nom); gdk_draw_point(cartew,donnees->gc, x1,y1); } pt_pass_current = pt_pass_current->ptsuiv; } while(pt_pass_current->ptsuiv!=NULL) // Parcours de tous les autres points de passage { if(pt_pass_current->type_point==0) // Si le point est un aérodrome { aerodrome * pass_aerodrome = pt_pass_current->point; // printf("\n AERODROME \n"); x2=conversion_longitude(pass_aerodrome->longitude,donnees)* donnees->xcarte; y2=conversion_lat(pass_aerodrome->latitude,donnees)* donnees->ycarte; // Affichage de l'aerodrome pass_aerodrome->affichage=1; dessiner_aerodromes(pass_aerodrome,donnees); } if(pt_pass_current->type_point==1) // Si le point est une balise { balise * pass_balise = pt_pass_current->point; // printf("\n BALISE \n"); x2=conversion_longitude(pass_balise->longitude,donnees)* donnees->xcarte; y2=conversion_lat(pass_balise->latitude,donnees)* donnees->ycarte; // Affichage de la balise pass_balise->affichage=1; dessiner_balise(pass_balise,donnees); } if(pt_pass_current->type_point==2) // Si le point est un ptgpx { ptgpx * pass = pt_pass_current->point; x2=conversion_longitude(pass->longitude,donnees)* donnees->xcarte; y2=conversion_lat(pass->latitude,donnees)* donnees->ycarte; // Affichage de la balise int x=conversion_longitude(pass->longitude,donnees)* donnees->xcarte; int y=conversion_lat(pass->latitude,donnees)* donnees->ycarte; //gdk_draw_string(carte,font,gc, x + 2,y + 7, pass_balise->nom); gdk_draw_point(cartew,donnees->gc, x,y); } // Une couleur différente par avion couleur(donnees->gc,donnees->c,donnees->couleur_avion); // Trace la ligne et remet la couleur normalement. gdk_draw_line(cartew, donnees->gc, x1,y1,x2,y2); couleur(donnees->gc,donnees->c,10); // Le point 2 devient le point 1 x1=x2; y1=y2; pt_pass_current = pt_pass_current->ptsuiv; } free(loc_avion); } }
static void cl_draw_corner (GdkWindow *window, GtkWidget *widget, GtkStyle *style, int x, int y, int width, int height, CLRectangle *r, CLCornerSide corner) { GdkColor *color; GdkColor aacolor; /* anti-aliasing color */ GdkGCValues values; GdkColor tmp; GdkColor *bgcolor; int x1; int y1; if (r->corners[corner] == CL_CORNER_NONE) return; color = cl_get_gradient_corner_color (r, corner); gdk_gc_get_values (r->bordergc, &values); if (color == NULL) { tmp = values.foreground; gdk_colormap_query_color (gtk_widget_get_colormap(widget), values.foreground.pixel, &tmp); color = &tmp; } bgcolor = get_parent_bgcolor(widget); if (bgcolor == NULL) { bgcolor = color; } blend (style->colormap, bgcolor, color, &aacolor, 70); if (r->corners[corner] == CL_CORNER_ROUND) { x1 = (corner == CL_CORNER_TOPLEFT || corner == CL_CORNER_BOTTOMLEFT) ? x+1 : x+width - 2; y1 = (corner == CL_CORNER_TOPLEFT || corner == CL_CORNER_TOPRIGHT) ? y+1 : y+height - 2; gdk_gc_set_foreground (r->bordergc, color); gdk_draw_point (window, r->bordergc, x1, y1); gdk_gc_set_foreground (r->bordergc, &aacolor); x1 = (corner == CL_CORNER_TOPLEFT || corner == CL_CORNER_BOTTOMLEFT) ? x+1 : x+width-2; y1 = (corner == CL_CORNER_TOPLEFT || corner == CL_CORNER_TOPRIGHT) ? y : y+height-1; gdk_draw_point (window, r->bordergc, x1, y1); x1 = (corner == CL_CORNER_TOPLEFT || corner == CL_CORNER_BOTTOMLEFT) ? x : x+width-1; y1 = (corner == CL_CORNER_TOPLEFT || corner == CL_CORNER_TOPRIGHT) ? y+1 : y+height-2; gdk_draw_point (window, r->bordergc, x1, y1); } else if (r->corners[corner] == CL_CORNER_NARROW) { x1 = (corner == CL_CORNER_TOPLEFT || corner == CL_CORNER_BOTTOMLEFT) ? x : x+width-1; y1 = (corner == CL_CORNER_TOPLEFT || corner == CL_CORNER_TOPRIGHT) ? y : y+height-1; gdk_gc_set_foreground (r->bordergc, &aacolor); gdk_draw_point (window, r->bordergc, x1, y1); } gdk_gc_set_foreground (r->bordergc, &values.foreground); }
static GtkWidget * mnb_notification_gtk_create () { GtkWidget *widget = NULL; GtkWindow *window; GtkWidget *evbox; GdkPixbuf *pixbuf; img_normal = gtk_image_new_from_file (THEMEDIR "/notifiers/fscreen-notif-normal.png"); if (img_normal) g_object_ref (img_normal); img_hover = gtk_image_new_from_file (THEMEDIR "/notifiers/fscreen-notif-hover.png"); if (img_hover) g_object_ref (img_hover); widget = gtk_window_new (GTK_WINDOW_POPUP); window = GTK_WINDOW (widget); pixbuf = gdk_pixbuf_new_from_file (THEMEDIR "/notifiers/fscreen-notif-normal.png", NULL); if (pixbuf) { gint width, height, rowstride, channels; guchar *pixels; gint x, y; GdkDrawable *mask; GdkGC *gc; rowstride = gdk_pixbuf_get_rowstride (pixbuf); pixels = gdk_pixbuf_get_pixels (pixbuf); width = gdk_pixbuf_get_width (pixbuf); height = gdk_pixbuf_get_height (pixbuf); channels = gdk_pixbuf_get_n_channels (pixbuf); g_assert (channels == 4); mask = gdk_pixmap_new (NULL, width, height, 1); gc = gdk_gc_new (mask); for (x = 0; x < width; ++x) for (y = 0; y < height; ++y) { GdkColor clr; guchar *p = pixels + y * rowstride + x * channels; if (p[3] == 0) clr.pixel = 0; else clr.pixel = 1; gdk_gc_set_foreground (gc, &clr); gdk_draw_point (mask, gc, x, y); } gtk_widget_shape_combine_mask (widget, mask, 0, 0); g_object_unref (mask); g_object_unref (pixbuf); g_object_unref (gc); } gtk_window_set_decorated (window, FALSE); gtk_window_set_type_hint (window, GDK_WINDOW_TYPE_HINT_NOTIFICATION); gtk_window_set_resizable (window, FALSE); gtk_window_set_title (window, "mnb-notification-gtk"); gtk_window_set_accept_focus (window, FALSE); gtk_window_move (window, 20, 20); evbox = gtk_event_box_new (); gtk_event_box_set_visible_window (GTK_EVENT_BOX (evbox), FALSE); gtk_event_box_set_above_child (GTK_EVENT_BOX (evbox), TRUE); if (!img_normal) { gtk_container_add (GTK_CONTAINER (evbox), gtk_button_new_with_label ("Notifications")); } else { gtk_container_add (GTK_CONTAINER (evbox), img_normal); } gtk_container_add (GTK_CONTAINER (window), evbox); gtk_widget_show (evbox); g_signal_connect (evbox, "button-press-event", G_CALLBACK(mnb_notification_gtk_click_cb), NULL); if (img_normal && img_hover) { g_signal_connect (evbox, "enter-notify-event", G_CALLBACK(mnb_notification_gtk_crossing_cb), NULL); g_signal_connect (evbox, "leave-notify-event", G_CALLBACK(mnb_notification_gtk_crossing_cb), NULL); } return widget; }
void draw_grid(void) { scope_disp_t *disp; double xscale, yscale; int xmajor, xminor, ymajor, yminor; int nx, ny, m; double fx, fy; int x, y; disp = &(ctrl_usr->disp); /* set color to draw */ gdk_gc_set_foreground(disp->context, &(disp->color_grid)); /* calculate scale factors */ xscale = disp->width - 1.0; yscale = disp->height - 1.0; /* calculate grid spacings */ xmajor = xscale * 0.1; if (xmajor >= 40) { xminor = 10; } else if (xmajor >= 20) { xminor = 5; } else { xminor = xmajor / 4; } ymajor = yscale * 0.1; if (ymajor >= 40) { yminor = 10; } else if (ymajor >= 20) { yminor = 5; } else { yminor = ymajor / 4; } /* draw the vertical lines */ for (nx = 0; nx <= 10; nx++) { /* calc the major division x coordinate */ fx = nx * 0.1; for (ny = 0; ny <= 10; ny++) { /* calc the major division y coordinate */ fy = ny * 0.1; /* draw the major division point */ x = fx * xscale; y = fy * yscale; gdk_draw_point(disp->win, disp->context, x, y); /* draw minor divisions (vertical) */ if (ny < 10) { for (m = 1; m < yminor; m++) { y = (((0.1 * m) / yminor) + fy) * yscale; gdk_draw_point(disp->win, disp->context, x, y); } } /* draw minor divisions (horizontal) */ if (nx < 10) { y = fy * yscale; for (m = 1; m < xminor; m++) { x = (((0.1 * m) / xminor) + fx) * xscale; gdk_draw_point(disp->win, disp->context, x, y); } } } } }
void on_button_run_clicked (GtkButton *button, gpointer user_data) { // guard if(point_list.empty()) return; svm_parameter param; int i,j; // default values param.svm_type = C_SVC; param.kernel_type = RBF; param.degree = 3; param.gamma = 0; param.coef0 = 0; param.nu = 0.5; param.cache_size = 40; param.C = 1; param.eps = 1e-3; param.p = 0.1; param.shrinking = 1; param.nr_weight = 0; param.weight_label = NULL; param.weight = NULL; // parse options const char *p = gtk_entry_get_text(GTK_ENTRY(entry_option)); while (1) { while (*p && *p != '-') p++; if (*p == '\0') break; p++; switch (*p++) { case 's': param.svm_type = atoi(p); break; case 't': param.kernel_type = atoi(p); break; case 'd': param.degree = atof(p); break; case 'g': param.gamma = atof(p); break; case 'r': param.coef0 = atof(p); break; case 'n': param.nu = atof(p); break; case 'm': param.cache_size = atof(p); break; case 'c': param.C = atof(p); break; case 'e': param.eps = atof(p); break; case 'p': param.p = atof(p); break; case 'h': param.shrinking = atoi(p); break; case 'w': ++param.nr_weight; param.weight_label = (int *)realloc(param.weight_label,sizeof(int)*param.nr_weight); param.weight = (double *)realloc(param.weight,sizeof(double)*param.nr_weight); param.weight_label[param.nr_weight-1] = atoi(p); while(*p && !isspace(*p)) ++p; param.weight[param.nr_weight-1] = atof(p); break; } } // build problem svm_problem prob; prob.l = point_list.size(); prob.y = new double[prob.l]; if(param.svm_type == EPSILON_SVR || param.svm_type == NU_SVR) { if(param.gamma == 0) param.gamma = 1; svm_node *x_space = new svm_node[2 * prob.l]; prob.x = new svm_node *[prob.l]; i = 0; for (list <point>::iterator q = point_list.begin(); q != point_list.end(); q++, i++) { x_space[2 * i].index = 1; x_space[2 * i].value = q->x; x_space[2 * i + 1].index = -1; prob.x[i] = &x_space[2 * i]; prob.y[i] = q->y; } // build model & classify svm_model *model = svm_train(&prob, ¶m); svm_node x[2]; x[0].index = 1; x[1].index = -1; int *j = new int[XLEN]; for (i = 0; i < XLEN; i++) { x[0].value = (double) i / XLEN; j[i] = (int)(YLEN*svm_predict(model, x)); } gdk_gc_set_foreground(gc,&colors[0]); gdk_draw_line(pixmap,gc,0,0,0,YLEN-1); gdk_draw_line(draw_main->window,gc,0,0,0,YLEN-1); int p = (int)(param.p * YLEN); for(i = 1; i < XLEN; i++) { gdk_gc_set_foreground(gc,&colors[0]); gdk_draw_line(pixmap,gc,i,0,i,YLEN-1); gdk_draw_line(draw_main->window,gc,i,0,i,YLEN-1); gdk_gc_set_foreground(gc,&colors[5]); gdk_draw_line(pixmap,gc,i-1,j[i-1],i,j[i]); gdk_draw_line(draw_main->window,gc,i-1,j[i-1],i,j[i]); if(param.svm_type == EPSILON_SVR) { gdk_gc_set_foreground(gc,&colors[2]); gdk_draw_line(pixmap,gc,i-1,j[i-1]+p,i,j[i]+p); gdk_draw_line(draw_main->window,gc,i-1,j[i-1]+p,i,j[i]+p); gdk_gc_set_foreground(gc,&colors[2]); gdk_draw_line(pixmap,gc,i-1,j[i-1]-p,i,j[i]-p); gdk_draw_line(draw_main->window,gc,i-1,j[i-1]-p,i,j[i]-p); } } svm_destroy_model(model); delete[] j; delete[] x_space; delete[] prob.x; delete[] prob.y; } else { if(param.gamma == 0) param.gamma = 0.5; svm_node *x_space = new svm_node[3 * prob.l]; prob.x = new svm_node *[prob.l]; i = 0; for (list <point>::iterator q = point_list.begin(); q != point_list.end(); q++, i++) { x_space[3 * i].index = 1; x_space[3 * i].value = q->x; x_space[3 * i + 1].index = 2; x_space[3 * i + 1].value = q->y; x_space[3 * i + 2].index = -1; prob.x[i] = &x_space[3 * i]; prob.y[i] = q->value; } // build model & classify svm_model *model = svm_train(&prob, ¶m); svm_node x[3]; x[0].index = 1; x[1].index = 2; x[2].index = -1; for (i = 0; i < XLEN; i++) for (j = 0; j < YLEN; j++) { x[0].value = (double) i / XLEN; x[1].value = (double) j / YLEN; double d = svm_predict(model, x); gdk_gc_set_foreground(gc,&colors[(int)d]); gdk_draw_point(pixmap,gc,i,j); gdk_draw_point(draw_main->window,gc,i,j); } svm_destroy_model(model); delete[] x_space; delete[] prob.x; delete[] prob.y; } free(param.weight_label); free(param.weight); draw_all_points(); }
static void gtk_plot_gdk_draw_string (GtkPlotPC *pc, gint tx, gint ty, gint angle, const GdkColor *fg, const GdkColor *bg, gboolean transparent, gint border, gint border_space, gint border_width, gint shadow_width, const gchar *font_name, gint font_height, GtkJustification just, const gchar *text) { GdkBitmap *text_bitmap; GdkPixmap *text_pixmap; GdkBitmap *text_mask; GdkImage *image; GdkGC *gc, *bitmap_gc; GdkColormap *colormap; GdkColor white, black, mask_color; GList *family = NULL; gint y0; gint old_width, old_height; gboolean bold, italic; gint fontsize; gint ascent, descent; gint numf; gint xp = 0, yp = 0; gint width, height; gint x, y; gint i; GdkFont *font, *latin_font, *dfont; GtkPSFont *psfont, *base_psfont, *latin_psfont; gchar subs[2], insert_char; GdkWChar *aux, *wtext, *lastchar = NULL, *xaux; gchar num[4]; if(!GTK_PLOT_GDK(pc)->drawable) return; if(!GTK_PLOT_GDK(pc)->window) return; if(!GTK_PLOT_GDK(pc)->gc) return; if(!text || strlen(text) == 0) return; colormap = gdk_colormap_get_system (); gc = GTK_PLOT_GDK(pc)->gc; if(!gc) return; gtk_plot_text_get_size(text, angle, font_name, font_height, &width, &height, &ascent, &descent); if(height == 0 || width == 0) return; old_width = width; old_height = height; if(angle == 90 || angle == 270) { old_width = height; old_height = width; } gtk_psfont_get_families(&family, &numf); font = gtk_psfont_get_gdkfont(font_name, font_height); base_psfont = psfont = gtk_psfont_get_font(font_name); italic = psfont->italic; bold = psfont->bold; fontsize = font_height; x = 0; y0 = y = ascent; if (psfont->i18n_latinfamily) { latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily, italic, bold); latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname, fontsize); } else { latin_psfont = NULL; latin_font = NULL; } i = strlen(text) + 2; aux = wtext = g_malloc0(sizeof(GdkWChar) * i); gdk_mbstowcs(wtext, text, i - 1); /* initializing text bitmap - ajd */ text_bitmap = gdk_pixmap_new(GTK_PLOT_GDK(pc)->window, old_width, old_height, 1); bitmap_gc = gdk_gc_new(text_bitmap); gdk_color_white (colormap, &white); gdk_gc_set_foreground(bitmap_gc, &white); gdk_draw_rectangle(text_bitmap, bitmap_gc, TRUE, 0, 0, -1, -1); gdk_color_black (colormap, &black); gdk_gc_set_foreground(bitmap_gc, &black); while(aux && *aux != '\0' && *aux != '\n'){ if(*aux == '\\'){ aux++; switch(*aux){ case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '9': psfont = gtk_psfont_find_by_family((gchar *)g_list_nth_data(family, *aux-'0'), italic, bold); gdk_font_unref(font); font = gtk_psfont_get_gdkfont(psfont->psname, fontsize); if (latin_font) { gdk_font_unref(latin_font); latin_font = NULL; } aux++; break; case '8': case 'g': psfont = gtk_psfont_find_by_family("Symbol", italic, bold); gdk_font_unref(font); font = gtk_psfont_get_gdkfont(psfont->psname, fontsize); if (latin_font) { gdk_font_unref(latin_font); latin_font = NULL; } aux++; break; case 'B': bold = TRUE; psfont = gtk_psfont_find_by_family(psfont->family, italic, bold); gdk_font_unref(font); font = gtk_psfont_get_gdkfont(psfont->psname, fontsize); if (latin_font) { gdk_font_unref(latin_font); latin_font = NULL; } if (psfont->i18n_latinfamily) { latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily, italic, bold); latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname, fontsize); } aux++; break; case 'x': xaux = aux + 1; for (i=0; i<3; i++){ if (xaux[i] >= '0' && xaux[i] <= '9') num[i] = xaux[i]; else break; } if (i < 3){ aux++; break; } num[3] = '\0'; insert_char = (gchar)atoi(num); subs[0] = insert_char; subs[1] = '\0'; /* \xNNN is always outputted with latin fonts. */ dfont = (psfont->i18n_latinfamily != NULL) ? latin_font : font; gdk_draw_string (text_bitmap, dfont, bitmap_gc, x, y, subs); x += gdk_char_width(font, insert_char); aux += 4; lastchar = aux - 1; break; case 'i': italic = TRUE; psfont = gtk_psfont_find_by_family(psfont->family, italic, bold); gdk_font_unref(font); font = gtk_psfont_get_gdkfont(psfont->psname, fontsize); if (latin_font) { gdk_font_unref(latin_font); latin_font = NULL; } if (psfont->i18n_latinfamily) { latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily, italic, bold); latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname, fontsize); } aux++; break; case 'S': case '^': fontsize = (int)((gdouble)fontsize * 0.6 + 0.5); gdk_font_unref(font); font = gtk_psfont_get_gdkfont(psfont->psname, fontsize); y -= font->ascent; if (latin_font) { gdk_font_unref(latin_font); latin_font = NULL; } if (psfont->i18n_latinfamily) { latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily, italic, bold); latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname, fontsize); } aux++; break; case 's': case '_': fontsize = (int)((gdouble)fontsize * 0.6 + 0.5); gdk_font_unref(font); font = gtk_psfont_get_gdkfont(psfont->psname, fontsize); y += font->descent; if (latin_font) { gdk_font_unref(latin_font); latin_font = NULL; } if (psfont->i18n_latinfamily) { latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily, italic, bold); latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname, fontsize); } aux++; break; case '+': fontsize += 3; gdk_font_unref(font); font = gtk_psfont_get_gdkfont(psfont->psname, fontsize); if (latin_font) { gdk_font_unref(latin_font); latin_font = NULL; } if (psfont->i18n_latinfamily) { latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily, italic, bold); latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname, fontsize); } aux++; break; case '-': fontsize -= 3; gdk_font_unref(font); font = gtk_psfont_get_gdkfont(psfont->psname, fontsize); if (latin_font) { gdk_font_unref(latin_font); latin_font = NULL; } if (psfont->i18n_latinfamily) { latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily, italic, bold); latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname, fontsize); } aux++; break; case 'N': psfont = base_psfont; gdk_font_unref(font); fontsize = font_height; font = gtk_psfont_get_gdkfont(psfont->psname, fontsize); y = y0; italic = psfont->italic; bold = psfont->bold; if (latin_font) { gdk_font_unref(latin_font); latin_font = NULL; } if (psfont->i18n_latinfamily) { latin_psfont = gtk_psfont_find_by_family(psfont->i18n_latinfamily, italic, bold); latin_font = gtk_psfont_get_gdkfont(latin_psfont->psname, fontsize); } aux++; break; case 'b': if (lastchar) { gtk_psfont_get_char_size(psfont, font, latin_font, *lastchar, &i, NULL, NULL); x -= i; if (lastchar == wtext) lastchar = NULL; else lastchar--; } else { gtk_psfont_get_char_size(psfont, font, latin_font, 'X', &i, NULL, NULL); x -= i; } aux++; break; default: if(aux && *aux != '\0' && *aux !='\n'){ x += drawstring(pc, text_bitmap, bitmap_gc, &black, &white, x, y, psfont, font, latin_font, *aux); lastchar = aux; aux++; } break; } } else { if(aux && *aux != '\0' && *aux !='\n'){ x += drawstring(pc, text_bitmap, bitmap_gc, &black, &white, x, y, psfont, font, latin_font, *aux); lastchar = aux; aux++; } } } g_free(wtext); /* initializing clip mask bitmap - ajd */ text_mask = gdk_pixmap_new(GTK_PLOT_GDK(pc)->window, width, height, 1); mask_color = white; mask_color.pixel = 0; gdk_gc_set_foreground(bitmap_gc, &mask_color); gdk_draw_rectangle(text_mask, bitmap_gc, TRUE, 0, 0, -1, -1); mask_color = black; mask_color.pixel = 1; gdk_gc_set_foreground(bitmap_gc, &mask_color); /* performing text rotation and saving it onto clip mask bitmap - ajd */ image = gdk_image_get(text_bitmap, 0, 0, old_width, old_height); for(y = 0; y < old_height; y++) for(x = 0; x < old_width; x++) { if( black.pixel == gdk_image_get_pixel(image, x, y) ){ switch(angle){ case 0: xp = x; yp = y; break; case 90: xp = y; yp = old_width - x; break; case 180: xp = old_width - x; yp = old_height - y; break; case 270: xp = old_height - y; yp = x; break; } gdk_draw_point(text_mask, bitmap_gc, xp, yp); } } gdk_image_destroy(image); /* initializing text pixmap - ajd */ text_pixmap = gdk_pixmap_new(GTK_PLOT_GDK(pc)->window, width, height, -1); gdk_gc_set_foreground(gc, (GdkColor *) bg); gdk_draw_rectangle(text_pixmap, gc, TRUE, 0, 0, -1, -1); gdk_gc_set_foreground(gc, (GdkColor *) fg); /* copying clip mask bitmap onto text pixmap - ajd */ gdk_gc_set_clip_mask(gc, text_mask); gdk_gc_set_clip_origin(gc, 0, 0); gdk_draw_rectangle(text_pixmap, gc, TRUE, 0, 0, -1, -1); gdk_gc_set_clip_mask(gc, NULL); gtk_plot_text_get_area(text, angle, just, font_name, font_height, &x, &y, &width, &height); tx += x; ty += y; if(transparent){ gdk_gc_set_clip_mask (gc, text_mask); gdk_gc_set_clip_origin (gc, tx, ty); } else { gdk_gc_set_foreground(gc, (GdkColor *) bg); gtk_plot_pc_draw_rectangle(pc, TRUE, tx - border_space, ty - border_space, width + 2*border_space, height + 2*border_space); } gdk_draw_pixmap(GTK_PLOT_GDK(pc)->drawable, gc, text_pixmap, 0, 0, tx, ty, -1, -1); gdk_gc_set_clip_mask(gc, NULL); gdk_pixmap_unref(text_pixmap); gdk_bitmap_unref(text_mask); gdk_font_unref(font); if (latin_font) gdk_font_unref(latin_font); gdk_gc_unref(bitmap_gc); gdk_pixmap_unref(text_bitmap); /* border */ gdk_gc_set_foreground(gc, (GdkColor *) fg); gtk_plot_pc_set_dash(pc, 0, NULL, 0); gtk_plot_pc_set_lineattr(pc, border_width, 0, 0, 0); switch(border){ case GTK_PLOT_BORDER_SHADOW: gtk_plot_pc_draw_rectangle(pc, TRUE, tx - border_space + shadow_width, ty + height + border_space, width + 2 * border_space, shadow_width); gtk_plot_pc_draw_rectangle(pc, TRUE, tx + width + border_space, ty - border_space + shadow_width, shadow_width, height + 2 * border_space); case GTK_PLOT_BORDER_LINE: gtk_plot_pc_draw_rectangle(pc, FALSE, tx - border_space, ty - border_space, width + 2*border_space, height + 2*border_space); case GTK_PLOT_BORDER_NONE: default: break; } return; }
void draw_picture(GdkDrawable *gd) { int i; double WIDTH,HEIGHT,OriginX,OriginY,ScaleX,ScaleY; double Max_X,Min_X,Max_Y,Min_Y; double r; gT_M31 p; gT_M33 m1,m2,m3,m4; Max_X=50; Min_X=-50; Max_Y=160; Min_Y=-10; // 論理座標系の描画領域 WIDTH=Max_X-Min_X; HEIGHT=Max_Y-Min_Y; // 論理座標系の中心座標 OriginX=WIDTH/2.0-(Max_X+Min_X)/2; OriginY=HEIGHT/2.0+(Max_Y+Min_Y)/2; // スケールファクタの計算 ScaleX=(double)PICT_WIDTH/WIDTH, ScaleY=(double)PICT_HEIGHT/HEIGHT; // 変換行列の設定 m1=gM33Set(0.2,-0.26,0,0.23,0.22,24,0,0,1); m2=gM33Set(-0.15,0.28,0,0.26,0.24,6.6,0,0,1); m3=gM33Set(0,0,0,0,0.16,0,0,0,1); m4=gM33Set(0.85,0.04,0,-0.04,0.85,24,0,0,1); // 初期値の設定 p=gM31Set(0,0,1); /* 背景を白に設定 */ SetColor( 0xffff, 0xffff, 0xffff); gdk_gc_set_line_attributes( g_gc, 1, GDK_LINE_SOLID, GDK_CAP_BUTT, GDK_JOIN_ROUND ); gdk_draw_rectangle(gd,g_gc,TRUE,0,0,300,510); // 点の色を青に設定 SetColor( 0x0000, 0x0000, 0xffff); gdk_gc_set_line_attributes( g_gc, 1, GDK_LINE_SOLID, GDK_CAP_BUTT, GDK_JOIN_ROUND ); // 乱数の初期化 srand(time(NULL)); // 乱数の値によって変換行列を選択 for(i=0;i<MAX;i++){ r=rand()/(double)RAND_MAX; if(0<=r&&r<0.065) p=gM33xM31(m1,p); if(0.065<=r&&r<0.13) p=gM33xM31(m2,p); if(0.13<=r&&r<0.150) p=gM33xM31(m3,p); if(0.150<r&&r<=1) p=gM33xM31(m4,p); // 点の描画 gdk_draw_point(gd,g_gc,(OriginX+p.v[0])*ScaleX,(OriginY-p.v[1])*ScaleY); } }
wxBitmap wxBitmap::Rescale( int clipx, int clipy, int clipwidth, int clipheight, int newx, int newy ) { wxCHECK_MSG( Ok(), wxNullBitmap, wxT("invalid bitmap") ); if (newy==M_BMPDATA->m_width && newy==M_BMPDATA->m_height) return *this; int width = wxMax(newx, 1); int height = wxMax(newy, 1); width = wxMin(width, clipwidth); height = wxMin(height, clipheight); wxBitmap bmp; #ifdef __WXGTK20__ if (HasPixbuf()) { bmp.SetWidth(width); bmp.SetHeight(height); bmp.SetDepth(GetDepth()); bmp.SetPixbuf(gdk_pixbuf_new(GDK_COLORSPACE_RGB, gdk_pixbuf_get_has_alpha(GetPixbuf()), 8, width, height)); gdk_pixbuf_scale(GetPixbuf(), bmp.GetPixbuf(), 0, 0, width, height, clipx, clipy, (double)newx/GetWidth(), (double)newy/GetHeight(), GDK_INTERP_BILINEAR); } else #endif // __WXGTK20__ { GdkImage *img = (GdkImage*) NULL; if (GetPixmap()) img = gdk_image_get( GetPixmap(), 0, 0, GetWidth(), GetHeight() ); else if (GetBitmap()) img = gdk_image_get( GetBitmap(), 0, 0, GetWidth(), GetHeight() ); else wxFAIL_MSG( wxT("Ill-formed bitmap") ); wxCHECK_MSG( img, wxNullBitmap, wxT("couldn't create image") ); int bpp = -1; GdkGC *gc = NULL; GdkPixmap *dstpix = NULL; if (GetPixmap()) { GdkVisual *visual = gdk_window_get_visual( GetPixmap() ); if (visual == NULL) visual = wxTheApp->GetGdkVisual(); bpp = visual->depth; bmp = wxBitmap(width,height,bpp); dstpix = bmp.GetPixmap(); gc = gdk_gc_new( dstpix ); } char *dst = NULL; long dstbyteperline = 0; if (GetBitmap()) { bpp = 1; dstbyteperline = width/8*M_BMPDATA->m_bpp; if (width*M_BMPDATA->m_bpp % 8 != 0) dstbyteperline++; dst = (char*) malloc(dstbyteperline*height); } // be careful to use the right scaling factor float scx = (float)M_BMPDATA->m_width/(float)newx; float scy = (float)M_BMPDATA->m_height/(float)newy; // prepare accel-tables int *tablex = (int *)calloc(width,sizeof(int)); int *tabley = (int *)calloc(height,sizeof(int)); // accel table filled with clipped values for (int x = 0; x < width; x++) tablex[x] = (int) (scx * (x+clipx)); for (int y = 0; y < height; y++) tabley[y] = (int) (scy * (y+clipy)); // Main rescaling routine starts here for (int h = 0; h < height; h++) { char outbyte = 0; int old_x = -1; guint32 old_pixval = 0; for (int w = 0; w < width; w++) { guint32 pixval; int x = tablex[w]; if (x == old_x) pixval = old_pixval; else { pixval = gdk_image_get_pixel( img, x, tabley[h] ); old_pixval = pixval; old_x = x; } if (bpp == 1) { if (!pixval) { char bit=1; char shift = bit << w % 8; outbyte |= shift; } if ((w+1)%8==0) { dst[h*dstbyteperline+w/8] = outbyte; outbyte = 0; } } else { GdkColor col; col.pixel = pixval; gdk_gc_set_foreground( gc, &col ); gdk_draw_point( dstpix, gc, w, h); } } // do not forget the last byte if ((bpp == 1) && (width % 8 != 0)) dst[h*dstbyteperline+width/8] = outbyte; } gdk_image_destroy( img ); if (gc) gdk_gc_unref( gc ); if (bpp == 1) { bmp = wxBitmap( (const char *)dst, width, height, 1 ); free( dst ); } if (GetMask()) { dstbyteperline = width/8; if (width % 8 != 0) dstbyteperline++; dst = (char*) malloc(dstbyteperline*height); img = gdk_image_get( GetMask()->GetBitmap(), 0, 0, GetWidth(), GetHeight() ); for (int h = 0; h < height; h++) { char outbyte = 0; int old_x = -1; guint32 old_pixval = 0; for (int w = 0; w < width; w++) { guint32 pixval; int x = tablex[w]; if (x == old_x) pixval = old_pixval; else { pixval = gdk_image_get_pixel( img, x, tabley[h] ); old_pixval = pixval; old_x = x; } if (pixval) { char bit=1; char shift = bit << w % 8; outbyte |= shift; } if ((w+1)%8 == 0) { dst[h*dstbyteperline+w/8] = outbyte; outbyte = 0; } } // do not forget the last byte if (width % 8 != 0) dst[h*dstbyteperline+width/8] = outbyte; } wxMask* mask = new wxMask; mask->m_bitmap = gdk_bitmap_create_from_data( wxGetRootWindow()->window, (gchar *) dst, width, height ); bmp.SetMask(mask); free( dst ); gdk_image_destroy( img ); } free( tablex ); free( tabley ); } return bmp; }
static void _mt_draw_point(MT_WINDOW *win, MT_GC *gc, int x, int y) { _set_clipping(gc); gdk_draw_point((GdkWindow *)win, ((MT_GTK_GC *)gc)->gc, x, y); _unset_clipping(gc); }