void draw_rubberbox(GtkWidget *drawing_area, GdkRect rect) { GdkRect c; GdkRect oc; GdkRect update_rect; c = rect; oc = old_rect; if ((c.x > skin_infos.width) || (c.y > skin_infos.height) || ((c.x + c.w) > skin_infos.width) || ((c.y + c.h) > skin_infos.height)) return; g_object_unref(pixbuf); pixbuf = gdk_pixbuf_copy(skin_infos.img_orig); draw_hline(c.x, c.y, c.w); draw_hline(c.x, c.y + c.h, c.w); draw_vline(c.x, c.y, c.h); draw_vline(c.x + c.w, c.y, c.h); /* * 2 calls to SDL_UpdateRect : * + erase the old rect * + draw the new one * * We could composite a new rectangle with the new and old ones, * but this would consume more resources than these 2 calls. * Plus it would complicate the code. *sigh* */ update_rect.x = oc.x; update_rect.y = oc.y; update_rect.w = ((oc.w + oc.x + 1) <= skin_infos.width) ? (oc.w + 1) : oc.w; /* add 2 to really erase the lines (right, bottom) ... */ update_rect.h = ((oc.h + oc.y + 1) <= skin_infos.height) ? (oc.h + 1) : oc.h; /* ... but be careful */ gtk_widget_draw (drawing_area, (GdkRectangle *)(&update_rect)); update_rect.x = c.x; update_rect.y = c.y; update_rect.w = ((c.w + c.x + 1) <= skin_infos.width) ? (c.w + 1) : c.w; /* add 2 to really erase the lines (right, bottom) ... */ update_rect.h = ((c.h + c.y + 1) <= skin_infos.height) ? (c.h + 1) : c.h; /* ... but be careful */ gtk_widget_draw (drawing_area, (GdkRectangle *)&update_rect); tmp_rect = rect; /* when called from callbacks.c (for LCD or keys) */ old_rect = rect; /* save coords */ }
void cartesianMover::cartesian_line_click(GtkTreeView *tree_view, GtkTreePath *path, GtkTreeViewColumn *column, cartesianMover *cm) { ICartesianControl *icrt = cm->crt; int *i = gtk_tree_path_get_indices (path); //double currPos[NUMBER_OF_CARTESIAN_COORDINATES]; Vector x; Vector axis; if(!icrt->getPose(x,axis)) fprintf(stderr, "Troubles in getting the cartesian pose for %s", cm->partLabel); Matrix R = axis2dcm(axis); Vector eu = dcm2euler(R); //fprintf(stderr, "Storing euler angles: %s...", eu.toString().c_str()); //fprintf(stderr, "...corrsponding to axis: %s", axis.toString().c_str()); for (int k =0; k < NUMBER_OF_CARTESIAN_COORDINATES; k++) { if(k<3) cm->STORED_POS[*i][k] = x(k); else cm->STORED_POS[*i][k] = eu(k-3)*180/M_PI; } gtk_tree_view_set_model (GTK_TREE_VIEW (tree_view), refresh_cartesian_list_model(cm)); gtk_widget_draw(GTK_WIDGET(tree_view), NULL); return; }
void gl_window_change_orientation(GtkGLArea *glarea, o_enum orientation) { gl_window_info *info; GdkRectangle area; info = gtk_object_get_data(GTK_OBJECT(glarea), "info"); if (gtk_gl_area_make_current(GTK_GL_AREA(glarea))){ //if changing to 3d or texture orientation if(orientation == ORIENTATION_3D || orientation == ORIENTATION_TEXTURE ){ glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); glShadeModel(GL_SMOOTH); glClearColor(0.2, 0.5, 0.7, 1.0); glClearDepth(1); }else{ glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); glClearColor(0.6, 0.6, 0.6, 1); } } info->orientation = orientation; area.x = 0; area.y = 0; area.width = GTK_WIDGET (glarea)->allocation.width; area.height = GTK_WIDGET (glarea)->allocation.height; //orientation changed, redraw gtk_widget_draw(GTK_WIDGET (glarea), &area); }
gboolean draw_down (GtkScrollbox *self) { GdkRectangle update_rect = {0, 0, GTK_WIDGET(self)->allocation.width, GTK_WIDGET(self)->allocation.height}; XFCE_PANEL_LOCK(); if (self->draw_offset == self->draw_maxoffset) { self->draw_timeout = 0; start_draw_up(self); XFCE_PANEL_UNLOCK(); return FALSE; } else self->draw_offset--; gtk_widget_draw(GTK_WIDGET(self), &update_rect); XFCE_PANEL_UNLOCK(); return TRUE; }
static void close_button_class_init(CloseButtonClass* klass) { GTK_WIDGET_CLASS(klass)->draw = [] (GtkWidget* self, cairo_t* cr) { gtk_widget_draw(GTK_WIDGET(CLOSE_BUTTON(self)->priv->img), cr); return TRUE; }; GTK_WIDGET_CLASS(klass)->state_flags_changed = [] (GtkWidget* self, GtkStateFlags prev_state) { auto* img = CLOSE_BUTTON(self)->priv->img; if (!img) return; auto new_flags = gtk_widget_get_state_flags(self); auto const& deco_style = decoration::Style::Get(); auto file = deco_style->ThemedFilePath(CLOSE_BUTTON_INACTIVE_FILE, {PKGDATADIR"/"}); if (((new_flags & GTK_STATE_FLAG_PRELIGHT) && !gtk_widget_get_can_focus(self)) || (new_flags & GTK_STATE_FLAG_FOCUSED)) { auto const& basename = (new_flags & GTK_STATE_FLAG_ACTIVE) ? CLOSE_BUTTON_ACTIVE_FILE : CLOSE_BUTTON_FOCUSED_FILE; file = deco_style->ThemedFilePath(basename, {PKGDATADIR"/"}); } gtk_image_set_from_file(img, file.c_str()); return GTK_WIDGET_CLASS(close_button_parent_class)->state_flags_changed(self, prev_state); }; G_OBJECT_CLASS(klass)->finalize = [] (GObject* self) { CLOSE_BUTTON(self)->priv->img = nullptr; return G_OBJECT_CLASS(close_button_parent_class)->finalize(self); }; }
static void gtk_check_item_draw (GtkWidget *widget, GdkRectangle *area) { GtkCheckItem *check_item; GtkToggleButton *toggle_button; GtkBin *bin; GdkRectangle child_area; g_return_if_fail (widget != NULL); g_return_if_fail (GTK_IS_CHECK_ITEM (widget)); g_return_if_fail (area != NULL); check_item = GTK_CHECK_ITEM (widget); toggle_button = GTK_TOGGLE_BUTTON (widget); bin = GTK_BIN (widget); if (GTK_WIDGET_DRAWABLE (widget)) { if (toggle_button->draw_indicator) { gtk_check_item_paint (widget, area); if (bin->child && gtk_widget_intersect (bin->child, area, &child_area)) gtk_widget_draw (bin->child, &child_area); } else { if (GTK_WIDGET_CLASS (parent_class)->draw) (* GTK_WIDGET_CLASS (parent_class)->draw) (widget, area); } } }
static gboolean _gradient_slider_button_release(GtkWidget *widget, GdkEventButton *event) { GtkDarktableGradientSlider *gslider=DTGTK_GRADIENT_SLIDER(widget); if( event->button==1 && gslider->selected != -1 && gslider->do_reset==FALSE ) { // First get some dimention info gslider->is_changed=TRUE; gdouble newposition = roundf(_screen_to_scale(widget, event->x)/gslider->increment)*gslider->increment; newposition = CLAMP_RANGE(newposition, 0.0, 1.0); gint direction = gslider->position[gslider->selected] <= newposition ? MOVE_RIGHT : MOVE_LEFT; _slider_move(widget, gslider->selected, newposition, direction); gslider->min = gslider->selected == 0 ? 0.0f : gslider->position[gslider->selected-1]; gslider->max = gslider->selected == gslider->positions-1 ? 1.0f : gslider->position[gslider->selected+1]; gtk_widget_draw(widget,NULL); gslider->prev_x_root = event->x_root; gslider->is_dragging=FALSE; g_signal_emit_by_name(G_OBJECT(widget),"value-changed"); } return TRUE; }
gboolean draw_up (GtkScrollbox *self) { GdkRectangle update_rect = {0,0, GTK_WIDGET(self)->allocation.width, GTK_WIDGET(self)->allocation.height}; XFCE_PANEL_LOCK(); if (self->draw_offset == 0) { self->draw_timeout = g_timeout_add(LABEL_REFRESH, (GSourceFunc)start_draw_down, self); XFCE_PANEL_UNLOCK(); return FALSE; } else self->draw_offset++; gtk_widget_draw(GTK_WIDGET(self), &update_rect); XFCE_PANEL_UNLOCK(); return TRUE; }
static void gtk_pizza_draw (GtkWidget *widget, GdkRectangle *area) { GtkPizza *pizza; GtkPizzaChild *child; GdkRectangle child_area; GList *children; g_return_if_fail (widget != NULL); g_return_if_fail (GTK_IS_PIZZA (widget)); pizza = GTK_PIZZA (widget); /* Sometimes, We handle all expose events in window.cpp now. */ if (pizza->external_expose) return; children = pizza->children; if ( !(GTK_WIDGET_APP_PAINTABLE (widget)) && (pizza->clear_on_draw)) { gdk_window_clear_area( pizza->bin_window, area->x, area->y, area->width, area->height); } while (children) { child = children->data; children = children->next; if (gtk_widget_intersect (child->widget, area, &child_area)) gtk_widget_draw (child->widget, &child_area); } }
static void gtk_form_draw(GtkWidget *widget, GdkRectangle *area) { GtkForm *form; GList *children; GtkFormChild *child; GdkRectangle child_area; g_return_if_fail(GTK_IS_FORM(widget)); if (GTK_WIDGET_DRAWABLE(widget)) { form = GTK_FORM(widget); children = form->children; while (children) { child = children->data; if (GTK_WIDGET_DRAWABLE(child->widget) && gtk_widget_intersect(child->widget, area, &child_area)) gtk_widget_draw(child->widget, &child_area); children = children->next; } } }
static void awt_gtk_panel_draw (GtkWidget *widget, GdkRectangle *area) { AWTGtkPanel *panel; GtkWidget *child; GdkRectangle child_area; GList *children; g_return_if_fail (widget != NULL); if (GTK_WIDGET_DRAWABLE (widget)) { panel = AWT_GTK_PANEL (widget); awt_gtk_panel_paint (widget, area); children = panel->children; while (children) { child = children->data; children = children->next; if (gtk_widget_intersect (child, area, &child_area)) gtk_widget_draw (child, &child_area); } } }
static void new_game (void) { fill_board (); set_score (0); gtk_widget_draw (draw_area, NULL); }
void x_update_input (WInput *in) { GnomeEntry *gnome_entry; GtkEntry *entry; char *text; int draw = 0; /* If the widget has not been initialized yet (done by WIDGET_INIT) */ if (!in->widget.wdata) return; #ifdef USE_GNOME_ENTRY gnome_entry = GNOME_ENTRY (in->widget.wdata); entry = GTK_ENTRY (gnome_entry_gtk_entry (gnome_entry)); #else entry = GTK_ENTRY (in->widget.wdata); #endif if (in->first == -1){ gtk_editable_select_region (GTK_EDITABLE (entry), 0, 0); in->first = 0; } text = gtk_entry_get_text (GTK_ENTRY (entry)); if (text && strcmp (text, in->buffer)){ gtk_entry_set_text (entry, in->buffer); draw = 1; } if (GTK_EDITABLE (entry)->current_pos != in->point){ gtk_entry_set_position (entry, in->point); draw = 1; } if (draw){ #ifdef USE_GNOME_ENTRY gtk_widget_draw (GTK_WIDGET (gnome_entry), NULL); #else gtk_widget_draw (GTK_WIDGET (entry), NULL); #endif gtk_editable_changed (GTK_EDITABLE (entry)); gtk_widget_queue_draw (GTK_WIDGET (entry)); } }
void start_draw_up(GtkScrollbox *self) { gint width, height; struct label *lbl; static int i = 0; GtkWidget *widget = (GtkWidget *)self; XFCE_PANEL_LOCK(); if (self->labels->len == 0) { XFCE_PANEL_UNLOCK(); return; } if (i >= self->labels->len) i = 0; lbl = (struct label*)g_ptr_array_index(self->labels, i); self->pixmap = lbl->pixmap; /* If we failed to create a proper pixmap, try again now */ if (!lbl->pixmap) { lbl->pixmap = make_pixmap(self, lbl->msg); if (!lbl->pixmap) { /* Still no pixmap. We need to restart the timer */ if (self->draw_timeout) stop_callback(self); self->draw_timeout = g_timeout_add(LABEL_SPEED, (GSourceFunc)start_draw_up, self); XFCE_PANEL_UNLOCK(); return; } } if (self->labels->len == 1) { GdkRectangle update_rect = {0, 0, GTK_WIDGET(self)->allocation.width, GTK_WIDGET(self)->allocation.height}; self->pixmap = lbl->pixmap; self->draw_offset = 0; gtk_widget_draw(GTK_WIDGET(self), &update_rect); XFCE_PANEL_UNLOCK(); return; } gdk_drawable_get_size(GDK_DRAWABLE(self->pixmap), &width, &height); self->draw_middle = self->draw_maxmiddle - width / 2; self->draw_timeout = g_timeout_add(LABEL_SPEED, (GSourceFunc)draw_up, self); i++; XFCE_PANEL_UNLOCK(); }
static gboolean _gradient_slider_leave_notify_event(GtkWidget *widget, GdkEventCrossing *event) { GtkDarktableGradientSlider *gslider=DTGTK_GRADIENT_SLIDER(widget); gtk_widget_set_state(widget,GTK_STATE_NORMAL); gslider->is_entered = FALSE; gtk_widget_draw(widget,NULL); DTGTK_GRADIENT_SLIDER(widget)->prev_x_root=event->x_root; return FALSE; }
static void refresh(UNUSED void* arg) { GdkRectangle update_rect; update_rect.x = 0; update_rect.y = 0; update_rect.width = SIZEX * SCALE; update_rect.height = SIZEY * SCALE; // aostk_draw(); gtk_widget_draw (drawing_area, &update_rect); }
void UpdatePreview( bool DataChange ){ if ( g_pWndPreview && GTK_WIDGET_VISIBLE( g_pWndPreview ) ) { if ( DataChange ) { GenerateXYZ(); } gtk_widget_draw( g_pPreviewWidget, NULL ); } }
void UpdatePreview( bool DataChange ){ if ( g_pWndPreview && gtk_widget_get_visible( g_pWndPreview ) ) { if ( DataChange ) { GenerateXYZ(); } gtk_widget_draw( g_pPreviewWidget, NULL ); } }
void BaseObject::updateLocation(int deltaX, int deltaY, GtkWidget *widget) { this->rect.x += deltaX; this->rect.y += deltaY; if (this->parentObj) { this->parentObj->expandForChildIfNeeded(this); } gtk_widget_draw(widget, &(widget->allocation)); // TODO: Find a way to not redraw everything!!! }
void wxMiniFrame::SetTitle( const wxString &title ) { wxFrame::SetTitle( title ); #ifdef __WXGTK20__ gdk_window_invalidate_rect( GTK_PIZZA(m_mainWidget)->bin_window, NULL, true ); #else gtk_widget_draw( m_mainWidget, (GdkRectangle*) NULL ); #endif }
static gint button_release_event(GtkWidget *widget, GdkEventButton *event) { if (event->button == 1) { if (selectedObject && selectedObject->parentObj) { selectedObject->parentObj->shrinkToFitChildrenIfPossible(); gtk_widget_draw(widget, &(widget->allocation)); // TODO: Find a way to not redraw everything!!! } } return TRUE; }
/* Remove a page from the notebook */ void remove_book (GtkButton *button, GtkNotebook *notebook) { gint page; page = gtk_notebook_current_page(notebook); gtk_notebook_remove_page (notebook, page); /* Need to refresh the widget -- This forces the widget to redraw itself. */ gtk_widget_draw(GTK_WIDGET(notebook), NULL); }
static gboolean slider_reset_callback(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, gpointer data) { GtkDarktableSlider *slider=DTGTK_SLIDER(data); gtk_adjustment_set_value(slider->adjustment, slider->default_value); gtk_widget_draw(GTK_WIDGET(slider),NULL); g_signal_emit_by_name(G_OBJECT(slider),"value-changed"); return TRUE; }
int navdata_ihm_raw_navdata_update ( const navdata_unpacked_t* const navdata ) { int cpt; long int period; double frequence,lowpass_frequence; static double previous_frequence=0.0f; struct timeval current_time; static struct timeval previous_time; static unsigned long int lastRefreshTime=0; navdata_t* packed_navdata = (navdata_t*) &navdata_buffer[0]; if (!window || !view) { return -1; } gettimeofday(¤t_time,NULL); period = ((current_time.tv_sec-previous_time.tv_sec))*1000000+(current_time.tv_usec-previous_time.tv_usec); lastRefreshTime+=period; frequence = 1000000.0f / (double)period; lowpass_frequence = frequence * 0.005f + previous_frequence * 0.95f; if (lastRefreshTime > 100000 /*ms*/) { lastRefreshTime = 0; gdk_threads_enter(); //http://library.gnome.org/devel/gdk/stable/gdk-Threads.html snprintf(buf,sizeof(buf),"%d",packed_navdata->sequence); snprintf(buf2,sizeof(buf2),"%3.1f Hz",lowpass_frequence); gtk_tree_store_set(treestore, &sequence_number,COL_VALUE, buf,COL_COMMENT,buf2,-1); cpt=0; snprintf(buf,sizeof(buf),"%x",navdata->navdata_demo.ctrl_state); setfield(NAVDATA_DEMO_TAG,buf,&cpt); snprintf(buf,sizeof(buf),"%3.1f",navdata->navdata_demo.phi/1000); setfield(NAVDATA_DEMO_TAG,buf,&cpt); snprintf(buf,sizeof(buf),"%3.1f",navdata->navdata_demo.psi/1000); setfield(NAVDATA_DEMO_TAG,buf,&cpt); snprintf(buf,sizeof(buf),"%3.1f",navdata->navdata_demo.theta/1000); setfield(NAVDATA_DEMO_TAG,buf,&cpt); cpt=0; snprintf(buf,sizeof(buf),"%x",navdata->navdata_games.double_tap_counter); setfield(NAVDATA_GAMES_TAG,buf,&cpt); snprintf(buf,sizeof(buf),"%x",navdata->navdata_games.finish_line_counter); setfield(NAVDATA_GAMES_TAG,buf,&cpt); gtk_widget_draw(GTK_WIDGET(view), NULL); gdk_threads_leave(); //http://library.gnome.org/devel/gdk/stable/gdk-Threads.html } previous_time = current_time; previous_frequence = lowpass_frequence; return C_OK; }
static void draw_screen (C2NetworkTraffic *nt) { GdkRectangle rect; GtkWidget *widget = GTK_WIDGET (nt); rect.x = 0; rect.y = 0; rect.width = widget->allocation.width; rect.height = widget->allocation.height; gtk_widget_draw (widget, &rect); }
void draw_qw_skin (GtkWidget *preview, guchar *data, int top, int bottom) { guchar buf[320*3]; guchar colormap[256]; guchar *ptr; int i, j, k; int fixed_top_color = fix_qw_player_color (top); int fixed_bottom_color = fix_qw_player_color (bottom); if (data) { for (i = 0; i < 256; i++) colormap[i] = i; if (fixed_top_color != 1) { for (i = 0; i<16; i++) colormap[16*1 + i] = fixed_top_color*16 + ((fixed_top_color <= 7)? i : 15 - i); } if (fixed_bottom_color != 6) { for (i = 0; i<16; i++) colormap[16*6 + i] = fixed_bottom_color*16 + ((fixed_bottom_color <= 7)? i : 15 - i); } for (i = 0; i < 200; i++) { ptr = buf; for (j = 0; j < 320; j++) { *ptr++ = quake_pallete[colormap[*data] * 3 + 0]; *ptr++ = quake_pallete[colormap[*data] * 3 + 1]; *ptr++ = quake_pallete[colormap[*data] * 3 + 2]; data++; } gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, i, 320); } } else { for (j = 0, k = NOSKIN_WCOLOR; j < 200; j += 40) { i = k; for (ptr = buf; ptr < buf+320*3; ptr += 40*3) { memset (ptr, i, 40*3); i = (NOSKIN_WCOLOR + NOSKIN_BCOLOR) - i; } for (i = 0; i < 40; i++) { gtk_preview_draw_row (GTK_PREVIEW (preview), buf, 0, j+i, 320); } k = (NOSKIN_WCOLOR + NOSKIN_BCOLOR) - k; } } gtk_widget_draw (preview, NULL); }
static gboolean gd_stack_draw (GtkWidget *widget, cairo_t *cr) { GdStack *stack = GD_STACK (widget); GdStackPrivate *priv = stack->priv; cairo_t *pattern_cr; if (priv->visible_child) { if (priv->transition_pos < 1.0) { if (priv->last_visible_surface == NULL && priv->last_visible_child != NULL) { gtk_widget_get_allocation (priv->last_visible_child->widget, &priv->last_visible_surface_allocation); priv->last_visible_surface = gdk_window_create_similar_surface (gtk_widget_get_window (widget), CAIRO_CONTENT_COLOR_ALPHA, priv->last_visible_surface_allocation.width, priv->last_visible_surface_allocation.height); pattern_cr = cairo_create (priv->last_visible_surface); /* We don't use propagate_draw here, because we don't want to apply the bin_window offset */ gtk_widget_draw (priv->last_visible_child->widget, pattern_cr); cairo_destroy (pattern_cr); } switch (priv->transition_type) { case GD_STACK_TRANSITION_TYPE_CROSSFADE: gd_stack_draw_crossfade (widget, cr); break; case GD_STACK_TRANSITION_TYPE_SLIDE_LEFT: case GD_STACK_TRANSITION_TYPE_SLIDE_RIGHT: gd_stack_draw_slide (widget, cr); break; default: g_assert_not_reached (); } } else if (gtk_cairo_should_draw_window (cr, priv->bin_window)) gtk_container_propagate_draw (GTK_CONTAINER (stack), priv->visible_child->widget, cr); } return TRUE; }
static gboolean slider_decrease_callback(GtkAccelGroup *accel_group, GObject *acceleratable, guint keyval, GdkModifierType modifier, gpointer data) { GtkDarktableSlider *slider=DTGTK_SLIDER(data); float value = gtk_adjustment_get_value(slider->adjustment); value -= gtk_adjustment_get_step_increment(slider->adjustment); if(slider->snapsize) value = slider->snapsize * (((int)value)/slider->snapsize); gtk_adjustment_set_value(slider->adjustment, value); gtk_widget_draw(GTK_WIDGET(slider),NULL); g_signal_emit_by_name(G_OBJECT(slider),"value-changed"); return TRUE; }
void tandrawselect(int dx, int dy, int drot){ tanpiecepos *selpiece; double zoom; int dumrot; GdkRectangle selbk2; selpiece=&(figgrande.piecepos[PIECENBR-1]); zoom=widgetgrande->allocation.width*figgrande.zoom; selposxnc += dx/zoom; selposync += dy/zoom; selpiece->posx = CLAMP(selposxnc, 0, 1.0/figgrande.zoom); selpiece->posy = CLAMP(selposync, 0, 1.0/figgrande.zoom); dumrot=selpiece->rot; rotnew=selpiece->rot-=drot; gdk_draw_pixmap(pixmapgrande1, widgetgrande->style->fg_gc[GTK_WIDGET_STATE (widgetgrande)], pixmapgrande2, selbackrect.x,selbackrect.y, selbackrect.x,selbackrect.y, selbackrect.width,selbackrect.height); selbk2=tandrawpiece(widgetgrande,pixmapgrande1, selpiece, zoom, TAN_PIECEHI); gtk_widget_draw (widgetgrande, &selbackrect); gtk_widget_draw (widgetgrande, &selbk2); selbackrect=selbk2; selpiece->rot=dumrot; }
static void kill_balls (int x, int y) { if (!field [x][y].color) return; if (tagged_count < 2) return; set_score (score + (tagged_count - 2) * (tagged_count - 2)); compress_y (); compress_x (); gtk_widget_draw (draw_area, NULL); check_game_over (); }