/* 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);
}
static void
maybe_check_submenu_state (GtkMenuItem *menu_item,
ThemeMatchData *match_data)
{
/* Distinguish between active and passive focus, depending on whether the
* focus is in submenu.
*
* Active focus:
* function = BOX
* state = PRELIGHT
*
* Passive focus:
* function = BOX
* state = SELECTED
*/
if (menu_item->submenu)
{
GtkWidget *sub_item;
sub_item = GTK_MENU_SHELL (menu_item->submenu)->active_menu_item;
if (sub_item && gtk_widget_get_state (sub_item) != GTK_STATE_NORMAL)
match_data->state = GTK_STATE_SELECTED;
}
/* This is a hack to cover the cases where a menu item is being
* used outside the usual a GtkMenu. More specificaly, this covers
* menu items inside the hildon-desktop custom menu widget. */
if (!GTK_IS_MENU (GTK_WIDGET (menu_item)->parent) &&
!gtk_widget_is_focus (GTK_WIDGET (menu_item)) &&
gtk_widget_get_state (GTK_WIDGET (menu_item)) != GTK_STATE_NORMAL)
match_data->state = GTK_STATE_SELECTED;
}
static gboolean
mx_gtk_light_switch_expose (GtkWidget *lightswitch,
GdkEventExpose *event)
{
MxGtkLightSwitchPrivate *priv;
GtkStyle *style;
GtkStateType state_type;
cairo_t *cr;
cr = gdk_cairo_create (gtk_widget_get_window (lightswitch));
cairo_rectangle (cr,
event->area.x,
event->area.y,
event->area.width,
event->area.height);
cairo_clip (cr);
priv = MX_GTK_LIGHT_SWITCH_GET_PRIVATE (lightswitch);
style = gtk_widget_get_style (lightswitch);
state_type = gtk_widget_get_state (lightswitch);
/* draw the trough */
gtk_paint_box (style,
gtk_widget_get_window (lightswitch),
(state_type != GTK_STATE_INSENSITIVE && priv->active)
? GTK_STATE_SELECTED : state_type,
GTK_SHADOW_IN,
NULL,
NULL,
"light-switch-trough",
0,
0,
(priv->trough_width),
priv->switch_height);
/* draw the switch itself */
if (state_type != GTK_STATE_INSENSITIVE)
{
gtk_paint_box (style,
gtk_widget_get_window (lightswitch),
gtk_widget_get_state (lightswitch),
GTK_SHADOW_OUT,
NULL,
NULL,
"light-switch-handle",
priv->x + style->xthickness,
style->ythickness,
priv->switch_width - style->xthickness * 2,
priv->switch_height - style->ythickness * 2);
}
cairo_destroy (cr);
return FALSE;
}
static bool
childrenUseEvent(GtkWidget *widget, GdkEventButton *event, bool inNoteBook)
{
// accept, by default
bool usable = true;
// get children and check
GList *children = gtk_container_get_children(GTK_CONTAINER(widget));
for (GList *child = children;child && usable;child = g_list_next(child)) {
// cast child to GtkWidget
if (GTK_IS_WIDGET(child->data)) {
GtkWidget *childWidget = GTK_WIDGET(child->data);
GdkWindow *window = nullptr;
// check widget state and type
if (gtk_widget_get_state(childWidget) == GTK_STATE_PRELIGHT) {
// if widget is prelight, we don't need to check where event
// happen, any prelight widget indicate we can't do a move
usable = false;
continue;
}
window = gtk_widget_get_window(childWidget);
if (!(window && gdk_window_is_visible(window)))
continue;
if (GTK_IS_NOTEBOOK(childWidget))
inNoteBook = true;
if(!(event && withinWidget(childWidget, event)))
continue;
// check special cases for which grab should not be enabled
if((isBlackListed(G_OBJECT(childWidget))) ||
(GTK_IS_NOTEBOOK(widget) && Tab::isLabel(GTK_NOTEBOOK(widget),
childWidget)) ||
(GTK_IS_BUTTON(childWidget) &&
gtk_widget_get_state(childWidget) != GTK_STATE_INSENSITIVE) ||
(gtk_widget_get_events(childWidget) &
(GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK)) ||
(GTK_IS_MENU_ITEM(childWidget)) ||
(GTK_IS_SCROLLED_WINDOW(childWidget) &&
(!inNoteBook || gtk_widget_is_focus(childWidget)))) {
usable = false;
}
// if child is a container and event has been accepted so far,
// also check it, recursively
if (usable && GTK_IS_CONTAINER(childWidget)) {
usable = childrenUseEvent(childWidget, event, inNoteBook);
}
}
}
if (children) {
g_list_free(children);
}
return usable;
}
static void init_gc(void) {
count_new = 0;
calculate_standard_signal();
calculate_difficulty();
calculate_sensitivity();
count = 0;
count_new = 0;
count_standard_signal = border; /* border so that signal starts with low */
initial_count=0;
// drawing
is_stop=FALSE;
is_pause=FALSE;
mute=FALSE;
image_volume_on = GTK_WIDGET(gtk_image_new_from_file("/home/pi/gtk_drawing/lautsprecher_mit.png"));
gtk_button_set_image(GTK_BUTTON(cmd_mute), image_volume_on);
gtk_button_set_label(GTK_BUTTON(cmd_pause), "Pause");
count = 0;
count_new = 0;
count_standard_signal = border; /* border so that signal starts with low */
gtk_widget_get_allocation(draw_area, &draw_area_size);
g_print("width: %d \n height: %d \n", draw_area_size.width, draw_area_size.height);
pixmap = gdk_pixmap_new(draw_area->window, 2*draw_area_size.width, draw_area_size.height, -1);
gdk_colormap_alloc_color(gtk_widget_get_colormap(draw_area), &red, FALSE, TRUE);
gdk_colormap_alloc_color(gtk_widget_get_colormap(draw_area), &black, FALSE, TRUE);
gdk_colormap_alloc_color(gtk_widget_get_colormap(draw_area), &green, FALSE, TRUE);
gc = gdk_gc_new(pixmap);
*gc = *(draw_area->style->fg_gc[gtk_widget_get_state(draw_area)]);
gdk_gc_set_foreground(gc, &red);
gdk_gc_set_line_attributes(gc, 2, GDK_LINE_SOLID, GDK_CAP_NOT_LAST, GDK_JOIN_MITER);
gcgr = gdk_gc_new(pixmap);
*gcgr = *(draw_area->style->fg_gc[gtk_widget_get_state(draw_area)]);
gdk_gc_set_foreground(gcgr, &green);
gdk_gc_set_line_attributes(gcgr, 2, GDK_LINE_SOLID, GDK_CAP_NOT_LAST, GDK_JOIN_MITER);
gcbl = gdk_gc_new(pixmap); // black graphic context
*gcbl = *(draw_area->style->fg_gc[gtk_widget_get_state(draw_area)]);
gdk_gc_set_foreground(gcbl, &black);
gdk_gc_set_line_attributes(gcbl, 2, GDK_LINE_SOLID, GDK_CAP_NOT_LAST, GDK_JOIN_MITER);
}
static gboolean panel_icon_grid_expose(GtkWidget *widget, GdkEventExpose *event)
#endif
{
if (gtk_widget_is_drawable(widget))
{
if (gtk_widget_get_has_window(widget) &&
!gtk_widget_get_app_paintable(widget))
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_render_background(gtk_widget_get_style_context(widget), cr, 0, 0,
gtk_widget_get_allocated_width(widget),
gtk_widget_get_allocated_height(widget));
#else
gtk_paint_flat_box(gtk_widget_get_style(widget),
gtk_widget_get_window(widget),
gtk_widget_get_state(widget), GTK_SHADOW_NONE,
&event->area, widget, "panelicongrid",
0, 0, -1, -1);
#endif
#if GTK_CHECK_VERSION(3, 0, 0)
GTK_WIDGET_CLASS(panel_icon_grid_parent_class)->draw(widget, cr);
#else
GTK_WIDGET_CLASS(panel_icon_grid_parent_class)->expose_event(widget, event);
#endif
}
return FALSE;
}
/* Redraw the screen from the backing pixmap */
static gboolean expose_event (GtkWidget *widget,
GdkEventExpose *event)
{
static GdkImage *image = NULL;
GdkCursor *cursor;
GdkPixbuf *pixbuf;
if (framebuffer_allocated == FALSE) {
rfbClientSetClientData (cl, gtk_init, widget);
image = gdk_drawable_get_image (widget->window, 0, 0,
widget->allocation.width,
widget->allocation.height);
cl->frameBuffer= image->mem;
cl->width = widget->allocation.width;
cl->height = widget->allocation.height;
cl->format.bitsPerPixel = image->bits_per_pixel;
cl->format.redShift = image->visual->red_shift;
cl->format.greenShift = image->visual->green_shift;
cl->format.blueShift = image->visual->blue_shift;
cl->format.redMax = (1 << image->visual->red_prec) - 1;
cl->format.greenMax = (1 << image->visual->green_prec) - 1;
cl->format.blueMax = (1 << image->visual->blue_prec) - 1;
#ifdef LIBVNCSERVER_CONFIG_LIBVA
/* Allow libvncclient to use a more efficient way
* of putting the framebuffer on the screen when
* using the H.264 format.
*/
cl->outputWindow = GDK_WINDOW_XID(widget->window);
#endif
SetFormatAndEncodings (cl);
framebuffer_allocated = TRUE;
/* Also disable local cursor */
pixbuf = gdk_pixbuf_new_from_xpm_data(dot_cursor_xpm);
cursor = gdk_cursor_new_from_pixbuf(gdk_display_get_default(), pixbuf, dot_cursor_x_hot, dot_cursor_y_hot);
g_object_unref(pixbuf);
gdk_window_set_cursor (gtk_widget_get_window(GTK_WIDGET(window)), cursor);
gdk_cursor_unref(cursor);
}
#ifndef LIBVNCSERVER_CONFIG_LIBVA
gdk_draw_image (GDK_DRAWABLE (widget->window),
widget->style->fg_gc[gtk_widget_get_state(widget)],
image,
event->area.x, event->area.y,
event->area.x, event->area.y,
event->area.width, event->area.height);
#endif
return FALSE;
}
static gboolean window_menu_on_expose(GtkWidget* widget, GdkEventExpose* event, gpointer data)
#endif
{
WindowMenu* window_menu = data;
if (gtk_widget_has_focus(window_menu->applet))
gtk_paint_focus(gtk_widget_get_style(widget),
#if GTK_CHECK_VERSION (3, 0, 0)
cr,
#else
gtk_widget_get_window(widget),
#endif
gtk_widget_get_state(widget),
#if !GTK_CHECK_VERSION (3, 0, 0)
NULL,
#endif
widget,
"menu-applet",
0, 0,
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_get_allocated_width (widget),
gtk_widget_get_allocated_height (widget));
#else
-1, -1);
#endif
return FALSE;
}
static gboolean
gb_progress_bar_draw (GtkWidget *widget,
cairo_t *cr)
{
GbProgressBarPrivate *priv;
GtkStyleContext *context;
GbProgressBar *bar = (GbProgressBar *)widget;
GtkAllocation allocation;
GtkStateType state;
GdkRGBA color = { 0 };
g_return_val_if_fail(GB_IS_PROGRESS_BAR(bar), FALSE);
priv = bar->priv;
if (gtk_widget_is_drawable(widget)) {
gtk_widget_get_allocation(widget, &allocation);
state = gtk_widget_get_state(widget);
context = gtk_widget_get_style_context(widget);
gtk_style_context_get_color(context, state, &color);
cairo_save(cr);
cairo_rectangle(cr,
0,
0,
priv->fraction * allocation.width,
allocation.height);
gdk_cairo_set_source_rgba(cr, &color);
cairo_fill(cr);
cairo_restore(cr);
}
return FALSE;
}
/***********************************************
* hc_gtk2_engine_hack_menu_shell_leave -
*
* Leave signal to ensure menushell items
* normal state on mouse leave.
***********************************************/
static gboolean
hc_gtk2_engine_hack_menu_shell_leave(GtkWidget *widget,
GdkEventCrossing *event,
gpointer user_data)
{
if (GE_IS_MENU_SHELL(widget))
{
GList *children = NULL, *child = NULL;
if (GE_IS_CONTAINER(widget))
{
children = gtk_container_get_children(GTK_CONTAINER(widget));
for (child = g_list_first(children); child; child = g_list_next(child))
{
if ((child->data) && GE_IS_MENU_ITEM(child->data) &&
(gtk_widget_get_state (GTK_WIDGET(child->data)) != GTK_STATE_INSENSITIVE))
{
GtkWidget* submenu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(child->data));
if ((!GE_IS_MENU(submenu)) ||
(!(gtk_widget_get_realized(submenu) &&
gtk_widget_get_visible (submenu))))
{
gtk_widget_set_state (GTK_WIDGET(child->data), GTK_STATE_NORMAL);
}
}
}
if (children)
g_list_free(children);
}
}
return FALSE;
}
static gboolean
render_contribution_topdown(GtkExperimentTranscript *trans,
ExperimentReaderContrib *contrib,
gint64 current_time, gint64 current_time_px,
gint *last_contrib_y)
{
GtkWidget *widget = GTK_WIDGET(trans);
gint old_last_contrib_y = *last_contrib_y;
int logical_height;
*last_contrib_y = current_time_px - TIME_TO_PX(contrib->start_time);
if (!configure_text_layout(trans, contrib, current_time,
*last_contrib_y, old_last_contrib_y,
&logical_height))
return TRUE;
if (*last_contrib_y - logical_height > widget->allocation.height)
return FALSE;
gdk_draw_layout(GDK_DRAWABLE(trans->priv->layer_text),
widget->style->text_gc[gtk_widget_get_state(widget)],
0, *last_contrib_y - logical_height,
trans->priv->layer_text_layout);
return *last_contrib_y < widget->allocation.height;
}
void wxStatusBarGeneric::OnPaint(wxPaintEvent& WXUNUSED(event) )
{
wxPaintDC dc(this);
#ifdef __WXGTK20__
// Draw grip first
if ( ShowsSizeGrip() )
{
const wxRect& rc = GetSizeGripRect();
GdkWindowEdge edge =
GetLayoutDirection() == wxLayout_RightToLeft ? GDK_WINDOW_EDGE_SOUTH_WEST :
GDK_WINDOW_EDGE_SOUTH_EAST;
gtk_paint_resize_grip(gtk_widget_get_style(m_widget),
GTKGetDrawingWindow(),
gtk_widget_get_state(m_widget),
NULL,
m_widget,
"statusbar",
edge,
rc.x, rc.y, rc.width, rc.height );
}
#endif // __WXGTK20__
if (GetFont().IsOk())
dc.SetFont(GetFont());
// compute char height only once for all panes:
int textHeight = dc.GetCharHeight();
dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
for (size_t i = 0; i < m_panes.GetCount(); i ++)
DrawField(dc, i, textHeight);
}
static gboolean
qtcMenuShellLeave(GtkWidget *widget, GdkEventCrossing *event, void *data)
{
QTC_UNUSED(data);
QTC_UNUSED(event);
if (GTK_IS_MENU_SHELL(widget) && GTK_IS_CONTAINER(widget)) {
GList *children = gtk_container_get_children(GTK_CONTAINER(widget));
for (GList *child = children;child;child = g_list_next(child)) {
if ((child->data) && GTK_IS_MENU_ITEM(child->data) &&
(gtk_widget_get_state(GTK_WIDGET(child->data)) !=
GTK_STATE_INSENSITIVE)) {
GtkWidget *submenu =
gtk_menu_item_get_submenu(GTK_MENU_ITEM(child->data));
GtkWidget *topLevel =
submenu ? gtk_widget_get_toplevel(submenu) : NULL;
if (submenu &&
((!GTK_IS_MENU(submenu)) ||
(!(gtk_widget_get_realized(submenu) &&
gtk_widget_get_visible(submenu) &&
gtk_widget_get_realized(topLevel) &&
gtk_widget_get_visible(topLevel))))) {
gtk_widget_set_state(GTK_WIDGET(child->data),
GTK_STATE_NORMAL);
}
}
}
if (children) {
g_list_free(children);
}
}
return false;
}
static gboolean panel_menu_bar_on_expose(GtkWidget* widget, GdkEventExpose* event, gpointer data)
#endif
{
PanelMenuBar* menubar = data;
if (gtk_widget_has_focus(GTK_WIDGET(menubar)))
{
gtk_paint_focus(gtk_widget_get_style(widget),
#if GTK_CHECK_VERSION (3, 0, 0)
cr,
#else
gtk_widget_get_window(widget),
#endif
gtk_widget_get_state(GTK_WIDGET(menubar)),
#if !GTK_CHECK_VERSION (3, 0, 0)
NULL,
#endif
widget,
"menubar-applet",
0,
0,
#if GTK_CHECK_VERSION (3, 0, 0)
gtk_widget_get_allocated_width (widget),
gtk_widget_get_allocated_height (widget));
#else
-1,
-1);
#endif
}
return FALSE;
}
static inline void
render_backdrop_area(GtkExperimentTranscript *trans, gint64 current_time_px)
{
GtkWidget *widget = GTK_WIDGET(trans);
gint y_start, y_end;
GdkColor color;
GdkColor *bg = &widget->style->bg[gtk_widget_get_state(widget)];
if (!gtk_experiment_transcript_get_use_backdrop_area(trans))
return;
if (gtk_experiment_transcript_get_reverse_mode(trans)) {
y_end = current_time_px - TIME_TO_PX(trans->priv->backdrop.start);
y_start = current_time_px - TIME_TO_PX(trans->priv->backdrop.end);
} else {
y_start = widget->allocation.height -
(current_time_px - TIME_TO_PX(trans->priv->backdrop.start));
y_end = widget->allocation.height -
(current_time_px - TIME_TO_PX(trans->priv->backdrop.end));
}
if ((y_start < 0 && y_end < 0) ||
(y_start > widget->allocation.height &&
y_end > widget->allocation.height))
return;
y_start = CLAMP(y_start, 0, widget->allocation.height);
y_end = CLAMP(y_end, 0, widget->allocation.height);
color.pixel = 0;
color.red = MAX((gint)bg->red - BACKDROP_VALUE, 0);
color.blue = MAX((gint)bg->blue - BACKDROP_VALUE, 0);
color.green = MAX((gint)bg->green - BACKDROP_VALUE, 0);
if (!color.red && !color.blue && !color.green) {
color.red = MIN((gint)bg->red + BACKDROP_VALUE, G_MAXUINT16);
color.blue = MIN((gint)bg->blue + BACKDROP_VALUE, G_MAXUINT16);
color.green = MIN((gint)bg->green + BACKDROP_VALUE, G_MAXUINT16);
}
gtk_widget_modify_fg(widget, gtk_widget_get_state(widget), &color);
gdk_draw_rectangle(GDK_DRAWABLE(trans->priv->layer_text),
widget->style->fg_gc[gtk_widget_get_state(widget)],
TRUE,
0, y_start,
widget->allocation.width, y_end - y_start);
}
static void
on_preview_expose_event (GtkWidget *drawing_area,
GdkEventExpose *event,
gpointer data)
{
ScreenshotDialog *dialog = data;
GdkPixbuf *pixbuf = NULL;
gboolean free_pixbuf = FALSE;
cairo_t *cr;
/* Stolen from GtkImage. I really should just make the drawing area an
* image some day */
if (gtk_widget_get_state (drawing_area) != GTK_STATE_NORMAL)
{
GtkIconSource *source;
source = gtk_icon_source_new ();
gtk_icon_source_set_pixbuf (source, dialog->preview_image);
gtk_icon_source_set_size (source, GTK_ICON_SIZE_SMALL_TOOLBAR);
gtk_icon_source_set_size_wildcarded (source, FALSE);
pixbuf = gtk_style_render_icon (drawing_area->style,
source,
gtk_widget_get_direction (drawing_area),
gtk_widget_get_state (drawing_area),
(GtkIconSize) -1,
drawing_area,
"gtk-image");
free_pixbuf = TRUE;
gtk_icon_source_free (source);
}
else
{
pixbuf = g_object_ref (dialog->preview_image);
}
cr = gdk_cairo_create (drawing_area->window);
gdk_cairo_region (cr, event->region);
cairo_clip (cr);
gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
cairo_paint (cr);
cairo_destroy (cr);
g_object_unref (pixbuf);
}
static gboolean
panel_toggle_button_draw (GtkWidget *widget, cairo_t *cr)
{
GtkWidget *child = gtk_bin_get_child (GTK_BIN (widget));
GtkStateType state_type;
GtkShadowType shadow_type;
GtkAllocation allocation;
GtkStyleContext *context = gtk_widget_get_style_context (widget);
GtkStateFlags flags = 0;
state_type = gtk_widget_get_state (widget);
/* FIXME: someone make this layout work nicely for all themes
* Currently I'm trying to imitate the volume applet's widget */
if (gtk_toggle_button_get_inconsistent (GTK_TOGGLE_BUTTON (widget))) {
if (state_type == GTK_STATE_ACTIVE)
state_type = GTK_STATE_NORMAL;
shadow_type = GTK_SHADOW_ETCHED_IN;
} else {
shadow_type = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)) ? GTK_SHADOW_IN : GTK_SHADOW_OUT;
}
if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (widget)))
state_type = GTK_STATE_SELECTED;
/* FIXME: better detail? */
gtk_widget_get_allocation (widget, &allocation);
gtk_style_context_add_class (context, "togglebutton");
switch (state_type)
{
case GTK_STATE_PRELIGHT:
flags |= GTK_STATE_FLAG_PRELIGHT;
break;
case GTK_STATE_SELECTED:
flags |= GTK_STATE_FLAG_SELECTED;
break;
case GTK_STATE_INSENSITIVE:
flags |= GTK_STATE_FLAG_INSENSITIVE;
break;
case GTK_STATE_ACTIVE:
flags |= GTK_STATE_FLAG_ACTIVE;
break;
case GTK_STATE_FOCUSED:
flags |= GTK_STATE_FLAG_FOCUSED;
break;
case GTK_STATE_NORMAL:
case GTK_STATE_INCONSISTENT:
default:
break;
}
gtk_style_context_set_state (context, flags);
gtk_render_background (context, cr, (gdouble) allocation.x, (gdouble) allocation.y,
(gdouble) allocation.width, (gdouble) allocation.height);
(void) shadow_type;
if (child)
gtk_container_propagate_draw (GTK_CONTAINER (widget), child, cr);
return FALSE;
}
static void
cb_state_change (GtkWidget *widget, G_GNUC_UNUSED GtkStateType old_state, GOComboBox *combo_box)
{
GtkStateType const new_state = gtk_widget_get_state (widget);
if (combo_box->priv->display_widget)
gtk_widget_set_state (combo_box->priv->display_widget,
new_state);
}
GtkStateType nsgtk_widget_get_state(GtkWidget *widget)
{
#if GTK_CHECK_VERSION(2,18,0)
return gtk_widget_get_state(widget);
#else
return GTK_WIDGET_STATE(widget);
#endif
}
static void draw(Scope *scope)
{
guint segcnt, i;
GdkPoint pt[SCOPE_WIDTH+1];
GdkSegment seg[100], *segp;
GtkWidget *widget;
GtkAllocation allocation;
GtkStyle *style;
widget = GTK_WIDGET(scope);
g_return_if_fail(gtk_widget_is_drawable(widget));
g_return_if_fail(scope->pixmap);
gtk_widget_get_allocation(widget, &allocation);
style = gtk_widget_get_style(widget);
/* calculate grid segments */
for (segp = seg, segcnt = i = 0; i < SCOPE_WIDTH; i += SCOPE_WIDTH/8) {
segp->x1 = segp->x2 = i;
segp->y1 = SCOPE_HEIGHT/2-5;
segp->y2 = SCOPE_HEIGHT/2+5;
segp++;
segcnt++;
}
segp->y1 = segp->y2 = SCOPE_HEIGHT/2;
segp->x1 = 0;
segp->x2 = SCOPE_WIDTH-1;
segp++;
segcnt++;
/* copy data points */
for (i = 0; i < SCOPE_WIDTH; i++) {
pt[i].x = i;
pt[i].y = ((32767-(int)scope->y[i])*SCOPE_HEIGHT) >> 16;
}
/* clear window */
gdk_draw_rectangle(scope->pixmap, style->base_gc[gtk_widget_get_state(widget)],
TRUE, 0, 0,
allocation.width,
allocation.height);
/* draw grid */
gdk_draw_segments(scope->pixmap, scope->grid_gc, seg, segcnt);
/* draw trace */
gdk_draw_lines(scope->pixmap, scope->trace_gc, pt, SCOPE_WIDTH);
/* draw to screen */
gdk_draw_drawable(gtk_widget_get_window(widget), style->base_gc[gtk_widget_get_state(widget)], scope->pixmap,
0, 0, 0, 0, allocation.width, allocation.height);
}
/* Draws a rounded rectangle with text inside. */
static gboolean
numbers_draw_cb (GtkWidget *widget, cairo_t *ctx, gpointer data)
{
double x, y, w, h;
PangoLayout * layout;
gint font_size = gtk_widget_get_font_size (widget);
#if (INDICATOR_MESSAGES_HAS_LOZENGE == 1)
gboolean is_lozenge = GPOINTER_TO_INT (g_object_get_data (G_OBJECT (widget), "is-lozenge"));
/* let the label handle the drawing if it's not a lozenge */
if (!is_lozenge)
return FALSE;
#endif
if (!GTK_IS_WIDGET (widget)) return FALSE;
/* get style + arrow position / dimensions */
double red, green, blue;
GtkStyleContext *style = gtk_widget_get_style_context (widget);
GdkRGBA color;
gtk_style_context_get_color (style, gtk_widget_get_state(widget), &color);
red = color.red;
green = color.green;
blue = color.blue;
GtkAllocation allocation;
gtk_widget_get_allocation (widget, &allocation);
w = allocation.width;
h = allocation.height;
x = y = 0;
layout = gtk_label_get_layout (GTK_LABEL(widget));
PangoRectangle layout_extents;
pango_layout_get_extents (layout, NULL, &layout_extents);
pango_extents_to_pixels (&layout_extents, NULL);
if (layout_extents.width == 0)
return TRUE;
cairo_set_line_width (ctx, 1.0);
cairo_set_fill_rule (ctx, CAIRO_FILL_RULE_EVEN_ODD);
/* cairo drawing code */
custom_cairo_rounded_rectangle (ctx, x - font_size/2.0, y, w + font_size, h);
cairo_set_source_rgba (ctx, red,
green,
blue, 0.5);
x += (allocation.width - layout_extents.width) / 2.0;
y += (allocation.height - layout_extents.height) / 2.0;
cairo_move_to (ctx, floor (x), floor (y));
pango_cairo_layout_path (ctx, layout);
cairo_fill (ctx);
return TRUE;
}
gint expose_event( GtkWidget *widget, GdkEventExpose *event, gpointer data )
{
gdk_draw_drawable( widget->window,
widget->style->fg_gc[gtk_widget_get_state( widget )],
pixmap,
0, 0, 0, 0,
width, height );
return TRUE;
}
static void
type_toggled_cb(GtkWidget *widget, gpointer data)
{
if (gtk_widget_get_state (widget) & GTK_STATE_SELECTED)
{
grid_type = GPOINTER_TO_INT (data);
preview_redraw();
}
}
static gboolean window_menu_on_expose(GtkWidget* widget, GdkEventExpose* event, gpointer data)
{
WindowMenu* window_menu = data;
if (gtk_widget_has_focus(window_menu->applet))
gtk_paint_focus(gtk_widget_get_style(widget), gtk_widget_get_window(widget), gtk_widget_get_state(widget), NULL, widget, "menu-applet", 0, 0, -1, -1);
return FALSE;
}
gboolean draw_mypb(GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
int off;
GtkAllocation alloc;
pqi const inst = (pqi)data;
gtk_widget_get_allocation(inst->box, &alloc); /* Get the dimensions of our widget */
off = inst->clicked ? (int)(alloc.width / 16.0) : 0; /* Use it as our draw offset */
gdk_draw_pixbuf(widget->window,widget->style->fg_gc[gtk_widget_get_state(widget)],inst->glowing?inst->pmainicon_glow:inst->pmainicon,0,0,off-1,off-1,-1,-1,GDK_RGB_DITHER_NONE,0,0);
return TRUE;
}
static void gdkDrawFocusRect(Ihandle* ih, int x, int y, int w, int h)
{
GdkWindow* window = iupgtkGetWindow(ih->handle);
GtkStyle *style = gtk_widget_get_style(ih->handle);
#if GTK_CHECK_VERSION(2, 18, 0)
GtkStateType state = gtk_widget_get_state(ih->handle);
#else
GtkStateType state = GTK_WIDGET_STATE(ih->handle);
#endif
gtk_paint_focus(style, window, state, NULL, ih->handle, NULL, x, y, w, h);
}
/*
* This is the signal handler for the "pressed" or "enter" signal handler
* on the GtkButton.
*
* If the state is now GTK_STATE_ACTIVE we notify a property change
*/
static void
gail_button_pressed_enter_handler (GtkWidget *widget)
{
AtkObject *accessible;
if (gtk_widget_get_state (widget) == GTK_STATE_ACTIVE)
{
accessible = gtk_widget_get_accessible (widget);
atk_object_notify_state_change (accessible, ATK_STATE_ARMED, TRUE);
GAIL_BUTTON (accessible)->state = GTK_STATE_ACTIVE;
}
}
/* Redraw the screen from the backing pixmap */
static gboolean
expose_event (GtkWidget *widget, GdkEventExpose *event)
{
gdk_draw_drawable (widget->window,
widget->style->fg_gc[gtk_widget_get_state (widget)],
pixmap,
event->area.x, event->area.y,
event->area.x, event->area.y,
event->area.width, event->area.height);
return FALSE;
}
void wxStatusBarGeneric::OnPaint(wxPaintEvent& WXUNUSED(event) )
{
wxPaintDC dc(this);
#ifdef __WXGTK20__
// Draw grip first
if ( ShowsSizeGrip() )
{
const wxRect& rc = GetSizeGripRect();
#ifdef __WXGTK3__
GtkWidget* toplevel = gtk_widget_get_toplevel(m_widget);
GdkRectangle rect;
if (toplevel && (!gtk_window_get_resize_grip_area(GTK_WINDOW(toplevel), &rect) ||
rect.width == 0 || rect.height == 0))
{
GtkStyleContext* sc = gtk_widget_get_style_context(toplevel);
gtk_style_context_save(sc);
gtk_style_context_add_class(sc, GTK_STYLE_CLASS_GRIP);
GtkJunctionSides sides = GTK_JUNCTION_CORNER_BOTTOMRIGHT;
if (GetLayoutDirection() == wxLayout_RightToLeft)
sides = GTK_JUNCTION_CORNER_BOTTOMLEFT;
gtk_style_context_set_junction_sides(sc, sides);
gtk_render_handle(sc,
static_cast<cairo_t*>(dc.GetImpl()->GetCairoContext()),
rc.x, rc.y, rc.width, rc.height);
gtk_style_context_restore(sc);
}
#else
GdkWindowEdge edge =
GetLayoutDirection() == wxLayout_RightToLeft ? GDK_WINDOW_EDGE_SOUTH_WEST :
GDK_WINDOW_EDGE_SOUTH_EAST;
gtk_paint_resize_grip(gtk_widget_get_style(m_widget),
GTKGetDrawingWindow(),
gtk_widget_get_state(m_widget),
NULL,
m_widget,
"statusbar",
edge,
rc.x, rc.y, rc.width, rc.height );
#endif
}
#endif // __WXGTK20__
if (GetFont().IsOk())
dc.SetFont(GetFont());
// compute char height only once for all panes:
int textHeight = dc.GetCharHeight();
dc.SetBackgroundMode(wxBRUSHSTYLE_TRANSPARENT);
for (size_t i = 0; i < m_panes.GetCount(); i ++)
DrawField(dc, i, textHeight);
}
GtkStateFlags nsgtk_widget_get_state_flags(GtkWidget *widget)
{
#if GTK_CHECK_VERSION(3,0,0)
return gtk_widget_get_state_flags(widget);
#else
#if GTK_CHECK_VERSION(2,18,0)
return gtk_widget_get_state(widget);
#else
return 0; /* FIXME */
#endif
#endif
}