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 ();
}
