Esempio n. 1
0
/* Queue a redraw of the dnd highlight rect */
static void
dnd_highlight_queue_redraw (GtkWidget *widget)
{
	NemoIconDndInfo *dnd_info;
	int width, height;
	GtkAllocation allocation;
	
	dnd_info = NEMO_ICON_CONTAINER (widget)->details->dnd_info;
	
	if (!dnd_info->highlighted) {
		return;
	}

	gtk_widget_get_allocation (widget, &allocation);
	width = allocation.width;
	height = allocation.height;

	/* we don't know how wide the shadow is exactly,
	 * so we expose a 10-pixel wide border
	 */
	gtk_widget_queue_draw_area (widget,
				    0, 0,
				    width, 10);
	gtk_widget_queue_draw_area (widget,
				    0, 0,
				    10, height);
	gtk_widget_queue_draw_area (widget,
				    0, height - 10,
				    width, 10);
	gtk_widget_queue_draw_area (widget,
				    width - 10, 0,
				    10, height);
}
Esempio n. 2
0
/**
 * gtk_image_tool_selector_set_selection:
 * @selector: a #GtkImageToolSelector
 * @rect: Selection rectangle in image space coordinates.
 *
 * Sets the selection rectangle for the tool. Setting this attribute
 * will cause the widget to immediately repaint itself if its view is
 * realized.
 *
 * This method does nothing under the following circumstances:
 *
 * <itemizedlist>
 *   <listitem>If the views pixbuf is %NULL.</listitem>
 *   <listitem>If @rect is wider or taller than the size of the
 *   pixbuf</listitem>
 *   <listitem>If @rect equals the current selection
 *   rectangle.</listitem>
 * </itemizedlist>
 *
 * If the selection falls outside the pixbufs area, its position is
 * moved so that it is within the pixbuf.
 *
 * Calling this method causes the ::selection-changed signal to be
 * emitted.
 *
 * The default selection is (0,0) - [0,0].
 **/
void
gtk_image_tool_selector_set_selection (GtkImageToolSelector *selector,
                                       GdkRectangle         *rect)
{
    GtkImageView *view = selector->view;
    GdkPixbuf *pixbuf = gtk_image_view_get_pixbuf (view);
    if (!pixbuf)
        return;

    int width = gdk_pixbuf_get_width (pixbuf);
    int height = gdk_pixbuf_get_height (pixbuf);
    if (rect->width > width || rect->height > height)
        return;

    rect->x = CLAMP (rect->x, 0, width - rect->width);
    rect->y = CLAMP (rect->y, 0, height - rect->height);
    if (gdk_rectangle_eq (*rect, selector->sel_rect))
        return;

    GdkRectangle wid_old = {0}, wid_new = {0};
    gtk_image_view_image_to_widget_rect (view, &selector->sel_rect, &wid_old);
    gtk_image_view_image_to_widget_rect (view, rect, &wid_new);

    selector->sel_rect = *rect;

    gtk_widget_queue_draw_area (GTK_WIDGET (view),
                                wid_old.x, wid_old.y,
                                wid_old.width, wid_old.height);
    gtk_widget_queue_draw_area (GTK_WIDGET (view),
                                wid_new.x, wid_new.y,
                                wid_new.width, wid_new.height);

    g_signal_emit (G_OBJECT (selector),
                   gtk_image_tool_selector_signals[0], 0);
}
Esempio n. 3
0
static void
gimp_ruler_queue_pos_redraw (GimpRuler *ruler)
{
  GimpRulerPrivate  *priv = GIMP_RULER_GET_PRIVATE (ruler);
  const GdkRectangle rect = gimp_ruler_get_pos_rect (ruler, priv->position);

  gtk_widget_queue_draw_area (GTK_WIDGET(ruler),
                              rect.x,
                              rect.y,
                              rect.width,
                              rect.height);

  if (priv->last_pos_rect.width != 0 || priv->last_pos_rect.height != 0)
    {
      gtk_widget_queue_draw_area (GTK_WIDGET(ruler),
                                  priv->last_pos_rect.x,
                                  priv->last_pos_rect.y,
                                  priv->last_pos_rect.width,
                                  priv->last_pos_rect.height);

      priv->last_pos_rect.x      = 0;
      priv->last_pos_rect.y      = 0;
      priv->last_pos_rect.width  = 0;
      priv->last_pos_rect.height = 0;
    }
}
Esempio n. 4
0
void Widget::invalidateRect(const IntRect& rect)
{
    if (data->suppressInvalidation)
        return;

    if (!parent()) {
        gtk_widget_queue_draw_area(GTK_WIDGET(containingWindow()), rect.x(), rect.y(),
                                   rect.width(), rect.height());
        if (isFrameView())
            static_cast<FrameView*>(this)->addToDirtyRegion(rect);
        return;
    }

    // Get the root widget.
    ScrollView* outermostView = parent();
    while (outermostView && outermostView->parent())
        outermostView = outermostView->parent();
    if (!outermostView)
        return;

    IntRect windowRect = convertToContainingWindow(rect);
    gtk_widget_queue_draw_area(GTK_WIDGET(containingWindow()), windowRect.x(), windowRect.y(),
                               windowRect.width(), windowRect.height());
    outermostView->addToDirtyRegion(windowRect);
}
Esempio n. 5
0
File: item.c Progetto: vtervo/gropes
void move_item(struct gropes_state *gs, struct map_state *ms,
	       struct item_on_screen *item, const struct gps_coord *pos,
	       struct gps_speed *speed)
{
	GdkRectangle *area;

