static void sanalyzer_init(void)
{
GdkColor color;
int i;
if(window)
return;
window = gtk_window_new(GTK_WINDOW_DIALOG);
gtk_window_set_title(GTK_WINDOW(window),_("Spectrum analyzer"));
gtk_window_set_policy(GTK_WINDOW(window), FALSE, FALSE, FALSE);
gtk_widget_realize(window);
bg_pixmap = gdk_pixmap_create_from_xpm_d(window->window,NULL,NULL,sanalyzer_xmms_logo_xpm);
gdk_window_set_back_pixmap(window->window,bg_pixmap,0);
gtk_signal_connect(GTK_OBJECT(window),"destroy",GTK_SIGNAL_FUNC(sanalyzer_destroy_cb),NULL);
gtk_signal_connect(GTK_OBJECT(window), "destroy", GTK_SIGNAL_FUNC(gtk_widget_destroyed), &window);
gtk_widget_set_usize(window, WIDTH, HEIGHT);
gc = gdk_gc_new(window->window);
draw_pixmap = gdk_pixmap_new(window->window,WIDTH,HEIGHT,gdk_rgb_get_visual()->depth);
bar = gdk_pixmap_new(window->window,25, HEIGHT, gdk_rgb_get_visual()->depth);
for(i = 0; i < HEIGHT / 2; i++)
{
color.red = 0xFFFF;
color.green = ((i * 255) / (HEIGHT / 2)) << 8;
color.blue = 0;
gdk_color_alloc(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
gdk_draw_line(bar,gc,0,i,24,i);
}
for(i = 0; i < HEIGHT / 2; i++)
{
color.red = (255 - ((i * 255) / (HEIGHT / 2))) <<8;
color.green = 0xFFFF;
color.blue = 0;
gdk_color_alloc(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
gdk_draw_line(bar,gc,0,i + (HEIGHT / 2),24,i + (HEIGHT / 2));
}
scale = HEIGHT / log(256);
gdk_color_black(gdk_colormap_get_system(),&color);
gdk_gc_set_foreground(gc,&color);
area = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(window),area);
gtk_widget_realize(area);
gdk_window_set_back_pixmap(area->window,bg_pixmap,0);
gtk_widget_show(area);
gtk_widget_show(window);
gdk_window_clear(window->window);
gdk_window_clear(area->window);
}
static void
gs_theme_engine_clear (GtkWidget *widget)
{
GdkColor color = { 0, 0x0000, 0x0000, 0x0000 };
GdkColormap *colormap;
GtkStateType state;
g_return_if_fail (GS_IS_THEME_ENGINE (widget));
if (! GTK_WIDGET_VISIBLE (widget))
{
return;
}
state = (GtkStateType) 0;
while (state < (GtkStateType) G_N_ELEMENTS (widget->style->bg))
{
gtk_widget_modify_bg (widget, state, &color);
state++;
}
colormap = gdk_drawable_get_colormap (widget->window);
gdk_colormap_alloc_color (colormap, &color, FALSE, TRUE);
gdk_window_set_background (widget->window, &color);
gdk_window_clear (widget->window);
gdk_flush ();
}
/*!
\brief highlight_tinfo() highlights the trace info box on the left side
of the logviewer when the mouse goes in there..
\param tnum is the trace number starting from 0
\param state if set we highlight the target trace info box
*/
G_MODULE_EXPORT void highlight_tinfo(gint tnum, gboolean state)
{
GdkRectangle rect;
extern Logview_Data *lv_data;
GdkWindow *window = gtk_widget_get_window(lv_data->darea);
rect.x = 0;
rect.y = lv_data->spread*tnum;
rect.width = lv_data->info_width-1;
rect.height = lv_data->spread;
if (state)
gdk_draw_rectangle(lv_data->pixmap,
lv_data->highlight_gc,
FALSE, rect.x,rect.y,
rect.width,rect.height);
else
gdk_draw_rectangle(lv_data->pixmap,
gtk_widget_get_style(lv_data->darea)->white_gc,
FALSE, rect.x,rect.y,
rect.width,rect.height);
rect.width+=1;
rect.height+=1;
gdk_window_clear(window);
return;
}
static gint draw_func(gpointer data)
{
gint i;
if(!window)
{
timeout_tag = 0;
return FALSE;
}
GDK_THREADS_ENTER();
gdk_draw_rectangle(draw_pixmap,gc,TRUE,0,0,WIDTH,HEIGHT);
for(i = 0; i < NUM_BANDS; i++)
{
/*if(bar_heights[i] > 4)
bar_heights[i] -= 4;
else
bar_heights[i] = 0;*/
gdk_draw_pixmap(draw_pixmap,gc,bar, 0,HEIGHT - 1 - bar_heights[i], i * (WIDTH / NUM_BANDS), HEIGHT - 1 - bar_heights[i], (WIDTH / NUM_BANDS) - 1, bar_heights[i]);
}
gdk_window_clear(area->window);
GDK_THREADS_LEAVE();
return TRUE;
}
void wxListBox::DoApplyWidgetStyle(GtkRcStyle *style)
{
if (m_hasBgCol && m_backgroundColour.Ok())
{
GdkWindow *window = GTK_WIDGET(m_list)->window;
if ( window )
{
m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
gdk_window_set_background( window, m_backgroundColour.GetColor() );
gdk_window_clear( window );
}
}
GList *child = m_list->children;
while (child)
{
gtk_widget_modify_style( GTK_WIDGET(child->data), style );
GtkBin *bin = GTK_BIN( child->data );
GtkWidget *label = GTK_WIDGET( bin->child );
gtk_widget_modify_style( label, style );
child = child->next;
}
}
/* logo_add */
static int _logo_add(Logo * logo, GdkWindow * window)
{
LogoWindow * p;
#if GTK_CHECK_VERSION(3, 4, 0)
GdkRGBA color = { 0.0, 0.0, 0.0, 0.0 };
#else
GdkColor color = { 0x0, 0x0, 0x0, 0x0 };
#endif
#ifdef DEBUG
fprintf(stderr, "DEBUG: %s() window=%p\n", __func__, (void *)window);
#endif
if((p = realloc(logo->windows, sizeof(*p) * (logo->windows_cnt + 1)))
== NULL)
return -1;
logo->windows = p;
/* set the default color */
#if GTK_CHECK_VERSION(3, 4, 0)
gdk_window_set_background_rgba(window, &color);
#else
gdk_window_set_background(window, &color);
gdk_window_clear(window);
#endif
logo->windows[logo->windows_cnt].window = window;
logo->windows[logo->windows_cnt].frame = NULL;
#if GTK_CHECK_VERSION(3, 0, 0)
logo->windows[logo->windows_cnt++].cairo = gdk_cairo_create(window);
#else
logo->windows[logo->windows_cnt++].pixmap = NULL;
#endif
return 0;
}
gint scope_mode(GtkWidget *widget, gpointer data)
{
int i=GPOINTER_TO_INT(data);
switch((ScopeMode) i)
{
case DOT_SCOPE:
scope_sub_mode = (ScopeMode) i;
break;
case LINE_SCOPE:
scope_sub_mode = (ScopeMode) i;
break;
case GRAD_SCOPE:
scope_sub_mode = (ScopeMode) i;
break;
default:
break;
}
if (mode == SCOPE)
{
gdk_draw_rectangle(main_pixmap,
main_display->style->black_gc,
TRUE, 0,0,
width,height);
gdk_window_clear(main_display->window);
}
return 0;
}
/*!
\brief gets called to redraw the entire display manually
\param gauge (MtxPieGauge *) pointer to the gauge object
*/
void mtx_pie_gauge_redraw (MtxPieGauge *gauge)
{
if (!GTK_WIDGET(gauge)->window) return;
update_pie_gauge_position(gauge);
gdk_window_clear(GTK_WIDGET(gauge)->window);
}
static gboolean
gtk_vkb_button_expose (GtkWidget *widget, GdkEventExpose *event)
{
GtkVkbButton *button = GTK_VKB_BUTTON(widget);
GtkWidget *child;
GList *children;
GList *tmplist;
g_return_val_if_fail(widget != NULL, FALSE);
g_return_val_if_fail (GTK_IS_VKB_BUTTON(widget), FALSE);
g_return_val_if_fail (event != NULL, FALSE);
if(GTK_WIDGET_DRAWABLE(widget)){
GtkStateType state = GTK_WIDGET_STATE(widget);
if (!button->bg_pixmap) {
gdk_window_set_background(widget->window, &button->bgcolor[state]);
gdk_window_clear(widget->window);
}
children = gtk_container_get_children(GTK_CONTAINER(widget));
tmplist = children;
while (tmplist) {
child = GTK_WIDGET(tmplist->data);
tmplist = tmplist->next;
gtk_container_propagate_expose(GTK_CONTAINER(widget),
child, event);
}
g_list_free(children);
}
return FALSE;
}
bool wxTextCtrl::SetBackgroundColour( const wxColour &colour )
{
wxCHECK_MSG( m_text != NULL, false, wxT("invalid text ctrl") );
if ( !wxControl::SetBackgroundColour( colour ) )
return false;
if (!m_widget->window)
return false;
if (!m_backgroundColour.IsOk())
return false;
if (m_windowStyle & wxTE_MULTILINE)
{
GdkWindow *window = GTK_TEXT(m_text)->text_area;
if (!window)
return false;
m_backgroundColour.CalcPixel( gdk_window_get_colormap( window ) );
gdk_window_set_background( window, m_backgroundColour.GetColor() );
gdk_window_clear( window );
}
// change active background color too
m_defaultStyle.SetBackgroundColour( colour );
return true;
}
void
meta_image_window_set (MetaImageWindow *iw,
GdkPixbuf *pixbuf,
int x,
int y)
{
/* We use a back pixmap to avoid having to handle exposes, because
* it's really too slow for large clients being minimized, etc.
* and this way flicker is genuinely zero.
*/
gdk_draw_pixbuf (iw->pixmap,
iw->window->style->black_gc,
pixbuf,
0, 0,
0, 0,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf),
GDK_RGB_DITHER_NORMAL,
0, 0);
gdk_window_set_back_pixmap (iw->window->window,
iw->pixmap,
FALSE);
gdk_window_move_resize (iw->window->window,
x, y,
gdk_pixbuf_get_width (pixbuf),
gdk_pixbuf_get_height (pixbuf));
gdk_window_clear (iw->window->window);
}
static void sanalyzer_playback_stop(void)
{
if(GTK_WIDGET_REALIZED(area))
{
gdk_window_set_back_pixmap(area->window,bg_pixmap,0);
gdk_window_clear(area->window);
}
}
static void
preview_clear (GtkWidget *widget)
{
GdkColor color = { 0, 0, 0 };
gtk_widget_modify_bg (widget, GTK_STATE_NORMAL, &color);
gdk_window_clear (widget->window);
}
static void sanalyzer_playback_start(void)
{
if(window)
{
gdk_window_set_back_pixmap(area->window,draw_pixmap,0);
gdk_window_clear(area->window);
}
}
/*!
\brief gets called to redraw the entire display manually
\param chart (MtxStripChart *) pointer to the chart object
*/
void mtx_stripchart_redraw (MtxStripChart *chart)
{
if (!GTK_WIDGET(chart)->window) return;
update_stripchart_position(chart);
render_marker(chart);
gdk_window_clear(GTK_WIDGET(chart)->window);
}
/* Init function. Here we setup all the gtk stuff */
static GtkWidget *init_fftscope_window()
{
GtkWidget *fftscope_win;
GtkStyle *style;
GdkColor color;
guint32 colors[129];
int i;
pthread_mutex_init(&fftscope_mutex, NULL);
style = gtk_style_new();
fftscope_win = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(fftscope_win), "FFTscope");
gtk_widget_set_usize(fftscope_win, 256, SCOPE_HEIGHT);
gtk_window_set_wmclass(GTK_WINDOW(fftscope_win), "FFTscope",
"AlsaPlayer");
gtk_window_set_policy(GTK_WINDOW(fftscope_win), FALSE, FALSE,
FALSE);
style =
gtk_style_copy(gtk_widget_get_style(GTK_WIDGET(fftscope_win)));
color.red = SCOPE_BG_RED << 8;
color.blue = SCOPE_BG_BLUE << 8;
color.green = SCOPE_BG_GREEN << 8;
gdk_color_alloc(gdk_colormap_get_system(), &color);
gtk_widget_set_style(GTK_WIDGET(fftscope_win), style);
for (i = 0; i < 32; i++) {
colors[i * 2] = colors[i * 2 + 1] =
((i * 8) << 16) + (255 << 8);
colors[i * 2 + 64] = colors[i * 2 + 65] =
(255 << 16) + (((31 - i) * 8) << 8);
}
colors[128] = 0;
color_map = gdk_rgb_cmap_new(colors, 129);
area = gtk_drawing_area_new();
gtk_container_add(GTK_CONTAINER(fftscope_win), area);
gtk_widget_realize(area);
gdk_window_set_background(area->window, &color);
gtk_widget_show(area);
gtk_widget_show(fftscope_win);
/* Signals */
gtk_signal_connect(GTK_OBJECT(fftscope_win), "delete_event",
GTK_SIGNAL_FUNC(close_fftscope_window),
fftscope_win);
/* Clear and show the window */
gdk_window_clear(fftscope_win->window);
gdk_flush();
ready_state = 1;
return fftscope_win;
}
/*!
\brief gets called to redraw the entire display manually
\param chart is the pointer to the chart object
*/
void mtx_stripchart_redraw (MtxStripChart *chart)
{
GdkWindow *window = gtk_widget_get_window(GTK_WIDGET(chart));
if (!window)
return;
update_stripchart_position(chart);
render_marker(chart);
gdk_window_clear(window);
}
void yui_viewer_draw_pixbuf(YuiViewer * yv, GdkPixbuf * pixbuf, int w, int h) {
if (yv->pixbuf) {
g_object_unref(yv->pixbuf);
}
yv->pixbuf = g_object_ref(pixbuf);
yv->w = w;
yv->h = h;
gdk_window_clear(GTK_WIDGET(yv)->window);
gtk_widget_queue_draw_area(GTK_WIDGET(yv), 0, 0, w, h);
}
/*!
\brief lv_configure_event() is the logviewer configure event that gets called
whenever the display is resized or created
\param widget is the pointer to widget receiving event
\param event is the pointer to Config event structure
\param data is unused)
\returns FALSE
*/
G_MODULE_EXPORT gboolean lv_configure_event(GtkWidget *widget, GdkEventConfigure *event, gpointer data)
{
GdkPixmap *pixmap = NULL;
GdkPixmap *pmap = NULL;
GtkAllocation allocation;
GdkWindow *window = gtk_widget_get_window(widget);
gtk_widget_get_allocation(widget,&allocation);
/* Get pointer to backing pixmap ... */
if (!lv_data)
{
lv_data = g_new0(Logview_Data,1);
lv_data->traces = g_hash_table_new(g_str_hash,g_str_equal);
}
pixmap = lv_data->pixmap;
pmap = lv_data->pmap;
if (window)
{
if (pixmap)
g_object_unref(pixmap);
if (pmap)
g_object_unref(pmap);
gint w = allocation.width;
gint h = allocation.height;
pixmap=gdk_pixmap_new(window,
w,h,
gtk_widget_get_visual(widget)->depth);
gdk_draw_rectangle(pixmap,
gtk_widget_get_style(widget)->black_gc,
TRUE, 0,0,
w,h);
pmap=gdk_pixmap_new(window,
w,h,
gtk_widget_get_visual(widget)->depth);
gdk_draw_rectangle(pmap,
gtk_widget_get_style(widget)->black_gc,
TRUE, 0,0,
w,h);
gdk_window_set_back_pixmap(window,pixmap,0);
lv_data->pixmap = pixmap;
lv_data->pmap = pmap;
if ((lv_data->traces) && (g_list_length(lv_data->tlist) > 0))
{
draw_infotext();
trace_update(TRUE);
}
gdk_window_clear(window);
}
return FALSE;
}
void
draw_preview_image (gint docompute)
{
gint startx, starty, pw, ph;
GdkColor color;
color.red = 0x0;
color.green = 0x0;
color.blue = 0x0;
gdk_gc_set_rgb_bg_color (gc, &color);
color.red = 0xFFFF;
color.green = 0xFFFF;
color.blue = 0xFFFF;
gdk_gc_set_rgb_fg_color (gc, &color);
gdk_gc_set_function (gc, GDK_COPY);
linetab[0].x1 = -1;
pw = PREVIEW_WIDTH * mapvals.zoom;
ph = PREVIEW_HEIGHT * mapvals.zoom;
startx = (PREVIEW_WIDTH - pw) / 2;
starty = (PREVIEW_HEIGHT - ph) / 2;
if (docompute == TRUE)
{
GdkDisplay *display = gtk_widget_get_display (previewarea);
GdkCursor *cursor;
cursor = gdk_cursor_new_for_display (display, GDK_WATCH);
gdk_window_set_cursor (previewarea->window, cursor);
gdk_cursor_unref (cursor);
compute_preview (0, 0, width - 1, height - 1, pw, ph);
cursor = gdk_cursor_new_for_display (display, GDK_HAND2);
gdk_window_set_cursor(previewarea->window, cursor);
gdk_cursor_unref (cursor);
clear_light_marker ();
}
if (pw != PREVIEW_WIDTH || ph != PREVIEW_HEIGHT)
gdk_window_clear (previewarea->window);
gdk_draw_rgb_image (previewarea->window, gc,
startx, starty, pw, ph,
GDK_RGB_DITHER_MAX,
preview_rgb_data, 3 * pw);
draw_lights (startx, starty, pw, ph);
}
static void
draw_background (MateBGCrossfade *fade)
{
if (GDK_WINDOW_TYPE (fade->priv->window) == GDK_WINDOW_ROOT) {
GdkDisplay *display;
display = gdk_drawable_get_display (fade->priv->window);
gdk_window_clear (fade->priv->window);
gdk_flush ();
} else {
gdk_window_invalidate_rect (fade->priv->window, NULL, FALSE);
gdk_window_process_updates (fade->priv->window, FALSE);
}
}
static gboolean
preview_expose (GtkWidget *widget,
GdkEventExpose *event,
gpointer data)
{
PreviewOp *pop = data;
gdk_window_clear (pop->area->window);
gtk_print_operation_preview_render_page (pop->preview,
pop->page - 1);
return TRUE;
}
/*!
Flushes the display buffer.
It's necessary to use this function to see the results of any drawing.
*/
void vpDisplayGTK::flushDisplay()
{
if (displayHasBeenInitialized)
{
gdk_window_clear(widget->window);
gdk_flush();
}
else
{
vpERROR_TRACE("GTK not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"GTK not initialized")) ;
}
}
/*!
Flushes the display buffer.
It's necessary to use this function to see the results of any drawing.
*/
void vpDisplayGTK::flushDisplayROI(const vpImagePoint &/*iP*/, const unsigned int /*width*/, const unsigned int /*height*/)
{
if (displayHasBeenInitialized)
{
gdk_window_clear(widget->window);
gdk_flush();
}
else
{
vpERROR_TRACE("GTK not initialized " ) ;
throw(vpDisplayException(vpDisplayException::notInitializedError,
"GTK not initialized")) ;
}
}
void MdispGtkView::Paint()
{
GdkColor textColor;
if(!m_MilDisplay)
{
/* red color */
textColor.red = 65535;
textColor.green = 0;
textColor.blue = 0;
gdk_window_clear(GDK_WINDOW(m_window->window));
m_cf->DrawText("Display Allocation Failed",(m_imageSizeX/2),10,textColor);
}
else if(m_isWindowed)
{
if(m_isX11AnnotationsEnabled)
{
/* pink color */
textColor.red = 65535;
textColor.green = 0;
textColor.blue = 65535;
m_cf->DrawText("Window Annotation",
(m_isFillDisplayEnabled)?(m_window->allocation.width/2):(m_imageSizeX/2),
10,
textColor);
}
}
else
{
/* black color */
textColor.red = 0;
textColor.green = 0;
textColor.blue = 0;
gdk_window_clear(GDK_WINDOW(m_window->window));
m_cf->DrawText("Image Displayed on external Screen",(m_imageSizeX/2),10,textColor);
}
}
static void
set_bg(GtkWidget *widget, panel *p)
{
ENTER;
if (p->gtopbg)
g_object_unref(p->gtopbg);
p->gtopbg = bg_new_for_win(p->topxwin);
modify_drawable(p->gtopbg, p->topgwin->style->black_gc, p->tintcolor, p->alpha);
gdk_window_set_back_pixmap(p->topgwin->window, p->gtopbg, FALSE);
gdk_window_clear(p->topgwin->window);
gtk_widget_queue_draw_area (p->topgwin, 0, 0, 2000, 2000);
RET();
}
void wxListBox::DoApplyWidgetStyle(GtkRcStyle *style)
{
if (m_hasBgCol && m_backgroundColour.Ok())
{
GdkWindow *window = gtk_tree_view_get_bin_window(m_treeview);
if (window)
{
m_backgroundColour.CalcPixel( gdk_drawable_get_colormap( window ) );
gdk_window_set_background( window, m_backgroundColour.GetColor() );
gdk_window_clear( window );
}
}
gtk_widget_modify_style( GTK_WIDGET(m_treeview), style );
}
static void blursk_playback_stop(void)
{
if (config.fullscreen_revert)
{
#if HAVE_XV
xv_end();
#endif
if (can_fullscreen)
xmms_fullscreen_cleanup(blursk_window);
fullscreen_method = NULL;
}
if(GTK_WIDGET_REALIZED(area))
gdk_window_clear(area->window);
}
int
clip_GDK_WINDOWCLEAR(ClipMachine * cm)
{
C_widget *cwin = _fetch_cw_arg(cm);
GdkWindow *win = NULL;
CHECKCWID(cwin,GTK_IS_WIDGET);
if (cwin && cwin->widget) win = cwin->widget->window;
gdk_window_clear(win);
return 0;
err:
return 1;
}
static gboolean touchscreen_callback(GtkWidget *widget, GdkEventMotion *event)
{
GdkGC *gc;
PangoLayout *layout;
char buf[64];
sprintf(buf, "<span size=\"30000\">[%d, %d]</span>",
(int)event->x, (int)event->y);
gdk_window_clear(widget->window);
gc = gdk_gc_new(widget->window);
layout = gtk_widget_create_pango_layout(widget, "");
pango_layout_set_markup(layout, buf, -1);
gdk_draw_layout(widget->window, gc, 80, 80, layout);
g_object_unref(layout);
gdk_gc_destroy(gc);
return TRUE;
}