	area = &item->area;

	if (pos == NULL) {
		/* If the position was already invalid, we don't have to
		 * do anything */
		item->pos_valid = item->on_screen = 0;
		if (item->update_info)
			item->update_info(ms, item);
	} else {
		GdkRectangle old_area;
		int was_valid;

		/* If the coordinates didn't change, we don't have to
		 * do anything */
		if (pos->la == item->pos.la &&
		    pos->lo == item->pos.lo &&
		    speed->speed == item->speed.speed &&
		    speed->track == item->speed.track &&
		    item->pos_valid)
			return;

		was_valid = item->pos_valid;
		item->pos_valid = 1;
		item->pos = *pos;
		item->speed = *speed;
		old_area = *area;
		if (item->update_info)
			item->update_info(ms, item);
		pthread_mutex_lock(&ms->mutex);
		calc_item_pos(gs, ms, item);
		item_save_track(item);
		pthread_mutex_unlock(&ms->mutex);
		/* Change map center if item is not on screen */
		if (gs->opt_follow_gps)
			change_map_center(gs, ms, &item->mpos, ms->scale);
		/* Now area contains the new item area */
		if (area->x == old_area.x && area->y == old_area.y &&
		    area->height == old_area.height &&
		    area->width == old_area.width)
			return;

		if (was_valid) {
			/* Invalidate old area */
			gtk_widget_queue_draw_area(ms->darea, old_area.x, old_area.y,
						   old_area.width, old_area.height);
		}
	}
	gtk_widget_queue_draw_area(ms->darea, area->x, area->y,
				   area->width, area->height);
}
Esempio n. 6
0
static void
screen_saver_update_state (ScreenSaver *screen_saver,
                           gdouble      time)
{
    GList *tmp;

    tmp = screen_saver->floaters;
    while (tmp != NULL)
    {
        ScreenSaverFloater *floater;
        floater = (ScreenSaverFloater *) tmp->data;

        screen_saver_floater_update_state (screen_saver, floater, time);

        if (GTK_WIDGET_REALIZED (screen_saver->drawing_area)
                && (floater->bounds.width > 0) && (floater->bounds.height > 0))
        {
            gint size;
            size = CLAMP ((int) (FLOATER_MAX_SIZE * floater->scale),
                          FLOATER_MIN_SIZE, FLOATER_MAX_SIZE);

            gtk_widget_queue_draw_area (screen_saver->drawing_area,
                                        floater->bounds.x,
                                        floater->bounds.y,
                                        floater->bounds.width,
                                        floater->bounds.height);

            /* the edges could concievably be spread across two
             * pixels so we add +2 to invalidated region
             */
            if (screen_saver->should_do_rotations)
                gtk_widget_queue_draw_area (screen_saver->drawing_area,
                                            (int) (floater->position.x -
                                                   .5 * G_SQRT2 * size),
                                            (int) (floater->position.y -
                                                   .5 * G_SQRT2 * size),
                                            G_SQRT2 * size + 2,
                                            G_SQRT2 * size + 2);
            else
                gtk_widget_queue_draw_area (screen_saver->drawing_area,
                                            (int) (floater->position.x -
                                                   .5 * size),
                                            (int) (floater->position.y -
                                                   .5 * size),
                                            size + 2, size + 2);

            if  (screen_saver->should_show_paths)
                gtk_widget_queue_draw (screen_saver->drawing_area);
        }

        tmp = tmp->next;
    }
}
Esempio n. 7
0
/* drawCar
 * Draws a car
 *
 * @return void
 */
void drawCar (int colorCarro, gint xant, gint yant, gint x, gint y, gint width, gint height) {
	GdkRectangle car;
	GdkColor color;
	switch(colorCarro){
		case 1: 
			gdk_color_parse("#FF0000", &color);
			break;
		case 2: 
			gdk_color_parse("#0000FF", &color);
			break;
		case 3: 
			gdk_color_parse("#00FF00", &color);
			break;
		case 4: 
			gdk_color_parse("#000000", &color);
			break;
		case 5:
			gdk_color_parse("#FFFFFF", &color);
			break;
		case 6: 
			gdk_color_parse("#FFFF00", &color);
			break;
		case 7: 
			gdk_color_parse("#FF6600", &color);
			break;
		case 8: 
			gdk_color_parse("#FF33CC", &color);
			break;
		case 9: 
			gdk_color_parse("#6699FF", &color);
			break;
		case 10: 
			gdk_color_parse("#777777", &color);
			break;
	}
	GdkGC* gcont;
	gcont = gdk_gc_new(this.pixMap); 
	gdk_gc_set_rgb_fg_color (gcont, &color);
	gtk_widget_queue_draw_area(this.drawingArea, xant, yant, width, height);
	car.x = x;
	car.y = y;
	car.width = width;
	car.height = height;
	gdk_draw_rectangle(this.pixMap, gcont, TRUE, car.x, car.y, car.width, car.height);
	if (colorCarro==4)
		gdk_draw_string(this.pixMap, gdk_font_load("-*-*-bold-r-normal--*-50-*-*-*-*-iso8859-1"), this.drawingArea->style->white_gc, (car.x+2), (car.y+10), "A1/5");
	else
		gdk_draw_string(this.pixMap, gdk_font_load("-*-*-bold-r-normal--*-50-*-*-*-*-iso8859-1"), this.drawingArea->style->black_gc, (car.x+2), (car.y+10), "A1/5");

	gtk_widget_queue_draw_area(this.drawingArea, car.x, car.y, car.width, car.height);
}
Esempio n. 8
0
static void nsgtk_tree_redraw_request(int x, int y, int width, int height, void *data)
{
	struct nsgtk_treeview *tw = data;
	
	gtk_widget_queue_draw_area(GTK_WIDGET(tw->drawing_area),
			x, y, width, height);
}
Esempio n. 9
0
void gtk_xournal_repaint_area(GtkWidget* widget, int x1, int y1, int x2,
                              int y2)
{
	g_return_if_fail(widget != NULL);
	g_return_if_fail(GTK_IS_XOURNAL(widget));

	GtkXournal* xournal = GTK_XOURNAL(widget);

	x1 -= xournal->x;
	x2 -= xournal->x;
	y1 -= xournal->y;
	y2 -= xournal->y;

	if (x2 < 0 || y2 < 0)
	{
		return; // outside visible area
	}

	GtkAllocation alloc = { 0 };
	gtk_widget_get_allocation(widget, &alloc);

	if (x1 > alloc.width || y1 > alloc.height)
	{
		return; // outside visible area
	}

	gtk_widget_queue_draw_area(widget, x1, y1, x2 - x1, y2 - y1);
}
Esempio n. 10
0
static void tile_fetched(const char *url, const char *filename,
			 gpointer data)
{
  char *nfname=g_strdup(filename);
  char *dot;
  GList *l=g_list_find_custom(tile_fetch_queue,url,mystrequal);
  struct mapwin *mw=(struct mapwin *)data;
  dot=strrchr(nfname,'.');
  if (dot) {
    dot[0]=0;
  }
  free_image_cache(nfname);
  g_free(nfname);
  if (mw) {
    gtk_widget_queue_draw_area(mw->map,0,0,
			       mw->page_width,
			       mw->page_height);
    mapwin_draw(mw,mw->map->style->fg_gc[mw->map->state],globalmap.first,
		mw->page_x,mw->page_y,0,0,mw->page_width,mw->page_height);
  }
  if (l) {
    free(l->data);
    tile_fetch_queue=g_list_remove_link(tile_fetch_queue,l);
    g_list_free(l);
  }
}
Esempio n. 11
0
/**
 * goc_canvas_invalidate:
 * @canvas: #GocCanvas
 * @x0: minimum x coordinate of the invalidated region in canvas coordinates
 * @y0: minimum y coordinate of the invalidated region in canvas coordinates
 * @x1: maximum x coordinate of the invalidated region in canvas coordinates
 * @y1: maximum y coordinate of the invalidated region in canvas coordinates
 *
 * Invalidates a region of the canvas. The canvas will be redrawn only if
 * the invalidated region intersects the visible area.
 **/
void
goc_canvas_invalidate (GocCanvas *canvas, double x0, double y0, double x1, double y1)
{
	if (!goc_canvas_get_realized (canvas))
		return;
#ifdef GOFFICE_WITH_GTK
	x0 = (x0 - canvas->scroll_x1) * canvas->pixels_per_unit;
	y0 = (y0 - canvas->scroll_y1) * canvas->pixels_per_unit;
	x1 = (x1 - canvas->scroll_x1) * canvas->pixels_per_unit;
	y1 = (y1 - canvas->scroll_y1) * canvas->pixels_per_unit;
	if (x0 < 0.)
		x0 = 0;
	if (y0 < 0)
		y0 = 0;
	if (x1 > canvas->width)
		x1 = canvas->width;
	if (y1 > canvas->height)
		y1 = canvas->height;
	if (canvas->direction == GOC_DIRECTION_RTL) {
		double tmp = x0;
		x0 = canvas->width - x1;
		x1 = canvas->width - tmp;
	}
	if (x1 > x0 && y1 > y0) /* invalidate with an extra one pixel wide margin */
		gtk_widget_queue_draw_area (GTK_WIDGET (canvas),
					    (int) floor (x0) - 1, (int) floor (y0) - 1,
					    (int) ceil (x1) - (int) floor (x0) + 2,
		                            (int) ceil (y1) - (int) floor (y0) + 2);
#endif
}
/* Draw a rectangle on the screen */
static void draw_brush( GtkWidget *widget,
                        gdouble    x,
                        gdouble    y)
{
	if( clear == 1 )
	{
   		a=breadth;b=height;p.x=0;p.y=0;
   		gtk_widget_queue_draw_area(widget,0,0,breadth,height);
 	}
 	else
 	{
 		p.x=x;a=rec1;b=rec2;
 		p.y=y;
  		gtk_widget_queue_draw_area(widget,x,y,rec1,rec2);
  	}
}
static void
inf_text_gtk_viewport_user_invalidate_user_area(InfTextGtkViewportUser* user)
{
  InfTextGtkViewportPrivate* priv;
  GtkWidget* scrollbar;

  priv = INF_TEXT_GTK_VIEWPORT_PRIVATE(user->viewport);

  if(priv->show_user_markers &&
     user->rectangle.width > 0 && user->rectangle.height > 0)
  {
    scrollbar = gtk_scrolled_window_get_vscrollbar(priv->scroll);

    /* During destruction of the widget it can happen that there is no
     * vertical scrollbar anymore, so check for it here. */
    if(scrollbar != NULL)
    {
      gtk_widget_queue_draw_area(
        scrollbar,
        user->rectangle.x,
        user->rectangle.y,
        user->rectangle.width,
        user->rectangle.height
      );
    }
  }
}
Esempio n. 14
0
static gboolean
qtcTreeViewLeave(GtkWidget *widget, GdkEventMotion *event, void *data)
{
    QTC_UNUSED(event);
    QTC_UNUSED(data);
    if (GTK_IS_TREE_VIEW(widget)) {
        QtCTreeView *tv = qtcTreeViewLookupHash(widget, false);
        if (tv) {
            GtkTreeView *treeView = GTK_TREE_VIEW(widget);
            QtcRect rect = {0, 0, -1, -1 };
            QtcRect alloc = qtcWidgetGetAllocation(widget);

            if (tv->path && tv->column) {
                gtk_tree_view_get_background_area(
                    treeView, tv->path, tv->column, (GdkRectangle*)&rect);
            }
            if (tv->fullWidth) {
                rect.x = 0;
                rect.width = alloc.width;
            }
            if (tv->path) {
                gtk_tree_path_free(tv->path);
            }
            tv->path = NULL;
            tv->column = NULL;

            gtk_tree_view_convert_bin_window_to_widget_coords(
                treeView, rect.x, rect.y, &rect.x, &rect.y);
            gtk_widget_queue_draw_area(
                widget, rect.x, rect.y, rect.width, rect.height);
        }
    }
    return false;
}
Esempio n. 15
0
static void init_rs_cb(GtkWidget *widget,
                       gpointer   data)
{
    InitializeGame();
    int x = 0;
    int y = 0;
    NodeType t;
    for (int i = 0; i <= 2; ++i) {
        t = (i == 1) ? Black : White;
        x = (BoardSize - 9) / 2 + rand() % 9;
        y = (BoardSize - 9) / 2 + rand() % 9;
        if (game.board[x][y] == Empty) {
            game.board[x][y] = t;
            DrawPiece(x, y, t);
        }
    }

    if (game.blackAI.id != 10) {
        Point p;
        p = game.blackAI.func(game.board, Black);
        game.Move(p);
        DrawPiece(p.x, p.y, Black);
    }
    GtkWidget* draw_area = (GtkWidget*) data;
    gtk_widget_queue_draw_area(draw_area, 0, 0, CanvasWidth, CanvasWidth);

}
Esempio n. 16
0
static VALUE
rg_queue_draw_area(VALUE self, VALUE x, VALUE y, VALUE width, VALUE height)
{
    gtk_widget_queue_draw_area(_SELF(self), NUM2INT(x), NUM2INT(y),
                               NUM2INT(width), NUM2INT(height));
    return self;
}
Esempio n. 17
0
static void gui_theme_changed(void)
{
	g_assert(legend_page != NULL);
	gtk_widget_queue_draw(legend_page);
	gtk_widget_queue_draw_area(gmap->area, 0, 0, gmap->width,
				   gmap->height);
}
Esempio n. 18
0
gboolean 
timer_anime ( gpointer user_data )
{

    static gboolean first_execution = TRUE;
	 GtkWidget  * widget = (GtkWidget * ) user_data;

    //use a safe function to get the value of currently_drawing so
    //we don't run into the usual multithreading issues
    int drawing_status = g_atomic_int_get(&currently_drawing);

    //if we are not currently drawing anything, launch a thread to 
    //update our pixmap
    if(drawing_status == 0){
        static pthread_t thread_info;
        int  iret;
        if(first_execution != TRUE){
            pthread_join(thread_info, NULL);
        }
        iret = pthread_create( &thread_info, NULL, do_draw, user_data);
    }

    //tell our window it is time to draw our animation.
    int width, height;
    gdk_drawable_get_size(pixmap, &width, &height);
    gtk_widget_queue_draw_area(widget, 0, 0, width, height);

    first_execution = FALSE;

    return TRUE;
}
Esempio n. 19
0
static gboolean
on_motion_notify_event (GtkWidget *window, GdkEventMotion *ev, gpointer user_data)
{
	AbiTable* table = static_cast<AbiTable*>(user_data);
	gboolean changed = FALSE;
	guint selected_cols;
	guint selected_rows;

	if (ev->x < 0 || ev->y < 0)
		return TRUE;
	
	pixels_to_cells(static_cast<guint>(ev->x), static_cast<guint>(ev->y), &selected_cols, &selected_rows);

	if ((selected_cols != table->selected_cols) || (selected_rows != table->selected_rows))
	{
		/* grow or shrink the table widget as necessary */
		table->selected_cols = selected_cols;
		table->selected_rows = selected_rows;

		if (table->selected_rows <= 0 || table->selected_cols <= 0)
			table->selected_rows = table->selected_cols = 0;

		table->total_rows = my_max(table->selected_rows + 1, 3);
		table->total_cols = my_max(table->selected_cols + 1, 3);

		abi_table_resize(table);
		gtk_widget_queue_draw_area (window, 0, 0, 
					    window->allocation.width, window->allocation.height);

		changed = TRUE;
	}

	return TRUE;
}
Esempio n. 20
0
gboolean timer_exe(GtkWidget * window){
    static int first_time = 1;
    //use a safe function to get the value of currently_drawing so
    //we don't run into the usual multithreading issues
    int drawing_status = g_atomic_int_get(&currently_drawing);

    //if this is the first time, create the drawing thread
    static pthread_t thread_info;
    if(first_time == 1){
        int  iret;
        iret = pthread_create( &thread_info, NULL, do_draw, NULL);
    }

    //if we are not currently drawing anything, send a SIGALRM signal
    //to our thread and tell it to update our pixmap
    if(drawing_status == 0){
        pthread_kill(thread_info, SIGALRM);
    }

    //tell our window it is time to draw our animation.
    int width, height;
    gdk_drawable_get_size(pixmap, &width, &height);
    gtk_widget_queue_draw_area(window, 0, 0, width, height);


    first_time = 0;
    return TRUE;

}
Esempio n. 21
0
void
splash_update (const gchar *text1,
               const gchar *text2,
               gdouble      percentage)
{
  GdkRectangle expose = { 0, 0, 0, 0 };

  g_return_if_fail (percentage >= 0.0 && percentage <= 1.0);

  if (! splash)
    return;

#ifdef STARTUP_TIMER
  splash_timer_elapsed (text1, text2, percentage);
#endif

  splash_position_layouts (splash, text1, text2, &expose);

  if (expose.width > 0 && expose.height > 0)
    gtk_widget_queue_draw_area (splash->area,
                                expose.x, expose.y,
                                expose.width, expose.height);

  gtk_progress_bar_set_fraction (GTK_PROGRESS_BAR (splash->progress),
                                 percentage);

  if (gtk_events_pending ())
    gtk_main_iteration ();
}
Esempio n. 22
0
static void PutPiece(GtkWidget *widget, 
                     GdkEventMotion *event, 
                     gpointer   data)
{
    if (game.winner == Empty && game.isBlackPlaying == (game.blackAI.id == 10)) {
        Point p(GetRowColFromPixel(event->x), GetRowColFromPixel(event->y));
        if (game.Move(p) == true) {
            DrawPiece(GetRowColFromPixel(event->x), GetRowColFromPixel(event->y), 
                    game.isBlackPlaying ? White : Black);
            gtk_widget_queue_draw_area(widget, 0, 0, CanvasWidth, CanvasWidth);
            if (game.CheckVictory() != Empty) {
                return;
            } else {
                if (game.isBlackPlaying) {
                    p = game.blackAI.func(game.board, Black);
                    game.Move(p);
                    DrawPiece(p.x, p.y, Black);
                } else {
                    p = game.whiteAI.func(game.board, White);
                    game.Move(p);
                    DrawPiece(p.x, p.y, White);
                }
                if (game.CheckVictory() != Empty)
                    return;
            }
        }
    }
}
Esempio n. 23
0
/* Pøidání textového popisu události do seznamu zachycených událostí we
 * widgetu */
static void gtk_ev_push_text(GtkEv *ev, const gchar* text)
{  
    g_return_if_fail(ev);
    
    if(text) {
        gchar** event; 
        
        event = g_strsplit(text, "\n", 10);
        ev->list = g_list_prepend(ev->list, event);
        ev->list_len ++;
        
        if(ev->list_end == NULL)
            ev->list_end = ev->list;
       
       if(ev->list_len > 100) {
           GList* prev = ev->list_end->prev;
           
           prev->next = NULL;
           g_strfreev(ev->list_end->data);
           g_list_free_1(ev->list_end);
           ev->list_end = prev;
           ev->list_len--;
         }
     }

    if(GTK_WIDGET_DRAWABLE(ev))
        gtk_widget_queue_draw_area(GTK_WIDGET(ev), ev->list_rect.x,
                                   ev->list_rect.y, ev->list_rect.width,
                                   ev->list_rect.height);
}
Esempio n. 24
0
static void draw_brush(GtkWidget *widget, gdouble x, gdouble y) {
    cairo_t *cr = cairo_create(surface);
    cairo_rectangle(cr, x - 3, y - 3, 6, 6);
    cairo_fill(cr);
    cairo_destroy(cr);
    gtk_widget_queue_draw_area(widget, x - 3, y - 3, 6, 6);
}
Esempio n. 25
0
static void pidgin_whiteboard_draw_brush_point(PurpleWhiteboard *wb, int x, int y, int color, int size)
{
	PidginWhiteboard *gtkwb = wb->ui_data;
	GtkWidget *widget = gtkwb->drawing_area;
	GdkPixmap *pixmap = gtkwb->pixmap;

	cairo_t *gfx_con = g_object_get_data(G_OBJECT(pixmap), "cairo-context");
	GdkColor col;

	/* Interpret and convert color */
	pidgin_whiteboard_rgb24_to_rgb48(color, &col);

	gdk_cairo_set_source_color(gfx_con, &col);

	/* Draw a circle */
	cairo_arc(gfx_con,
	          x, y,
	          size / 2.0,
	          0.0, 2.0 * M_PI);
	cairo_fill(gfx_con);

	gtk_widget_queue_draw_area(widget,
							   x - size / 2, y - size / 2,
							   size, size);
}
Esempio n. 26
0
static void remmina_rdp_call_feature(RemminaProtocolWidget* gp, const RemminaProtocolFeature* feature)
{
    RemminaFile* remminafile;
    rfContext* rfi;

    rfi = GET_DATA(gp);
    remminafile = remmina_plugin_service->protocol_plugin_get_file(gp);

    switch (feature->id)
    {
    case REMMINA_RDP_FEATURE_UNFOCUS:
        remmina_rdp_event_unfocus(gp);
        break;

    case REMMINA_RDP_FEATURE_SCALE:
        rfi->scale = remmina_plugin_service->file_get_int(remminafile, "scale", FALSE);
        remmina_rdp_event_update_scale(gp);
        break;

    case REMMINA_RDP_FEATURE_TOOL_REFRESH:
        gtk_widget_queue_draw_area(rfi->drawing_area, 0, 0,
                                   remmina_plugin_service->protocol_plugin_get_width(gp),
                                   remmina_plugin_service->protocol_plugin_get_height(gp));
        break;

    default:
        break;
    }
}
Esempio n. 27
0
void draw_area (view_struct *vs) {
	if (vs->calc_buf)
		(*vs->calc_buf) (vs->external_data, vs->buf8, vs->width, vs->height);

	// This calls an expose_event for vs->area:
	gtk_widget_queue_draw_area ( vs->area, 0, 0, vs->width, vs->height);
}
/* Draw a rectangle on the screen, size depending on pressure,
   and color on the type of device */
static void
draw_brush (GtkWidget *widget, GdkInputSource source,
            gdouble x, gdouble y, gdouble pressure)
{
  GdkGC *gc;
  GdkRectangle update_rect;

  switch (source)
    {
    case GDK_SOURCE_MOUSE:
      gc = widget->style->dark_gc[gtk_widget_get_state (widget)];
      break;
    case GDK_SOURCE_PEN:
      gc = widget->style->black_gc;
      break;
    case GDK_SOURCE_ERASER:
      gc = widget->style->white_gc;
      break;
    default:
      gc = widget->style->light_gc[gtk_widget_get_state (widget)];
    }

  update_rect.x = x - 10 * pressure;
  update_rect.y = y - 10 * pressure;
  update_rect.width = 20 * pressure;
  update_rect.height = 20 * pressure;
  gdk_draw_rectangle (pixmap, gc, TRUE,
                      update_rect.x, update_rect.y,
                      update_rect.width, update_rect.height);
  gtk_widget_queue_draw_area (widget, 
                      update_rect.x, update_rect.y,
                      update_rect.width, update_rect.height);
}
Esempio n. 29
0
void
gtku_gl_drawing_area_invalidate (GtkuGLDrawingArea * self)
{
    GtkWidget * widget = GTK_WIDGET (self);
    gtk_widget_queue_draw_area (widget, 0, 0,
            widget->allocation.width, widget->allocation.height);
}
Esempio n. 30
0
 virtual bool queue_draw_area(gint x,gint y, gint width,gint height) {
     widget_attached_t detached = 0;
     if ((detached = this->attached_to())) {
         gtk_widget_queue_draw_area(detached, x,y, width,height);
         return true;
     }
     return false;
 }