void
modify_drawable(GdkDrawable *base, GdkGC *gc, guint32 tintcolor, gint alpha)
{
int w, h;
GdkPixbuf *ret, *ret2;
static GdkColormap *cmap = NULL;
ENTER;
gdk_drawable_get_size (base, &w, &h);
if (!cmap) {
cmap = gdk_colormap_get_system ();
}
ret = gdk_pixbuf_get_from_drawable (NULL, base, cmap, 0, 0, 0, 0, w, h);
if (!ret)
RET();
ret2 = gdk_pixbuf_composite_color_simple(ret, w, h,
GDK_INTERP_HYPER, alpha, MIN(w, h), tintcolor, tintcolor);
//gdk_pixbuf_render_to_drawable (ret2, base, gc, 0, 0, 0, 0, w, h, GDK_RGB_DITHER_NONE, 0, 0);
gdk_draw_pixbuf (base, gc, ret2, 0, 0, 0, 0, w, h, GDK_RGB_DITHER_NONE, 0, 0);
g_object_unref(ret);
g_object_unref(ret2);
RET();
}
static void
_paint_lyrics (OlScrollWindow *scroll, cairo_t *cr)
{
ol_assert (OL_IS_SCROLL_WINDOW (scroll));
GtkWidget *widget = GTK_WIDGET (scroll);
ol_assert (GTK_WIDGET_REALIZED (widget));
OlScrollWindowPrivate *priv = OL_SCROLL_WINDOW_GET_PRIVATE (scroll);
int line_height = ol_scroll_window_get_font_height (scroll) + priv->line_margin;
int count = ol_scroll_window_compute_line_count (scroll);
gint width, height;
gdk_drawable_get_size (gtk_widget_get_window (GTK_WIDGET (scroll)),
&width, &height);
/* set the font */
PangoLayout *layout = _get_pango (scroll, cr);
/* paint the lyrics*/
cairo_save (cr);
cairo_new_path (cr);
cairo_rectangle (cr,
priv->padding_x, 0,
width - priv->padding_x * 2,
height - priv->padding_y * 2);
cairo_close_path (cr);
cairo_clip (cr);
int i;
gint current_lyric_id;
gint lrc_y;
_calc_paint_pos (scroll,
¤t_lyric_id,
&lrc_y);
int begin = current_lyric_id - count / 2;
int end = current_lyric_id + count / 2 + 1;
int ypos = height / 2 - lrc_y - (count / 2 + 1) * line_height;
cairo_set_source_rgb(cr,
priv->inactive_color.r,
priv->inactive_color.g,
priv->inactive_color.b);
if (scroll->whole_lyrics != NULL) {
for (i = begin; i < end; i++) {
ypos += line_height;
if (i < 0) continue;
if (i >= scroll->whole_lyrics->len)
break;
pango_layout_set_text (layout,
g_ptr_array_index (scroll->whole_lyrics, i),
-1);
cairo_save (cr);
double ratio = _get_active_color_ratio (scroll, i);
double alpha = 1.0;
if (ypos < line_height / 2.0 + priv->padding_y)
alpha = 1.0 - (line_height / 2.0 + priv->padding_y - ypos) * 1.0 / line_height * 2;
else if (ypos > height - line_height * 1.5 - priv->padding_y)
alpha = (height - line_height - priv->padding_y - ypos) * 1.0 / line_height * 2;
if (alpha < 0.0) alpha = 0.0;
cairo_set_source_rgba (cr,
priv->active_color.r * ratio +
priv->inactive_color.r * (1 - ratio),
priv->active_color.g * ratio +
priv->inactive_color.g * (1 - ratio),
priv->active_color.b * ratio +
priv->inactive_color.b * (1 - ratio),
alpha);
cairo_move_to (cr, priv->padding_x, ypos);
pango_cairo_update_layout (cr, layout);
pango_cairo_show_layout (cr, layout);
cairo_restore (cr);
}
}
g_object_unref (layout);
cairo_reset_clip (cr);
cairo_restore (cr);
}
static gint32
shoot (GdkScreen *screen)
{
GdkDisplay *display;
GdkWindow *window;
GdkPixbuf *screenshot;
GdkRegion *shape = NULL;
GdkRectangle rect;
GdkRectangle screen_rect;
gchar *name = NULL;
gint32 image;
gint screen_x;
gint screen_y;
gint x, y;
/* use default screen if we are running non-interactively */
if (screen == NULL)
screen = gdk_screen_get_default ();
display = gdk_screen_get_display (screen);
screen_rect.x = 0;
screen_rect.y = 0;
screen_rect.width = gdk_screen_get_width (screen);
screen_rect.height = gdk_screen_get_height (screen);
if (shootvals.shoot_type == SHOOT_REGION)
{
rect.x = MIN (shootvals.x1, shootvals.x2);
rect.y = MIN (shootvals.y1, shootvals.y2);
rect.width = ABS (shootvals.x2 - shootvals.x1);
rect.height = ABS (shootvals.y2 - shootvals.y1);
}
else
{
if (shootvals.shoot_type == SHOOT_ROOT)
{
window = gdk_screen_get_root_window (screen);
}
else
{
window = gdk_window_foreign_new_for_display (display,
shootvals.window_id);
}
if (! window)
{
g_message (_("Specified window not found"));
return -1;
}
gdk_drawable_get_size (GDK_DRAWABLE (window), &rect.width, &rect.height);
gdk_window_get_origin (window, &x, &y);
rect.x = x;
rect.y = y;
}
if (! gdk_rectangle_intersect (&rect, &screen_rect, &rect))
return -1;
window = gdk_screen_get_root_window (screen);
gdk_window_get_origin (window, &screen_x, &screen_y);
screenshot = gdk_pixbuf_get_from_drawable (NULL, window, NULL,
rect.x - screen_x,
rect.y - screen_y,
0, 0, rect.width, rect.height);
gdk_display_beep (display);
gdk_flush ();
if (! screenshot)
{
g_message (_("There was an error taking the screenshot."));
return -1;
}
if (shootvals.shoot_type == SHOOT_WINDOW)
{
name = window_get_title (display, shootvals.window_id);
shape = window_get_shape (screen, shootvals.window_id);
if (shape)
gdk_region_offset (shape, x - rect.x, y - rect.y);
}
image = create_image (screenshot, shape, name);
g_object_unref (screenshot);
if (shape)
gdk_region_destroy (shape);
g_free (name);
return image;
}
void XAttGtk::change_value(int set_focus)
{
int sts;
GtkWidget* text_w;
int multiline;
char* value;
int input_size;
if (input_open) {
g_object_set(cmd_input, "visible", FALSE, NULL);
g_object_set(cmd_scrolledinput, "visible", FALSE, NULL);
set_prompt("");
input_open = 0;
return;
}
sts = xattnav->check_attr(
&multiline, &input_node, input_name, &value, &input_size);
if (EVEN(sts)) {
if (sts == XATT__NOATTRSEL)
message('E', "No attribute is selected");
else
message('E', XNav::get_message(sts));
return;
}
if (multiline) {
text_w = cmd_scrolledinput;
g_object_set(text_w, "visible", TRUE, NULL);
int w, h;
gdk_drawable_get_size(pane->window, &w, &h);
gtk_paned_set_position(GTK_PANED(pane), h - 170);
if (set_focus)
gtk_widget_grab_focus(cmd_scrolledtextview);
input_max_length = input_size - 1;
input_multiline = 1;
} else {
text_w = cmd_input;
g_object_set(text_w, "visible", TRUE, "max-length", input_size - 1, NULL);
if (set_focus)
gtk_widget_grab_focus(cmd_input);
input_multiline = 0;
}
message(' ', "");
if (value) {
if (multiline) {
GtkTextIter start_iter, end_iter;
gtk_text_buffer_get_start_iter(cmd_scrolled_buffer, &start_iter);
gtk_text_buffer_get_end_iter(cmd_scrolled_buffer, &end_iter);
gtk_text_buffer_delete(cmd_scrolled_buffer, &start_iter, &end_iter);
gtk_text_buffer_get_start_iter(cmd_scrolled_buffer, &start_iter);
gtk_text_buffer_insert(cmd_scrolled_buffer, &start_iter, value, -1);
// Select the text
// gtk_text_buffer_get_start_iter( cmd_scrolled_buffer, &start_iter);
// gtk_text_buffer_get_end_iter( cmd_scrolled_buffer, &end_iter);
// gtk_text_buffer_select_range( cmd_scrolled_buffer, &start_iter,
// &end_iter);
} else {
gint pos = 0;
gtk_editable_delete_text(GTK_EDITABLE(cmd_input), 0, -1);
gtk_editable_insert_text(
GTK_EDITABLE(text_w), value, strlen(value), &pos);
// Select the text
gtk_editable_set_position(GTK_EDITABLE(cmd_input), -1);
gtk_editable_select_region(GTK_EDITABLE(cmd_input), 0, -1);
}
} else {
gtk_editable_delete_text(GTK_EDITABLE(cmd_input), 0, -1);
}
message(' ', "");
set_prompt(Lng::translate("value >"));
input_open = 1;
}
static void
draw_icon (GtkWidget *widget, GtkIconEntryPosition icon_pos)
{
GtkIconEntry *entry;
GtkIconEntryPrivate *priv;
EntryIconInfo *icon_info;
GdkPixbuf *pixbuf;
gint x, y, width, height;
entry = GTK_ICON_ENTRY (widget);
priv = GTK_ICON_ENTRY_GET_PRIVATE (entry);
icon_info = &priv->icons[icon_pos];
if (icon_info->pixbuf == NULL || !GTK_WIDGET_REALIZED (widget))
return;
if ((pixbuf = get_pixbuf_from_icon (entry, icon_pos)) == NULL)
return;
gdk_drawable_get_size (icon_info->window, &width, &height);
if (width == 1 || height == 1)
{
/*
* size_allocate hasn't been called yet. These are the default values.
*/
return;
}
if (gdk_pixbuf_get_height (pixbuf) > height)
{
GdkPixbuf *temp_pixbuf;
int scale;
scale = height - (2 * ICON_MARGIN);
temp_pixbuf = gdk_pixbuf_scale_simple (pixbuf, scale, scale,
GDK_INTERP_BILINEAR);
g_object_unref (pixbuf);
pixbuf = temp_pixbuf;
}
x = (width - gdk_pixbuf_get_width(pixbuf)) / 2;
y = (height - gdk_pixbuf_get_height(pixbuf)) / 2;
if (icon_info->insensitive)
{
GdkPixbuf *temp_pixbuf;
temp_pixbuf = gdk_pixbuf_copy (pixbuf);
gdk_pixbuf_saturate_and_pixelate (pixbuf,
temp_pixbuf,
0.8f,
TRUE);
g_object_unref (pixbuf);
pixbuf = temp_pixbuf;
}
else if (icon_info->hovered)
{
GdkPixbuf *temp_pixbuf;
temp_pixbuf = gdk_pixbuf_copy (pixbuf);
colorshift_pixbuf (temp_pixbuf, pixbuf, 30);
g_object_unref (pixbuf);
pixbuf = temp_pixbuf;
}
gdk_draw_pixbuf (icon_info->window, widget->style->black_gc, pixbuf,
0, 0, x, y, -1, -1,
GDK_RGB_DITHER_NORMAL, 0, 0);
g_object_unref (pixbuf);
}
static gboolean
gtk_mirror_bin_expose (GtkWidget *widget,
GdkEventExpose *event)
{
GtkMirrorBin *bin = GTK_MIRROR_BIN (widget);
gint width, height;
if (gtk_widget_is_drawable (widget))
{
if (event->window == widget->window)
{
GdkPixmap *pixmap;
cairo_t *cr;
cairo_matrix_t matrix;
cairo_pattern_t *mask;
if (bin->child && gtk_widget_get_visible (bin->child))
{
pixmap = gdk_offscreen_window_get_pixmap (bin->offscreen_window);
gdk_drawable_get_size (pixmap, &width, &height);
cr = gdk_cairo_create (widget->window);
cairo_save (cr);
cairo_rectangle (cr, 0, 0, width, height);
cairo_clip (cr);
/* paint the offscreen child */
gdk_cairo_set_source_pixmap (cr, pixmap, 0, 0);
cairo_paint (cr);
cairo_restore (cr);
cairo_matrix_init (&matrix, 1.0, 0.0, 0.3, 1.0, 0.0, 0.0);
cairo_matrix_scale (&matrix, 1.0, -1.0);
cairo_matrix_translate (&matrix, -10, - 3 * height - 10);
cairo_transform (cr, &matrix);
cairo_rectangle (cr, 0, height, width, height);
cairo_clip (cr);
gdk_cairo_set_source_pixmap (cr, pixmap, 0, height);
/* create linear gradient as mask-pattern to fade out the source */
mask = cairo_pattern_create_linear (0.0, height, 0.0, 2*height);
cairo_pattern_add_color_stop_rgba (mask, 0.0, 0.0, 0.0, 0.0, 0.0);
cairo_pattern_add_color_stop_rgba (mask, 0.25, 0.0, 0.0, 0.0, 0.01);
cairo_pattern_add_color_stop_rgba (mask, 0.5, 0.0, 0.0, 0.0, 0.25);
cairo_pattern_add_color_stop_rgba (mask, 0.75, 0.0, 0.0, 0.0, 0.5);
cairo_pattern_add_color_stop_rgba (mask, 1.0, 0.0, 0.0, 0.0, 1.0);
/* paint the reflection */
cairo_mask (cr, mask);
cairo_pattern_destroy (mask);
cairo_destroy (cr);
}
}
else if (event->window == bin->offscreen_window)
{
gtk_paint_flat_box (widget->style, event->window,
GTK_STATE_NORMAL, GTK_SHADOW_NONE,
&event->area, widget, "blah",
0, 0, -1, -1);
if (bin->child)
gtk_container_propagate_expose (GTK_CONTAINER (widget),
bin->child,
event);
}
}
return FALSE;
}
static GtkWidget *
pop_calendar_window(GtkWidget *parent, int orientation)
{
GtkWidget *window;
GtkWidget *cal;
gint parent_x, parent_y, parent_w, parent_h;
gint root_w, root_h;
gint width, height, x, y;
GtkRequisition requisition;
GtkAllocation allocation;
window = gtk_window_new(GTK_WINDOW_POPUP);
cal = gtk_calendar_new();
gtk_container_add(GTK_CONTAINER(window), cal);
gdk_window_get_origin(GDK_WINDOW(parent->window), &parent_x, &parent_y);
gdk_drawable_get_size(GDK_DRAWABLE(parent->window), &parent_w, &parent_h);
root_w = gdk_screen_width();
root_h = gdk_screen_height();
gtk_widget_realize(GTK_WIDGET(window));
gtk_widget_size_request(GTK_WIDGET(cal), &requisition);
allocation.x = requisition.width;
allocation.y = requisition.height;
gtk_widget_size_allocate(GTK_WIDGET(cal), &allocation);
gtk_widget_size_request(GTK_WIDGET(cal), &requisition);
width = requisition.width;
height = requisition.height;
g_print("parent: %dx%d +%d+%d\n", parent_w, parent_h, parent_x, parent_y);
g_print("root: %dx%d\n", root_w, root_h);
g_print("calendar: %dx%d\n", width, height);
if (orientation == GTK_ORIENTATION_VERTICAL) {
if (parent_x < root_w / 2) {
if (parent_y < root_h / 2) {
/* upper left */
x = parent_x + parent_w;
y = parent_y;
} else {
/* lower left */
x = parent_x + parent_w;
y = parent_y + parent_h - height;
}
} else {
if (parent_y < root_h / 2) {
/* upper right */
x = parent_x - width;
y = parent_y;
} else {
/* lower right */
x = parent_x - width;
y = parent_y + parent_h - height;
}
}
} else {
if (parent_x < root_w / 2) {
if (parent_y < root_h / 2) {
/* upper left */
x = parent_x;
y = parent_y + parent_h;
} else {
/* lower left */
x = parent_x;
y = parent_y - height;
}
} else {
if (parent_y < root_h / 2) {
/* upper right */
x = parent_x + parent_w - width;
y = parent_y + parent_h;
} else {
/* lower right */
x = parent_x + parent_w - width;
y = parent_y - height;
}
}
}
gtk_window_move(GTK_WINDOW(window), x, y);
gtk_widget_show(cal);
gtk_widget_show(window);
return window;
}
static gboolean
draw_simple_image (GtkStyle *style,
GdkWindow *window,
GdkRectangle *area,
GtkWidget *widget,
ThemeMatchData *match_data,
gboolean draw_center,
gint x,
gint y,
gint width,
gint height)
{
gboolean maemo_position_theming;
ThemeImage *image;
if ((width == -1) && (height == -1))
gdk_drawable_get_size (window, &width, &height);
else if (width == -1)
gdk_drawable_get_size (window, &width, NULL);
else if (height == -1)
gdk_drawable_get_size (window, NULL, &height);
if (!(match_data->flags & THEME_MATCH_ORIENTATION))
{
match_data->flags |= THEME_MATCH_ORIENTATION;
if (height > width)
match_data->orientation = GTK_ORIENTATION_VERTICAL;
else
match_data->orientation = GTK_ORIENTATION_HORIZONTAL;
}
/* Check for maemo-position-theming to update the position data */
if (widget && widget->parent &&
gtk_widget_class_find_style_property (GTK_WIDGET_GET_CLASS (widget->parent),
"maemo-position-theming"))
{
gtk_widget_style_get (widget->parent,
"maemo-position-theming", &maemo_position_theming,
NULL);
if (maemo_position_theming)
{
if (GTK_IS_BUTTON_BOX (widget->parent))
check_buttonbox_child_position (widget, match_data);
else
{
/* Generic code for other kinds of containers */
GList *children;
children = gtk_container_get_children (GTK_CONTAINER (widget->parent));
check_child_position (widget, children, match_data);
g_list_free (children);
}
}
}
image = match_theme_image (style, match_data);
if (image)
{
if (image->background)
{
GdkWindow *maskwin;
GdkBitmap *mask = NULL;
gboolean valid;
maskwin = get_window_for_shape (image, window, widget, x, y, width, height);
if (maskwin)
mask = gdk_pixmap_new (maskwin, width, height, 1);
valid = theme_pixbuf_render (image->background, G_OBJECT_TYPE (widget),
window, mask, area,
draw_center ? COMPONENT_ALL : COMPONENT_ALL | COMPONENT_CENTER,
FALSE,
x, y, width, height);
if (mask)
{
if (valid)
gdk_window_shape_combine_mask (maskwin, mask, 0, 0);
g_object_unref (mask);
}
}
if (image->overlay && draw_center)
theme_pixbuf_render (image->overlay, G_OBJECT_TYPE (widget),
window, NULL, area, COMPONENT_ALL,
TRUE,
x, y, width, height);
return TRUE;
}
else
return FALSE;
}
HICON pixmap_to_hicon (GdkPixmap *pixmap, GdkBitmap *mask)
{
ICONINFO ii;
HICON hIcon;
gint w = 0, h = 0;
HANDLE hpixmap = NULL;
HBITMAP hbitmap = NULL;
/* Create Drawing Context */
HDC hdc1 = NULL;
HBITMAP hbitmaptmp1 = NULL;
if (!pixmap) {
return NULL;
}
gdk_drawable_get_size (GDK_DRAWABLE (pixmap), &w, &h);
hpixmap = gdk_win32_drawable_get_handle (pixmap);
/* we need the inverted mask for the XOR op */
hdc1 = CreateCompatibleDC (NULL);
hbitmap = CreateCompatibleBitmap (hdc1, w, h);
hbitmaptmp1 = SelectObject (hdc1, hbitmap);
if (mask) {
HANDLE hmask = NULL;
HDC hdc2 = NULL;
HBITMAP hbitmaptmp2 = NULL;
hmask = gdk_win32_drawable_get_handle (mask);
hdc2 = CreateCompatibleDC (NULL);
hbitmaptmp2 = SelectObject (hdc2, hmask);
BitBlt (hdc1, 0,0,w,h, hdc2, 0,0, NOTSRCCOPY);
SelectObject (hdc2, hbitmaptmp2);
DeleteDC (hdc2);
} else {
RECT rect;
GetClipBox (hdc1, &rect);
FillRect (hdc1, &rect, GetStockObject (WHITE_BRUSH));
}
SelectObject (hdc1, hbitmaptmp1);
DeleteDC (hdc1);
ii.fIcon = TRUE;
ii.xHotspot = ii.yHotspot = 0; /* ignored for icons */
ii.hbmMask = hbitmap;
ii.hbmColor = hpixmap;
hIcon = CreateIconIndirect (&ii);
if (!hIcon) {
return NULL;
}
DeleteObject (hbitmap);
return hIcon;
}
G_MODULE_EXPORT void save_as(const char *filename, int type)
{
FILE *fp;
unsigned int i, j;
double freq, k;
mat_t *mat;
matvar_t *matvar;
int dims[2];
char tmp[20];
GdkPixbuf *pixbuf;
GError *err=NULL;
GdkColormap *cmap;
gint width, height;
gboolean ret = true;
char *name;
gdouble *tmp_data;
name = malloc(strlen(filename) + 5);
switch(type) {
/* Response Codes encoded in glade file */
case GTK_RESPONSE_DELETE_EVENT:
case GTK_RESPONSE_CANCEL:
break;
case SAVE_VSA:
/* Allow saving data when only in Time Domanin */
if ((gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != TIME_PLOT) &&
(gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != XY_PLOT)) {
create_blocking_popup(GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, "Invalid Plot Type",
"Please make sure to set the Plot Type to \"Time Domanin\" before saving data.");
return;
}
/* Save as Agilent VSA formatted file */
if (!strncasecmp(&filename[strlen(filename)-4], ".txt", 4))
strcpy(name, filename);
else
sprintf(name, "%s.txt", filename);
fp = fopen(name, "w");
if (!fp)
break;
fprintf(fp, "InputZoom\tTRUE\n");
fprintf(fp, "InputCenter\t0\n");
fprintf(fp, "InputRange\t1\n");
fprintf(fp, "InputRefImped\t50\n");
fprintf(fp, "XStart\t0\n");
if (!strcmp(adc_scale, "M"))
freq = adc_freq * 1000000;
else if (!strcmp(adc_scale, "k"))
freq = adc_freq * 1000;
else {
printf("error in writing\n");
break;
}
fprintf(fp, "XDelta\t%-.17f\n", 1.0/freq);
fprintf(fp, "XDomain\t2\n");
fprintf(fp, "XUnit\tSec\n");
fprintf(fp, "YUnit\tV\n");
fprintf(fp, "FreqValidMax\t%e\n", freq / 2);
fprintf(fp, "FreqValidMin\t-%e\n", freq / 2);
fprintf(fp, "Y\n");
for (j = 0; j < num_samples; j++) {
for (i = 0; i < num_active_channels ; i++) {
fprintf(fp, "%g", channel_data[i][j]);
if (i < (num_active_channels - 1))
fprintf(fp, "\t");
}
fprintf(fp, "\n");
}
fprintf(fp, "\n");
fclose(fp);
break;
case SAVE_MAT:
/* Allow saving data when only in Time Domanin */
if (gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != TIME_PLOT) {
create_blocking_popup(GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, "Invalid Plot Type",
"Please make sure to set the Plot Type to \"Time Domanin\" before saving data.");
return;
}
/* Matlab file
* http://na-wiki.csc.kth.se/mediawiki/index.php/MatIO
*/
if (!strncasecmp(&filename[strlen(filename)-4], ".mat", 4))
strcpy(name, filename);
else
sprintf(name, "%s.mat", filename);
dims[1] = 1;
dims[0] = num_samples;
mat = Mat_Open(name, MAT_ACC_RDWR);
if(mat) {
for (i = 0; i < num_active_channels; i++) {
sprintf(tmp, "in_voltage%d", i);
if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(save_mat_scale))) {
matvar = Mat_VarCreate(tmp, MAT_C_SINGLE,
MAT_T_SINGLE, 2, dims, channel_data[i], 0);
} else {
tmp_data = g_new(gdouble, num_samples);
if (channels[i].is_signed)
k = channels[i].bits_used - 1;
else
k = channels[i].bits_used;
for (j = 0; j < num_samples; j++) {
tmp_data[j] = (gdouble)channel_data[i][j] /
(pow(2.0, k));
}
matvar = Mat_VarCreate(tmp, MAT_C_DOUBLE,
MAT_T_DOUBLE, 2, dims, tmp_data, 0);
g_free(tmp_data);
}
if (!matvar)
printf("error creating matvar on channel %i\n", i);
else {
Mat_VarWrite(mat, matvar, 0);
Mat_VarFree(matvar);
}
}
Mat_Close(mat);
}
break;
case SAVE_CSV:
/* Allow saving data when only in Time Domanin */
if (gtk_combo_box_get_active(GTK_COMBO_BOX(plot_domain)) != TIME_PLOT) {
create_blocking_popup(GTK_MESSAGE_WARNING, GTK_BUTTONS_CLOSE, "Invalid Plot Type",
"Please make sure to set the Plot Type to \"Time Domanin\" before saving data.");
return;
}
/* save comma seperated valus (csv) */
if (!strncasecmp(&filename[strlen(filename)-4], ".csv", 4))
strcpy(name, filename);
else
sprintf(name, "%s.csv", filename);
fp = fopen(name, "w");
if (!fp)
break;
for (j = 0; j < num_samples; j++) {
for (i = 0; i < num_active_channels ; i++) {
fprintf(fp, "%g", channel_data[i][j]);
if (i < (num_active_channels - 1))
fprintf(fp, ", ");
}
fprintf(fp, "\n");
}
fprintf(fp, "\n");
fclose(fp);
break;
case SAVE_PNG:
/* save_png */
if (!strncasecmp(&filename[strlen(filename)-4], ".png", 4))
strcpy(name, filename);
else
sprintf(name, "%s.png", filename);
cmap = gdk_window_get_colormap(
GDK_DRAWABLE(gtk_widget_get_window(capture_graph)));
gdk_drawable_get_size(GDK_DRAWABLE(gtk_widget_get_window(capture_graph)),
&width, &height);
pixbuf = gdk_pixbuf_get_from_drawable(NULL,
GDK_DRAWABLE(gtk_widget_get_window(capture_graph)),
cmap, 0, 0, 0, 0, width, height);
if (pixbuf)
ret = gdk_pixbuf_save(pixbuf, name, "png", &err, NULL);
if (!pixbuf || !ret)
printf("error creating %s\n", name);
break;
default:
printf("ret : %i\n", ret);
}
free(name);
}
static gboolean
vik_print_preview_expose_event (GtkWidget *widget,
GdkEventExpose *eevent,
VikPrintPreview *preview)
{
gdouble paper_width;
gdouble paper_height;
gdouble left_margin;
gdouble right_margin;
gdouble top_margin;
gdouble bottom_margin;
gdouble scale;
cairo_t *cr;
paper_width = gtk_page_setup_get_paper_width (preview->page,
GTK_UNIT_POINTS);
paper_height = gtk_page_setup_get_paper_height (preview->page,
GTK_UNIT_POINTS);
vik_print_preview_get_page_margins (preview,
&left_margin,
&right_margin,
&top_margin,
&bottom_margin);
cr = gdk_cairo_create (gtk_widget_get_window(widget));
scale = vik_print_preview_get_scale (preview);
/* draw background */
cairo_scale (cr, scale, scale);
gdk_cairo_set_source_color (cr, >k_widget_get_style(widget)->white);
cairo_rectangle (cr, 0, 0, paper_width, paper_height);
cairo_fill (cr);
/* draw page_margins */
gdk_cairo_set_source_color (cr, >k_widget_get_style(widget)->black);
cairo_rectangle (cr,
left_margin,
top_margin,
paper_width - left_margin - right_margin,
paper_height - top_margin - bottom_margin);
cairo_stroke (cr);
if (preview->dragging)
{
gint width, height;
gdk_drawable_get_size(preview->drawable, &width, &height);
cairo_rectangle (cr,
left_margin + preview->image_offset_x,
top_margin + preview->image_offset_y,
(gdouble) width * 72.0 / preview->image_xres,
(gdouble) height * 72.0 / preview->image_yres);
cairo_stroke (cr);
}
else
{
GdkDrawable *drawable = preview->drawable;
/* draw image */
cairo_translate (cr,
left_margin + preview->image_offset_x,
top_margin + preview->image_offset_y);
if (preview->pixbuf == NULL)
{
gint width = MIN (widget->allocation.width, 1024);
gint height = MIN (widget->allocation.height, 1024);
preview->pixbuf = get_thumbnail(drawable, width, height);
}
if (preview->pixbuf != NULL)
{
gint width, height;
gdk_drawable_get_size(drawable, &width, &height);
gdouble scale_x = ((gdouble) width /
gdk_pixbuf_get_width (preview->pixbuf));
gdouble scale_y = ((gdouble) height /
gdk_pixbuf_get_height (preview->pixbuf));
scale_x = scale_x * 72.0 / preview->image_xres;
scale_y = scale_y * 72.0 / preview->image_yres;
cairo_scale (cr, scale_x, scale_y);
gdk_cairo_set_source_pixbuf (cr, preview->pixbuf, 0, 0);
cairo_paint (cr);
}
}
cairo_destroy (cr);
return FALSE;
}
gint compat_gdk_window_get_height(GdkWindow *window)
{
gint w, h;
gdk_drawable_get_size(window, &w, &h);
return h;
}
gint compat_gdk_window_get_width(GdkWindow *window)
{
gint w, h;
gdk_drawable_get_size(window, &w, &h);
return w;
}
void WdaGtk::change_value( int set_focus)
{
int sts;
GtkWidget *text_w;
int multiline;
char *value;
int input_size;
if ( input_open) {
g_object_set( cmd_input, "visible", FALSE, NULL);
g_object_set( cmd_scrolledinput, "visible", FALSE, NULL);
set_prompt( "");
input_open = 0;
return;
}
sts = wdanav->check_attr( &multiline, &input_node, input_name,
&value, &input_size);
if ( EVEN(sts)) {
if ( sts == WDA__NOATTRSEL)
message( 'E', "No attribute is selected");
else
message( 'E', wnav_get_message( sts));
return;
}
if ( multiline) {
text_w = cmd_scrolledinput;
g_object_set( text_w, "visible", TRUE, NULL);
int w, h;
gdk_drawable_get_size( pane->window, &w, &h);
gtk_paned_set_position( GTK_PANED(pane), h - 170);
gtk_widget_grab_focus( cmd_scrolledtextview);
input_multiline = 1;
}
else {
text_w = cmd_input;
g_object_set( text_w, "visible", TRUE, NULL);
gtk_widget_grab_focus( cmd_input);
input_multiline = 0;
}
message( ' ', "");
if ( value) {
char *valueutf8 = g_convert( value, -1, "UTF-8", "ISO8859-1", NULL, NULL, NULL);
if ( multiline) {
GtkTextIter start_iter, end_iter;
gtk_text_buffer_get_start_iter( cmd_scrolled_buffer, &start_iter);
gtk_text_buffer_get_end_iter( cmd_scrolled_buffer, &end_iter);
gtk_text_buffer_delete( cmd_scrolled_buffer, &start_iter, &end_iter);
gtk_text_buffer_get_start_iter( cmd_scrolled_buffer, &start_iter);
gtk_text_buffer_insert( cmd_scrolled_buffer, &start_iter, valueutf8, -1);
// Select the text
// gtk_text_buffer_get_start_iter( cmd_scrolled_buffer, &start_iter);
// gtk_text_buffer_get_end_iter( cmd_scrolled_buffer, &end_iter);
// gtk_text_buffer_select_range( cmd_scrolled_buffer, &start_iter, &end_iter);
}
else {
gint pos = 0;
gtk_editable_delete_text( GTK_EDITABLE(cmd_input), 0, -1);
gtk_editable_insert_text( GTK_EDITABLE(text_w), valueutf8, strlen(valueutf8), &pos);
// Select the text
gtk_editable_set_position( GTK_EDITABLE(cmd_input), -1);
gtk_editable_select_region( GTK_EDITABLE(cmd_input), 0, -1);
}
g_free( valueutf8);
}
else {
gtk_editable_delete_text( GTK_EDITABLE(cmd_input), 0, -1);
}
set_prompt( "value >");
input_open = 1;
}
WdaGtk::WdaGtk(
GtkWidget *wa_parent_wid,
void *wa_parent_ctx,
ldh_tSesContext wa_ldhses,
pwr_tObjid wa_objid,
pwr_tClassId wa_classid,
const char *wa_attribute,
int wa_editmode,
int wa_advanced_user,
int wa_display_objectname) :
Wda(wa_parent_ctx,wa_ldhses,wa_objid,wa_classid,wa_attribute,wa_editmode,
wa_advanced_user,wa_display_objectname),
parent_wid(wa_parent_wid), wdaclass_dia(0)
{
int sts;
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", 700,
"default-width", 700,
"title", "Spreadsheet Editor",
NULL);
g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);
g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this);
CoWowGtk::SetWindowIcon( toplevel);
GtkWidget *vbox = gtk_vbox_new( FALSE, 0);
// Menu
// Accelerators
GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);
GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File entry
GtkWidget *file_select_class = gtk_menu_item_new_with_mnemonic( "_Select Class");
g_signal_connect( file_select_class, "activate",
G_CALLBACK(activate_setclass), this);
gtk_widget_add_accelerator( file_select_class, "activate", accel_g,
'c', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *file_select_attr = gtk_menu_item_new_with_mnemonic( "Select _Attribute");
g_signal_connect( file_select_attr, "activate",
G_CALLBACK(activate_setattr), this);
gtk_widget_add_accelerator( file_select_attr, "activate", accel_g,
'a', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *file_next_attr = gtk_menu_item_new_with_mnemonic( "Next Attribute");
g_signal_connect( file_next_attr, "activate",
G_CALLBACK(activate_nextattr), this);
gtk_widget_add_accelerator( file_next_attr, "activate", accel_g,
'n', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *file_prev_attr = gtk_menu_item_new_with_mnemonic( "Previous Attribute");
g_signal_connect( file_prev_attr, "activate",
G_CALLBACK(activate_prevattr), this);
gtk_widget_add_accelerator( file_prev_attr, "activate", accel_g,
'p', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *file_export_text = gtk_menu_item_new_with_mnemonic( "Export to Textfile");
g_signal_connect( file_export_text, "activate",
G_CALLBACK(activate_export_text), this);
GtkWidget *file_import_text = gtk_menu_item_new_with_mnemonic( "Import from Textfile");
g_signal_connect( file_import_text, "activate",
G_CALLBACK(activate_import_text), this);
GtkWidget *file_print = gtk_image_menu_item_new_from_stock(GTK_STOCK_PRINT, NULL);
g_signal_connect(file_print, "activate", G_CALLBACK(activate_print), this);
GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_select_class);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_select_attr);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_next_attr);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_prev_attr);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_export_text);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_import_text);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Functions entry
GtkWidget *func_changevalue = gtk_menu_item_new_with_mnemonic( "_Change Value");
g_signal_connect( func_changevalue, "activate",
G_CALLBACK(activate_change_value), this);
gtk_widget_add_accelerator( func_changevalue, "activate", accel_g,
'q', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *func_close_changeval = gtk_menu_item_new_with_mnemonic( "C_lose Change Value");
g_signal_connect( func_close_changeval, "activate",
G_CALLBACK(activate_close_changeval), this);
gtk_widget_add_accelerator( func_close_changeval, "activate", accel_g,
't', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkMenu *func_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), func_changevalue);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), func_close_changeval);
GtkWidget *functions = gtk_menu_item_new_with_mnemonic("_Functions");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(func_menu));
// Help entry
GtkWidget *help_help = gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g);
g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
GtkWidget *help = gtk_menu_item_new_with_mnemonic("_Help");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
pane = gtk_vpaned_new();
utility = ((WUtility *)parent_ctx)->utype;
wdanav = new WdaNavGtk( (void *)this, pane, "Plant",
ldhses, objid, classid, attribute, wa_editmode,
wa_advanced_user,
wa_display_objectname, utility, &brow_widget, &sts);
wdanav->message_cb = &Wda::message_cb;
wdanav->change_value_cb = &Wda::change_value_cb;
GtkWidget *statusbar = gtk_hbox_new( FALSE, 0);
msg_label = gtk_label_new( "");
gtk_widget_set_size_request( msg_label, -1, 25);
cmd_prompt = gtk_label_new( "value > ");
gtk_widget_set_size_request( cmd_prompt, -1, 25);
cmd_entry = new CoWowEntryGtk( &value_recall);
cmd_input = cmd_entry->widget();
gtk_widget_set_size_request( cmd_input, -1, 25);
g_signal_connect( cmd_input, "activate",
G_CALLBACK(activate_cmd_input), this);
gtk_box_pack_start( GTK_BOX(statusbar), msg_label, FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(statusbar), cmd_prompt, FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(statusbar), cmd_input, TRUE, TRUE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_end( GTK_BOX(vbox), GTK_WIDGET(pane), TRUE, TRUE, 0);
gtk_paned_pack1( GTK_PANED(pane), GTK_WIDGET(brow_widget), TRUE, TRUE);
gtk_paned_pack2( GTK_PANED(pane), GTK_WIDGET(statusbar), FALSE, TRUE);
gtk_container_add( GTK_CONTAINER(toplevel), vbox);
cmd_scrolled_buffer = gtk_text_buffer_new( NULL);
cmd_scrolledtextview = gtk_text_view_new_with_buffer( cmd_scrolled_buffer);
GtkWidget *viewport = gtk_viewport_new( NULL, NULL);
GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add( GTK_CONTAINER(viewport), cmd_scrolledtextview);
gtk_container_add( GTK_CONTAINER(scrolledwindow), viewport);
cmd_scrolled_ok = gtk_button_new_with_label( "Ok");
gtk_widget_set_size_request( cmd_scrolled_ok, 70, 25);
g_signal_connect( cmd_scrolled_ok, "clicked",
G_CALLBACK(activate_cmd_scrolled_ok), this);
cmd_scrolled_ca = gtk_button_new_with_label( "Cancel");
gtk_widget_set_size_request( cmd_scrolled_ca, 70, 25);
g_signal_connect( cmd_scrolled_ca, "clicked",
G_CALLBACK(activate_cmd_scrolled_ca), this);
GtkWidget *hboxbuttons = gtk_hbox_new( TRUE, 40);
gtk_box_pack_start( GTK_BOX(hboxbuttons), cmd_scrolled_ok, FALSE, FALSE, 0);
gtk_box_pack_end( GTK_BOX(hboxbuttons), cmd_scrolled_ca, FALSE, FALSE, 0);
cmd_scrolledinput = gtk_vbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(cmd_scrolledinput), scrolledwindow, TRUE, TRUE, 0);
gtk_box_pack_start( GTK_BOX(cmd_scrolledinput), hboxbuttons, FALSE, FALSE, 5);
gtk_box_pack_start( GTK_BOX(statusbar), cmd_scrolledinput, TRUE, TRUE, 0);
gtk_widget_show_all( toplevel);
g_object_set( cmd_prompt, "visible", FALSE, NULL);
g_object_set( cmd_input, "visible", FALSE, NULL);
g_object_set( cmd_scrolledinput, "visible", FALSE, NULL);
int w, h;
gdk_drawable_get_size( pane->window, &w, &h);
gtk_paned_set_position( GTK_PANED(pane), h - 50);
create_class_dialog();
wow = new CoWowGtk( toplevel);
update_title();
if ( utility == wb_eUtility_Wtt) {
((Wtt *)parent_ctx)->register_utility( (void *) this,
wb_eUtility_SpreadsheetEditor);
}
((Wda *)this)->open_class_dialog();
}
void brush_bar(GdkDrawable *drawable, GdkGC *gc, int barWidth, int no)
{
int width, height;
GdkPoint points[3];
gdk_drawable_get_size(drawable, &width, &height);
set_foreground_color(gc, 65535*222/255, 65535*217/255, 65535*202/255);
switch (no) {
case 1:
gdk_draw_rectangle(drawable, gc, TRUE, 0, height/4, barWidth-1, height/2);
points[0].x = 7, points[0].y = height/2-5;
points[1].x = 2, points[1].y = height/2;
points[2].x = 7, points[2].y = height/2+5;
set_foreground_color(gc, 65535*255/255, 65535*255/255, 65535*255/255);
gdk_draw_polygon(drawable, gc, TRUE, points, 3);
break;
case 2:
gdk_draw_rectangle(drawable, gc, TRUE, 0, 3*height/4, barWidth-1, height/4-1);
gdk_draw_rectangle(drawable, gc, TRUE, 0, height-barWidth+1, width/4, barWidth-1);
points[0].x = 3, points[0].y = height-10;
points[1].x = 3, points[1].y = height-3;
points[2].x = 10, points[2].y = height-3;
set_foreground_color(gc, 65535*255/255, 65535*255/255, 65535*255/255);
gdk_draw_polygon(drawable, gc, TRUE, points, 3);
break;
case 3:
gdk_draw_rectangle(drawable, gc, TRUE, width/4, height-barWidth+1, width/2-1, barWidth-1);
points[0].x = width/2, points[0].y = height-2;
points[1].x = width/2+5, points[1].y = height-7;
points[2].x = width/2-5, points[2].y = height-7;
set_foreground_color(gc, 65535*255/255, 65535*255/255, 65535*255/255);
gdk_draw_polygon(drawable, gc, TRUE, points, 3);
break;
case 4:
gdk_draw_rectangle(drawable, gc, TRUE, width*3/4, height-barWidth+1, width/4, barWidth-1);
gdk_draw_rectangle(drawable, gc, TRUE, width-barWidth+1, height*3/4, barWidth-1, height/4);
points[0].x = width-10, points[0].y = height-3;
points[1].x = width-3, points[1].y = height-3;
points[2].x = width-3, points[2].y = height-10;
set_foreground_color(gc, 65535*255/255, 65535*255/255, 65535*255/255);
gdk_draw_polygon(drawable, gc, TRUE, points, 3);
break;
case 5:
gdk_draw_rectangle(drawable, gc, TRUE, width-barWidth+1, height/4, barWidth-1, height/2);
points[0].x = width-7, points[0].y = height/2-5;
points[1].x = width-2, points[1].y = height/2;
points[2].x = width-7, points[2].y = height/2+5;
set_foreground_color(gc, 65535*255/255, 65535*255/255, 65535*255/255);
gdk_draw_polygon(drawable, gc, TRUE, points, 3);
break;
case 6:
gdk_draw_rectangle(drawable, gc, TRUE, width*3/4, 0, width/4, barWidth-1);
gdk_draw_rectangle(drawable, gc, TRUE, width-MARGIN+1, 0, barWidth-1, height/4);
points[0].x = width-10, points[0].y = 3;
points[1].x = width-3, points[1].y = 3;
points[2].x = width-3, points[2].y = 10;
set_foreground_color(gc, 65535*255/255, 65535*255/255, 65535*255/255);
gdk_draw_polygon(drawable, gc, TRUE, points, 3);
break;
case 7:
gdk_draw_rectangle(drawable, gc, TRUE, width/4, 0, width/2, barWidth-1);
points[0].x = width/2, points[0].y = 2;
points[1].x = width/2-5, points[1].y = 7;
points[2].x = width/2+5, points[2].y = 7;
set_foreground_color(gc, 65535*255/255, 65535*255/255, 65535*255/255);
gdk_draw_polygon(drawable, gc, TRUE, points, 3);
break;
case 8:
gdk_draw_rectangle(drawable, gc, TRUE, 0, 0, barWidth-1, height/4);
gdk_draw_rectangle(drawable, gc, TRUE, 0, 0, width/4, barWidth-1);
points[0].x = 3, points[0].y = 3;
points[1].x = 3, points[1].y = 10;
points[2].x = 10, points[2].y = 3;
set_foreground_color(gc, 65535*255/255, 65535*255/255, 65535*255/255);
gdk_draw_polygon(drawable, gc, TRUE, points, 3);
break;
}
}
/*
* attrib_list is currently unused. This must be set to NULL or empty
* (first attribute of None). See GLX 1.3 spec.
*/
GdkGLPixmap *
gdk_gl_pixmap_new (GdkGLConfig *glconfig,
GdkPixmap *pixmap,
const int *attrib_list)
{
GdkGLPixmap *glpixmap;
GdkGLPixmapImplWin32 *impl;
gint width, height;
gint depth;
GdkPixmap *pixmap_gl = NULL;
HBITMAP hbitmap_gl;
HDC hdc_gl = NULL;
PIXELFORMATDESCRIPTOR pfd;
int pixel_format;
HBITMAP hbitmap_gdk;
HDC hdc_gdk = NULL;
GDK_GL_NOTE_FUNC ();
g_return_val_if_fail (GDK_IS_GL_CONFIG_IMPL_WIN32 (glconfig), NULL);
g_return_val_if_fail (GDK_IS_PIXMAP (pixmap), NULL);
/*
* Create offscreen rendering area.
*/
gdk_drawable_get_size (GDK_DRAWABLE (pixmap), &width, &height);
depth = gdk_drawable_get_depth (GDK_DRAWABLE (pixmap));
pixmap_gl = gdk_pixmap_new (NULL, width, height, depth);
if (pixmap_gl == NULL)
goto FAIL;
/*
* Source (OpenGL) DIB
*/
hbitmap_gl = (HBITMAP) gdk_win32_drawable_get_handle (GDK_DRAWABLE (pixmap_gl));
/* Create a memory DC. */
hdc_gl = CreateCompatibleDC (NULL);
if (hdc_gl == NULL)
{
g_warning ("cannot create a memory DC");
goto FAIL;
}
/* Select the bitmap. */
if (SelectObject (hdc_gl, hbitmap_gl) == NULL)
{
g_warning ("cannot select DIB");
goto FAIL;
}
/*
* Choose pixel format.
*/
pfd = *(GDK_GL_CONFIG_PFD (glconfig));
/* Draw to bitmap */
pfd.dwFlags &= ~PFD_DRAW_TO_WINDOW;
pfd.dwFlags |= PFD_DRAW_TO_BITMAP;
/* Request pfd.cColorBits should exclude alpha bitplanes. */
pfd.cColorBits = pfd.cRedBits + pfd.cGreenBits + pfd.cBlueBits;
GDK_GL_NOTE_FUNC_IMPL ("ChoosePixelFormat");
pixel_format = ChoosePixelFormat (hdc_gl, &pfd);
if (pixel_format == 0)
{
g_warning ("cannot choose pixel format");
goto FAIL;
}
/*
* Set pixel format.
*/
GDK_GL_NOTE_FUNC_IMPL ("SetPixelFormat");
if (!SetPixelFormat (hdc_gl, pixel_format, &pfd))
{
g_warning ("cannot set pixel format");
goto FAIL;
}
DescribePixelFormat (hdc_gl, pixel_format, sizeof (pfd), &pfd);
GDK_GL_NOTE (MISC, g_message (" -- impl->pixel_format = 0x%x", pixel_format));
GDK_GL_NOTE (MISC, _gdk_win32_gl_print_pfd (&pfd));
/*
* Destination (GDK) DIB
*/
hbitmap_gdk = (HBITMAP) gdk_win32_drawable_get_handle (GDK_DRAWABLE (pixmap));
/* Create a memory DC. */
hdc_gdk = CreateCompatibleDC (hdc_gl);
if (hdc_gdk == NULL)
{
g_warning ("cannot create a memory DC");
goto FAIL;
}
/*
* Instantiate the GdkGLPixmapImplWin32 object.
*/
glpixmap = g_object_new (GDK_TYPE_GL_PIXMAP_IMPL_WIN32, NULL);
impl = GDK_GL_PIXMAP_IMPL_WIN32 (glpixmap);
glpixmap->drawable = GDK_DRAWABLE (pixmap);
g_object_add_weak_pointer (G_OBJECT (glpixmap->drawable),
(gpointer *) &(glpixmap->drawable));
impl->pixmap_gl = pixmap_gl;
impl->width = width;
impl->height = height;
impl->pfd = pfd;
impl->pixel_format = pixel_format;
impl->glconfig = glconfig;
g_object_ref (G_OBJECT (impl->glconfig));
impl->hdc_gl = hdc_gl;
impl->hdc_gdk = hdc_gdk;
impl->hbitmap_gdk = hbitmap_gdk;
impl->is_destroyed = FALSE;
return glpixmap;
FAIL:
if (hdc_gdk != NULL)
DeleteDC (hdc_gdk);
if (hdc_gl != NULL)
DeleteDC (hdc_gl);
if (pixmap_gl != NULL)
g_object_unref (G_OBJECT (pixmap_gl));
return NULL;
}
static void
color_area_draw ()
{
Color col;
GdkColor *win_bg;
GdkColor fg, bg, bd;
gint rect_w, rect_h;
gint width, height;
gint def_width, def_height;
gint swap_width, swap_height;
GdkColor mask_pattern;
/* Check we haven't gotten initial expose yet,
* no point in drawing anything
*/
if (!color_area_pixmap || !color_area_gc)
return;
gdk_drawable_get_size (color_area_pixmap, &width, &height);
win_bg = &(color_area->style->bg[GTK_STATE_NORMAL]);
col = attributes_get_foreground();
color_convert(&col, &fg);
col = attributes_get_background();
color_convert(&col, &bg);
bd = color_gdk_black;
rect_w = width * 0.65;
rect_h = height * 0.65;
/* initialize the mask to transparent */
mask_pattern.pixel = 0;
gdk_gc_set_foreground (mask_gc, &mask_pattern);
gdk_draw_rectangle (color_area_mask, mask_gc, TRUE, 0, 0, -1, -1);
/* set the mask's gc to opaque */
mask_pattern.pixel = 1;
gdk_gc_set_foreground (mask_gc, &mask_pattern);
gdk_gc_set_foreground (color_area_gc, win_bg);
gdk_draw_rectangle (color_area_pixmap, color_area_gc, 1,
0, 0, width, height);
gdk_gc_set_foreground (color_area_gc, &bg);
gdk_draw_rectangle (color_area_pixmap, color_area_gc, 1,
(width - rect_w), (height - rect_h), rect_w, rect_h);
gdk_draw_rectangle (color_area_mask, mask_gc, TRUE,
(width - rect_w), (height - rect_h), rect_w, rect_h);
if (active_color == FOREGROUND)
gtk_paint_shadow (color_area->style, color_area_pixmap, GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
NULL, color_area, NULL,
(width - rect_w), (height - rect_h),
rect_w, rect_h);
else
gtk_paint_shadow (color_area->style, color_area_pixmap, GTK_STATE_NORMAL,
GTK_SHADOW_IN,
NULL, color_area, NULL,
(width - rect_w), (height - rect_h),
rect_w, rect_h);
gdk_gc_set_foreground (color_area_gc, &fg);
gdk_draw_rectangle (color_area_pixmap, color_area_gc, 1,
0, 0, rect_w, rect_h);
gdk_draw_rectangle (color_area_mask, mask_gc, TRUE,
0, 0, rect_w, rect_h);
if (active_color == FOREGROUND)
gtk_paint_shadow (color_area->style, color_area_pixmap, GTK_STATE_NORMAL,
GTK_SHADOW_IN,
NULL, color_area, NULL,
0, 0,
rect_w, rect_h);
else
gtk_paint_shadow (color_area->style, color_area_pixmap, GTK_STATE_NORMAL,
GTK_SHADOW_OUT,
NULL, color_area, NULL,
0, 0,
rect_w, rect_h);
/* draw the default pixmap */
gdk_drawable_get_size (default_pixmap, &def_width, &def_height);
gdk_draw_drawable (color_area_pixmap, color_area_gc, default_pixmap,
0, 0, 0, height - def_height, def_width, def_height);
gdk_draw_drawable (color_area_mask, mask_gc, default_mask,
0, 0, 0, height - def_height, def_width, def_height);
/* draw the swap pixmap */
gdk_drawable_get_size (swap_pixmap, &swap_width, &swap_height);
gdk_draw_drawable (color_area_pixmap, color_area_gc, swap_pixmap,
0, 0, width - swap_width, 0, swap_width, swap_height);
gdk_draw_drawable (color_area_mask, mask_gc, swap_mask,
0, 0, width - swap_width, 0, swap_width, swap_height);
/* draw the widget */
gdk_gc_set_clip_mask (color_area_gc, color_area_mask);
gdk_gc_set_clip_origin (color_area_gc, 0, 0);
gdk_draw_drawable (color_area->window, color_area_gc, color_area_pixmap,
0, 0, 0, 0, width, height);
/* reset the clip mask */
gdk_gc_set_clip_mask (color_area_gc, NULL);
}
static gboolean
draw_gap_image (GtkStyle *style,
GdkWindow *window,
GdkRectangle *area,
GtkWidget *widget,
ThemeMatchData *match_data,
gboolean draw_center,
gint x,
gint y,
gint width,
gint height,
GtkPositionType gap_side,
gint gap_x,
gint gap_width)
{
ThemeImage *image;
if ((width == -1) && (height == -1))
gdk_drawable_get_size (window, &width, &height);
else if (width == -1)
gdk_drawable_get_size (window, &width, NULL);
else if (height == -1)
gdk_drawable_get_size (window, NULL, &height);
if (!(match_data->flags & THEME_MATCH_ORIENTATION))
{
match_data->flags |= THEME_MATCH_ORIENTATION;
if (height > width)
match_data->orientation = GTK_ORIENTATION_VERTICAL;
else
match_data->orientation = GTK_ORIENTATION_HORIZONTAL;
}
match_data->flags |= THEME_MATCH_GAP_SIDE;
match_data->gap_side = gap_side;
image = match_theme_image (style, match_data);
if (image)
{
gint xthickness, ythickness;
GdkRectangle r1, r2, r3;
guint components = COMPONENT_ALL;
if (!draw_center)
components |= COMPONENT_CENTER;
if (!theme_pixbuf_get_geometry (image->gap_start, &xthickness, &ythickness))
{
xthickness = style->xthickness;
ythickness = style->ythickness;
}
switch (gap_side)
{
case GTK_POS_TOP:
if (!draw_center)
components |= COMPONENT_NORTH_WEST | COMPONENT_NORTH | COMPONENT_NORTH_EAST;
r1.x = x;
r1.y = y;
r1.width = gap_x;
r1.height = ythickness;
r2.x = x + gap_x;
r2.y = y;
r2.width = gap_width;
r2.height = ythickness;
r3.x = x + gap_x + gap_width;
r3.y = y;
r3.width = width - (gap_x + gap_width);
r3.height = ythickness;
break;
case GTK_POS_BOTTOM:
if (!draw_center)
components |= COMPONENT_SOUTH_WEST | COMPONENT_SOUTH | COMPONENT_SOUTH_EAST;
r1.x = x;
r1.y = y + height - ythickness;
r1.width = gap_x;
r1.height = ythickness;
r2.x = x + gap_x;
r2.y = y + height - ythickness;
r2.width = gap_width;
r2.height = ythickness;
r3.x = x + gap_x + gap_width;
r3.y = y + height - ythickness;
r3.width = width - (gap_x + gap_width);
r3.height = ythickness;
break;
case GTK_POS_LEFT:
if (!draw_center)
components |= COMPONENT_NORTH_WEST | COMPONENT_WEST | COMPONENT_SOUTH_WEST;
r1.x = x;
r1.y = y;
r1.width = xthickness;
r1.height = gap_x;
r2.x = x;
r2.y = y + gap_x;
r2.width = xthickness;
r2.height = gap_width;
r3.x = x;
r3.y = y + gap_x + gap_width;
r3.width = xthickness;
r3.height = height - (gap_x + gap_width);
break;
case GTK_POS_RIGHT:
if (!draw_center)
components |= COMPONENT_NORTH_EAST | COMPONENT_EAST | COMPONENT_SOUTH_EAST;
r1.x = x + width - xthickness;
r1.y = y;
r1.width = xthickness;
r1.height = gap_x;
r2.x = x + width - xthickness;
r2.y = y + gap_x;
r2.width = xthickness;
r2.height = gap_width;
r3.x = x + width - xthickness;
r3.y = y + gap_x + gap_width;
r3.width = xthickness;
r3.height = height - (gap_x + gap_width);
break;
default:
g_assert_not_reached ();
break;
}
if (image->background)
theme_pixbuf_render (image->background, G_OBJECT_TYPE (widget),
window, NULL, area, components, FALSE,
x, y, width, height);
if (image->gap_start)
theme_pixbuf_render (image->gap_start, G_OBJECT_TYPE (widget),
window, NULL, area, COMPONENT_ALL, FALSE,
r1.x, r1.y, r1.width, r1.height);
if (image->gap)
theme_pixbuf_render (image->gap, G_OBJECT_TYPE (widget),
window, NULL, area, COMPONENT_ALL, FALSE,
r2.x, r2.y, r2.width, r2.height);
if (image->gap_end)
theme_pixbuf_render (image->gap_end, G_OBJECT_TYPE (widget),
window, NULL, area, COMPONENT_ALL, FALSE,
r3.x, r3.y, r3.width, r3.height);
return TRUE;
}
else
return FALSE;
}
static void
locate_pointer_paint (GsdLocatePointerData *data,
cairo_t *cr,
gboolean composite)
{
GdkColor color;
gdouble progress, circle_progress;
gint width, height, i;
progress = data->progress;
gdk_drawable_get_size (data->window, &width, &height);
color = data->widget->style->bg[GTK_STATE_SELECTED];
cairo_set_source_rgba (cr, 1., 1., 1., 0.);
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
for (i = 0; i <= N_CIRCLES; i++)
{
if (progress < 0.)
break;
circle_progress = MIN (1., (progress * 2));
progress -= CIRCLES_PROGRESS_INTERVAL;
if (circle_progress >= 1.)
continue;
if (composite)
{
cairo_set_source_rgba (cr,
color.red / 65535.,
color.green / 65535.,
color.blue / 65535.,
1 - circle_progress);
cairo_arc (cr,
width / 2,
height / 2,
circle_progress * width / 2,
0, 2 * G_PI);
cairo_fill (cr);
cairo_stroke (cr);
}
else
{
cairo_set_source_rgb (cr, 0., 0., 0.);
cairo_set_line_width (cr, 3.);
cairo_arc (cr,
width / 2,
height / 2,
circle_progress * width / 2,
0, 2 * G_PI);
cairo_stroke (cr);
cairo_set_source_rgb (cr, 1., 1., 1.);
cairo_set_line_width (cr, 1.);
cairo_arc (cr,
width / 2,
height / 2,
circle_progress * width / 2,
0, 2 * G_PI);
cairo_stroke (cr);
}
}
}
gboolean
mc_show_history (GtkWidget *event_box,
GdkEventButton *event,
MCData *mc)
{
GtkWidget *window;
GtkWidget *scrolled_window;
GtkListStore *store;
GtkTreeIter iter;
GtkTreeModel *model;
GtkWidget *treeview;
GtkCellRenderer *cell_renderer;
GtkTreeViewColumn *column;
GtkRequisition req;
gchar *command_list[1];
int i, j;
gint win_x, win_y, width, height;
gint entry_h, entry_x, entry_y, applet_x, applet_y;
/* count commands stored in history list */
for(i = 0, j = 0; i < MC_HISTORY_LIST_LENGTH; i++)
if(exists_history_entry(i))
j++;
window = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_screen (GTK_WINDOW (window),
gtk_widget_get_screen (GTK_WIDGET (mc->applet)));
gtk_window_set_policy(GTK_WINDOW(window), 0, 0, 1);
gtk_widget_set_app_paintable (window, TRUE);
gtk_window_set_type_hint(GTK_WINDOW(window), GDK_WINDOW_TYPE_HINT_COMBO);
/* cb */
g_signal_connect_after(GTK_OBJECT(window),
"button_press_event",
GTK_SIGNAL_FUNC(history_popup_clicked_cb),
NULL);
g_signal_connect_after (G_OBJECT (window), "key_press_event",
G_CALLBACK (history_key_press_cb), NULL);
gdk_window_get_geometry (GTK_WIDGET (mc->applet_box)->window, NULL, NULL,
&width, &height, NULL);
gdk_window_get_origin (mc->applet_box->window, &applet_x, &applet_y);
gdk_window_get_position (mc->entry->window, &entry_x, &entry_y);
gdk_drawable_get_size (mc->entry->window, NULL, &entry_h);
win_x=applet_x + entry_x-1;
win_y=applet_y + entry_y;
/* size */
gtk_widget_set_usize(GTK_WIDGET(window), width-2*(entry_x-1), 350);
/* scrollbars */
/* create scrolled window to put the Gtk_list widget inside */
scrolled_window=gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_window),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
g_signal_connect(GTK_OBJECT(scrolled_window),
"button_release_event",
GTK_SIGNAL_FUNC(history_popup_clicked_inside_cb),
NULL);
gtk_container_add(GTK_CONTAINER(window), scrolled_window);
gtk_container_set_border_width (GTK_CONTAINER(scrolled_window), 1);
gtk_widget_show(scrolled_window);
store = gtk_list_store_new (1, G_TYPE_STRING);
/* add history entries to list */
if (j == 0) {
gtk_list_store_append (store, &iter);
gtk_list_store_set (store, &iter,0, _("No items in history"), -1);
}
else {
for(i = 0; i < MC_HISTORY_LIST_LENGTH; i++)
{
if(exists_history_entry(i))
{
command_list[0] = get_history_entry(i);
gtk_list_store_prepend (store, &iter);
gtk_list_store_set (store, &iter,0,command_list[0],-1);
}
}
}
model = GTK_TREE_MODEL(store);
treeview = gtk_tree_view_new_with_model (model);
g_object_set_data (G_OBJECT (mc->applet), "tree", treeview);
cell_renderer = gtk_cell_renderer_text_new ();
column = gtk_tree_view_column_new_with_attributes (NULL, cell_renderer,
"text", 0, NULL);
gtk_tree_view_append_column (GTK_TREE_VIEW (treeview), column);
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (treeview), FALSE);
if (j == 0) {
gtk_tree_selection_set_mode( (GtkTreeSelection *)gtk_tree_view_get_selection
(GTK_TREE_VIEW (treeview)),
GTK_SELECTION_NONE);
}
else {
gtk_tree_selection_set_mode( (GtkTreeSelection *)gtk_tree_view_get_selection
(GTK_TREE_VIEW (treeview)),
GTK_SELECTION_SINGLE);
g_signal_connect (G_OBJECT (treeview), "button_press_event",
G_CALLBACK (history_list_button_press_cb), mc);
g_signal_connect (G_OBJECT (treeview), "key_press_event",
G_CALLBACK (history_list_key_press_cb), mc);
}
g_object_unref (G_OBJECT (model));
gtk_container_add(GTK_CONTAINER(scrolled_window),treeview);
gtk_widget_show (treeview);
gtk_widget_size_request (window, &req);
switch (panel_applet_get_orient (mc->applet)) {
case PANEL_APPLET_ORIENT_RIGHT:
case PANEL_APPLET_ORIENT_LEFT:
case PANEL_APPLET_ORIENT_DOWN:
win_y += (entry_h+BORDER-1);
break;
case PANEL_APPLET_ORIENT_UP:
win_y -= (req.height+BORDER-1);
break;
}
gtk_window_move (GTK_WINDOW (window), win_x, win_y);
g_signal_connect ((gpointer) window, "expose_event",
G_CALLBACK (history_window_expose_event),
NULL);
gtk_widget_show(window);
/* grab focus */
gdk_pointer_grab (window->window,
TRUE,
GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_ENTER_NOTIFY_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_POINTER_MOTION_MASK,
NULL,
NULL,
GDK_CURRENT_TIME);
gdk_keyboard_grab (window->window, TRUE, GDK_CURRENT_TIME);
gtk_grab_add(window);
gtk_widget_grab_focus (treeview);
return FALSE;
}
static void
on_calendar_realized(GtkWidget *widget, gpointer data)
{
gint parent_x, parent_y, parent_w, parent_h;
gint root_w, root_h;
gint width, height, x, y;
gint orientation;
GdkScreen *screen;
GtkWidget *parent;
GtkRequisition requisition;
orientation = GPOINTER_TO_INT(data);
parent = g_object_get_data(G_OBJECT(widget), "calendar-parent");
gdk_window_get_origin(GDK_WINDOW(parent->window), &parent_x, &parent_y);
gdk_drawable_get_size(GDK_DRAWABLE(parent->window), &parent_w, &parent_h);
screen = gdk_drawable_get_screen(GDK_DRAWABLE(widget->window));
root_w = gdk_screen_get_width(GDK_SCREEN(screen));
root_h = gdk_screen_get_height(GDK_SCREEN(screen));
gtk_widget_size_request(GTK_WIDGET(widget), &requisition);
width = requisition.width;
height = requisition.height;
/*
g_print("parent: %dx%d +%d+%d\n", parent_w, parent_h, parent_x, parent_y);
g_print("root: %dx%d\n", root_w, root_h);
g_print("calendar: %dx%d\n", width, height);
*/
if (orientation == GTK_ORIENTATION_VERTICAL) {
if (parent_x < root_w / 2) {
if (parent_y < root_h / 2) {
/* upper left */
x = parent_x + parent_w;
y = parent_y;
} else {
/* lower left */
x = parent_x + parent_w;
y = parent_y + parent_h - height;
}
} else {
if (parent_y < root_h / 2) {
/* upper right */
x = parent_x - width;
y = parent_y;
} else {
/* lower right */
x = parent_x - width;
y = parent_y + parent_h - height;
}
}
} else {
if (parent_x < root_w / 2) {
if (parent_y < root_h / 2) {
/* upper left */
x = parent_x;
y = parent_y + parent_h;
} else {
/* lower left */
x = parent_x;
y = parent_y - height;
}
} else {
if (parent_y < root_h / 2) {
/* upper right */
x = parent_x + parent_w - width;
y = parent_y + parent_h;
} else {
/* lower right */
x = parent_x + parent_w - width;
y = parent_y - height;
}
}
}
gtk_window_move(GTK_WINDOW(widget), x, y);
}
static PyObject *
PyGdkWindow_GetAttr(PyGdkWindow_Object *self, char *key)
{
GdkWindow *win = PyGdkWindow_Get(self);
gint x, y;
GdkModifierType p_mask;
if (!strcmp(key, "__members__"))
return Py_BuildValue("[sssssssssssss]", "children", "colormap", "depth",
"height", "parent", "pointer", "pointer_state",
"toplevel", "type", "width", "x", "xid", "y");
if (!strcmp(key, "width")) {
gdk_drawable_get_size(win, &x, NULL);
return PyInt_FromLong(x);
}
if (!strcmp(key, "height")) {
gdk_drawable_get_size(win, NULL, &y);
return PyInt_FromLong(y);
}
if (!strcmp(key, "x")) {
gdk_window_get_position(win, &x, NULL);
return PyInt_FromLong(x);
}
if (!strcmp(key, "y")) {
gdk_window_get_position(win, NULL, &y);
return PyInt_FromLong(y);
}
if (!strcmp(key, "colormap"))
return PyGdkColormap_New(gdk_drawable_get_colormap(win));
if (!strcmp(key, "pointer")) {
gdk_window_get_pointer(win, &x, &y, NULL);
return Py_BuildValue("(ii)", x, y);
}
if (!strcmp(key, "pointer_state")) {
gdk_window_get_pointer(win, NULL, NULL, &p_mask);
return PyInt_FromLong(p_mask);
}
if (!strcmp(key, "parent")) {
GdkWindow *par = gdk_window_get_parent(win);
if (par)
return PyGdkWindow_New(par);
Py_INCREF(Py_None);
return Py_None;
}
if (!strcmp(key, "toplevel"))
return PyGdkWindow_New(gdk_window_get_toplevel(win));
if (!strcmp(key, "children")) {
GList *children, *tmp;
PyObject *ret;
children = gdk_window_get_children(win);
if ((ret = PyList_New(0)) == NULL)
return NULL;
for (tmp = children; tmp != NULL; tmp = tmp->next) {
PyObject *win = PyGdkWindow_New(tmp->data);
if (win == NULL) {
Py_DECREF(ret);
return NULL;
}
PyList_Append(ret, win);
Py_DECREF(win);
}
g_list_free(children);
return ret;
}
if (!strcmp(key, "type"))
return PyInt_FromLong(gdk_drawable_get_type(win));
if (!strcmp(key, "depth")) {
gdk_window_get_geometry(win, NULL, NULL, NULL, NULL, &x);
return PyInt_FromLong(x);
}
#ifdef WITH_XSTUFF
if (!strcmp(key, "xid"))
return PyInt_FromLong(GDK_WINDOW_XWINDOW(win));
#endif
return Py_FindMethod(PyGdkWindow_methods, (PyObject *)self, key);
}
void WAttGtk::change_value_close()
{
unsigned char *s;
int sts;
if ( input_open) {
if ( input_multiline) {
gchar *text, *textutf8;
GtkTextIter start_iter, end_iter;
gtk_text_buffer_get_start_iter( cmd_scrolled_buffer, &start_iter);
gtk_text_buffer_get_end_iter( cmd_scrolled_buffer, &end_iter);
textutf8 = gtk_text_buffer_get_text( cmd_scrolled_buffer, &start_iter, &end_iter,
FALSE);
text = g_convert( textutf8, -1, "ISO8859-1", "UTF-8", NULL, NULL, NULL);
g_free( textutf8);
// Replace ctrl characters with space
for ( s = (unsigned char *) text; *s; s++) {
if ( *s < ' ' && *s != 10 && *s != 13)
*s = ' ';
}
sts = wattnav->set_attr_value( input_node,
input_name, text);
g_free( text);
g_object_set( cmd_scrolledinput, "visible", FALSE, NULL);
set_prompt( "");
input_open = 0;
int w, h;
gdk_drawable_get_size( pane->window, &w, &h);
gtk_paned_set_position( GTK_PANED(pane), h - 50);
wattnav->redraw();
wattnav->set_inputfocus();
}
else {
char *text, *textutf8;
textutf8 = gtk_editable_get_chars( GTK_EDITABLE(cmd_input), 0, -1);
text = g_convert( textutf8, -1, "ISO8859-1", "UTF-8", NULL, NULL, NULL);
g_free( textutf8);
sts = wattnav->set_attr_value( input_node,
input_name, text);
g_free( text);
g_object_set( cmd_input, "visible", FALSE, NULL);
set_prompt( "");
input_open = 0;
if ( redraw_cb)
(redraw_cb)( this);
wattnav->set_inputfocus();
}
if ( pending_close) {
if ( close_cb)
(close_cb)( this);
else
delete this;
}
}
}
XAttGtk::XAttGtk(GtkWidget* xa_parent_wid, void* xa_parent_ctx,
pwr_sAttrRef* xa_objar, int xa_advanced_user, int* xa_sts)
: XAtt(xa_parent_ctx, xa_objar, xa_advanced_user, xa_sts),
parent_wid(xa_parent_wid)
{
int sts;
pwr_tAName title;
*xa_sts = gdh_AttrrefToName(&objar, title, sizeof(title), cdh_mNName);
if (EVEN(*xa_sts))
return;
str_StrncpyCutOff(title, title, 100, 1);
toplevel = (GtkWidget*)g_object_new(GTK_TYPE_WINDOW, "default-height", 600,
"default-width", 420, "title", CoWowGtk::convert_utf8(title), NULL);
g_signal_connect(toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect(toplevel, "destroy", G_CALLBACK(destroy_event), this);
g_signal_connect(
toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this);
CoWowGtk::SetWindowIcon(toplevel);
GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
// Menu
// Accelerators
GtkAccelGroup* accel_g
= (GtkAccelGroup*)g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);
GtkMenuBar* menu_bar = (GtkMenuBar*)g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File entry
GtkWidget* file_print = gtk_image_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Print"));
g_signal_connect(file_print, "activate", G_CALLBACK(activate_print), this);
GtkWidget* file_close = gtk_image_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Close"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(file_close),
gtk_image_new_from_stock("gtk-close", GTK_ICON_SIZE_MENU));
g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this);
gtk_widget_add_accelerator(file_close, "activate", accel_g, 'w',
GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
GtkMenu* file_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget* file
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_File"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Functions entry
GtkWidget* func_changevalue = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Change _Value"));
g_signal_connect(
func_changevalue, "activate", G_CALLBACK(activate_change_value), this);
gtk_widget_add_accelerator(func_changevalue, "activate", accel_g, 'q',
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget* func_close_changeval = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("C_lose Change Value"));
g_signal_connect(func_close_changeval, "activate",
G_CALLBACK(activate_close_changeval), this);
gtk_widget_add_accelerator(func_close_changeval, "activate", accel_g, 't',
GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget* functions_open_plc = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Open _Program"));
g_signal_connect(
functions_open_plc, "activate", G_CALLBACK(activate_open_plc), this);
gtk_widget_add_accelerator(functions_open_plc, "activate", accel_g, 'l',
GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
GtkWidget* functions_display_object = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Display object in Navigator"));
g_signal_connect(functions_display_object, "activate",
G_CALLBACK(activate_display_object), this);
gtk_widget_add_accelerator(functions_display_object, "activate", accel_g, 'd',
GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
GtkWidget* functions_show_cross = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Show C_rossreferences"));
g_signal_connect(
functions_show_cross, "activate", G_CALLBACK(activate_show_cross), this);
gtk_widget_add_accelerator(functions_show_cross, "activate", accel_g, 'r',
GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
GtkWidget* functions_open_classgraph = gtk_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("Open _ClassGraph"));
g_signal_connect(functions_open_classgraph, "activate",
G_CALLBACK(activate_open_classgraph), this);
gtk_widget_add_accelerator(functions_open_classgraph, "activate", accel_g,
'g', GdkModifierType(GDK_CONTROL_MASK), GTK_ACCEL_VISIBLE);
GtkMenu* func_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), func_changevalue);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), func_close_changeval);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_open_plc);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_display_object);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_show_cross);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), functions_open_classgraph);
GtkWidget* functions
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Functions"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(func_menu));
// Help entry
GtkWidget* help_help = gtk_image_menu_item_new_with_mnemonic(
CoWowGtk::translate_utf8("_Help"));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(help_help),
gtk_image_new_from_stock("gtk-help", GTK_ICON_SIZE_MENU));
g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
gtk_widget_add_accelerator(
help_help, "activate", accel_g, 'h', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkMenu* help_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
GtkWidget* help
= gtk_menu_item_new_with_mnemonic(CoWowGtk::translate_utf8("_Help"));
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
pane = gtk_vpaned_new();
xattnav = new XAttNavGtk((void*)this, pane, xattnav_eType_Object, "Plant",
&objar, xa_advanced_user, 0, &brow_widget, &sts);
xattnav->message_cb = &message_cb;
xattnav->change_value_cb = &change_value_cb;
xattnav->popup_menu_cb = &xatt_popup_menu_cb;
xattnav->is_authorized_cb = &xatt_is_authorized_cb;
xattnav->init_cb = &init_cb;
GtkWidget* statusbar = gtk_hbox_new(FALSE, 0);
msg_label = gtk_label_new("");
gtk_widget_set_size_request(msg_label, -1, 25);
cmd_prompt = gtk_label_new("value > ");
gtk_widget_set_size_request(cmd_prompt, -1, 25);
cmd_entry = new CoWowEntryGtk(&value_recall);
cmd_input = cmd_entry->widget();
gtk_widget_set_size_request(cmd_input, -1, 25);
g_signal_connect(cmd_input, "activate", G_CALLBACK(activate_cmd_input), this);
gtk_box_pack_start(GTK_BOX(statusbar), msg_label, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(statusbar), cmd_prompt, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(statusbar), cmd_input, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox), GTK_WIDGET(pane), TRUE, TRUE, 0);
gtk_paned_pack1(GTK_PANED(pane), GTK_WIDGET(brow_widget), TRUE, TRUE);
gtk_paned_pack2(GTK_PANED(pane), GTK_WIDGET(statusbar), FALSE, TRUE);
gtk_container_add(GTK_CONTAINER(toplevel), vbox);
cmd_scrolled_buffer = gtk_text_buffer_new(NULL);
g_signal_connect_after(cmd_scrolled_buffer, "insert-text",
G_CALLBACK(action_text_inserted), this);
cmd_scrolledtextview = gtk_text_view_new_with_buffer(cmd_scrolled_buffer);
GtkWidget* viewport = gtk_viewport_new(NULL, NULL);
GtkWidget* scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(viewport), cmd_scrolledtextview);
gtk_container_add(GTK_CONTAINER(scrolledwindow), viewport);
cmd_scrolled_ok = gtk_button_new_with_label("Ok");
gtk_widget_set_size_request(cmd_scrolled_ok, 70, 25);
g_signal_connect(
cmd_scrolled_ok, "clicked", G_CALLBACK(activate_cmd_scrolled_ok), this);
cmd_scrolled_ca = gtk_button_new_with_label("Cancel");
gtk_widget_set_size_request(cmd_scrolled_ca, 70, 25);
g_signal_connect(
cmd_scrolled_ca, "clicked", G_CALLBACK(activate_cmd_scrolled_ca), this);
GtkWidget* hboxbuttons = gtk_hbox_new(TRUE, 40);
gtk_box_pack_start(GTK_BOX(hboxbuttons), cmd_scrolled_ok, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hboxbuttons), cmd_scrolled_ca, FALSE, FALSE, 0);
cmd_scrolledinput = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(cmd_scrolledinput), scrolledwindow, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(cmd_scrolledinput), hboxbuttons, FALSE, FALSE, 5);
gtk_box_pack_start(GTK_BOX(statusbar), cmd_scrolledinput, TRUE, TRUE, 0);
gtk_widget_show_all(toplevel);
g_object_set(cmd_prompt, "visible", FALSE, NULL);
g_object_set(cmd_input, "visible", FALSE, NULL);
g_object_set(cmd_scrolledinput, "visible", FALSE, NULL);
int w, h;
gdk_drawable_get_size(pane->window, &w, &h);
gtk_paned_set_position(GTK_PANED(pane), h - 50);
*xa_sts = XATT__SUCCESS;
}
WAttGtk::WAttGtk(
GtkWidget *wa_parent_wid,
void *wa_parent_ctx,
ldh_tSesContext wa_ldhses,
pwr_sAttrRef wa_aref,
int wa_editmode,
int wa_advanced_user,
int wa_display_objectname) :
WAtt(wa_parent_ctx,wa_ldhses,wa_aref,wa_editmode,wa_advanced_user,
wa_display_objectname), parent_wid(wa_parent_wid)
{
int sts;
int size;
char *namep;
sts = ldh_AttrRefToName( ldhses, &aref, ldh_eName_Hierarchy,
&namep, &size);
if ( EVEN(sts)) return;
toplevel = (GtkWidget *) g_object_new( GTK_TYPE_WINDOW,
"default-height", 570,
"default-width", 410,
"title", CoWowGtk::convert_utf8(namep),
NULL);
g_signal_connect( toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect( toplevel, "destroy", G_CALLBACK(destroy_event), this);
g_signal_connect( toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this);
CoWowGtk::SetWindowIcon( toplevel);
GtkWidget *vbox = gtk_vbox_new( FALSE, 0);
// Menu
// Accelerators
GtkAccelGroup *accel_g = (GtkAccelGroup *) g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);
GtkMenuBar *menu_bar = (GtkMenuBar *) g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File entry
GtkWidget *file_close = gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this);
GtkWidget *file_print = gtk_image_menu_item_new_from_stock(GTK_STOCK_PRINT, accel_g);
g_signal_connect(file_print, "activate", G_CALLBACK(activate_print), this);
GtkMenu *file_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_print);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget *file = gtk_menu_item_new_with_mnemonic("_File");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Functions entry
GtkWidget *func_changevalue = gtk_menu_item_new_with_mnemonic( "_Change Value");
g_signal_connect( func_changevalue, "activate",
G_CALLBACK(activate_change_value), this);
gtk_widget_add_accelerator( func_changevalue, "activate", accel_g,
'q', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkWidget *func_close_changeval = gtk_menu_item_new_with_mnemonic( "C_lose Change Value");
g_signal_connect( func_close_changeval, "activate",
G_CALLBACK(activate_close_changeval), this);
gtk_widget_add_accelerator( func_close_changeval, "activate", accel_g,
't', GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
GtkMenu *func_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), func_changevalue);
gtk_menu_shell_append(GTK_MENU_SHELL(func_menu), func_close_changeval);
GtkWidget *functions = gtk_menu_item_new_with_mnemonic("_Functions");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), functions);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(functions), GTK_WIDGET(func_menu));
// Help entry
GtkWidget *help_help = gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g);
g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
GtkMenu *help_menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
GtkWidget *help = gtk_menu_item_new_with_mnemonic("_Help");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
pane = gtk_vpaned_new();
if ( ((WUtility *)parent_ctx)->utype == wb_eUtility_WNav)
parent_ctx = ((WNav *)parent_ctx)->parent_ctx;
utility = ((WUtility *)parent_ctx)->utype;
wattnav = new WAttNavGtk( (void *)this, wattnav_eType_Object, pane, "Plant",
ldhses, aref, wa_editmode, wa_advanced_user,
wa_display_objectname, utility, &brow_widget, &sts);
((WAttNav *)wattnav)->message_cb = &WAtt::message_cb;
((WAttNav *)wattnav)->change_value_cb = &WAtt::change_value_cb;
GtkWidget *statusbar = gtk_hbox_new( FALSE, 0);
msg_label = gtk_label_new( "");
gtk_widget_set_size_request( msg_label, -1, 25);
cmd_prompt = gtk_label_new( "value > ");
gtk_widget_set_size_request( cmd_prompt, -1, 25);
cmd_entry = new CoWowEntryGtk( &value_recall);
cmd_entry->set_hide_on_esc(true);
cmd_input = cmd_entry->widget();
gtk_widget_set_size_request( cmd_input, -1, 25);
g_signal_connect( cmd_input, "activate",
G_CALLBACK(activate_cmd_input), this);
g_signal_connect( cmd_input, "hide",
G_CALLBACK(hide_cmd_input), this);
gtk_box_pack_start( GTK_BOX(statusbar), msg_label, FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(statusbar), cmd_prompt, FALSE, FALSE, 0);
gtk_box_pack_start( GTK_BOX(statusbar), cmd_input, TRUE, TRUE, 0);
gtk_box_pack_start( GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_end( GTK_BOX(vbox), GTK_WIDGET(pane), TRUE, TRUE, 0);
gtk_paned_pack1( GTK_PANED(pane), GTK_WIDGET(brow_widget), TRUE, TRUE);
gtk_paned_pack2( GTK_PANED(pane), GTK_WIDGET(statusbar), FALSE, TRUE);
gtk_container_add( GTK_CONTAINER(toplevel), vbox);
cmd_scrolled_buffer = gtk_text_buffer_new( NULL);
g_signal_connect_after( cmd_scrolled_buffer, "insert-text",
G_CALLBACK(action_text_inserted), this);
cmd_scrolledtextview = gtk_text_view_new_with_buffer( cmd_scrolled_buffer);
GtkWidget *viewport = gtk_viewport_new( NULL, NULL);
GtkWidget *scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add( GTK_CONTAINER(viewport), cmd_scrolledtextview);
gtk_container_add( GTK_CONTAINER(scrolledwindow), viewport);
cmd_scrolled_ok = gtk_button_new_with_label( "Ok");
gtk_widget_set_size_request( cmd_scrolled_ok, 70, 25);
g_signal_connect( cmd_scrolled_ok, "clicked",
G_CALLBACK(activate_cmd_scrolled_ok), this);
cmd_scrolled_ca = gtk_button_new_with_label( "Cancel");
gtk_widget_set_size_request( cmd_scrolled_ca, 70, 25);
g_signal_connect( cmd_scrolled_ca, "clicked",
G_CALLBACK(activate_cmd_scrolled_ca), this);
GtkWidget *hboxbuttons = gtk_hbox_new( TRUE, 40);
gtk_box_pack_start( GTK_BOX(hboxbuttons), cmd_scrolled_ok, FALSE, FALSE, 0);
gtk_box_pack_end( GTK_BOX(hboxbuttons), cmd_scrolled_ca, FALSE, FALSE, 0);
cmd_scrolledinput = gtk_vbox_new( FALSE, 0);
gtk_box_pack_start( GTK_BOX(cmd_scrolledinput), scrolledwindow, TRUE, TRUE, 0);
gtk_box_pack_start( GTK_BOX(cmd_scrolledinput), hboxbuttons, FALSE, FALSE, 5);
gtk_box_pack_start( GTK_BOX(statusbar), cmd_scrolledinput, TRUE, TRUE, 0);
gtk_widget_show_all( toplevel);
g_object_set( cmd_prompt, "visible", FALSE, NULL);
g_object_set( cmd_input, "visible", FALSE, NULL);
g_object_set( cmd_scrolledinput, "visible", FALSE, NULL);
int w, h;
gdk_drawable_get_size( pane->window, &w, &h);
gtk_paned_set_position( GTK_PANED(pane), h - 50);
if ( utility == wb_eUtility_Wtt) {
((Wtt *)parent_ctx)->register_utility( (void *) this,
wb_eUtility_AttributeEditor);
}
}
static void
render (GtkWidget * widget)
{
GSMColorButton *color_button = GSM_COLOR_BUTTON (widget);
GdkColor *color, tmp_color = color_button->priv->color;
color = &tmp_color;
cairo_t *cr = gdk_cairo_create (gtk_widget_get_window (widget));
cairo_path_t *path = NULL;
gint width, height;
gdouble radius, arc_start, arc_end;
gint highlight_factor;
if (color_button->priv->highlight > 0) {
highlight_factor = 8192 * color_button->priv->highlight;
if (color->red + highlight_factor > 65535)
color->red = 65535;
else
color->red = color->red + highlight_factor;
if (color->blue + highlight_factor > 65535)
color->blue = 65535;
else
color->blue = color->blue + highlight_factor;
if (color->green + highlight_factor > 65535)
color->green = 65535;
else
color->green = color->green + highlight_factor;
}
gdk_cairo_set_source_color (cr, color);
gdk_drawable_get_size (gtk_widget_get_window (widget), &width, &height);
switch (color_button->priv->type)
{
case GSMCP_TYPE_CPU:
//gtk_widget_set_size_request (widget, GSMCP_MIN_WIDTH, GSMCP_MIN_HEIGHT);
cairo_paint (cr);
cairo_set_line_width (cr, 1);
cairo_set_source_rgba (cr, 0, 0, 0, 0.5);
cairo_rectangle (cr, 0.5, 0.5, width - 1, height - 1);
cairo_stroke (cr);
cairo_set_line_width (cr, 1);
cairo_set_source_rgba (cr, 1, 1, 1, 0.4);
cairo_rectangle (cr, 1.5, 1.5, width - 3, height - 3);
cairo_stroke (cr);
break;
case GSMCP_TYPE_PIE:
if (width < 32) // 32px minimum size
gtk_widget_set_size_request (widget, 32, 32);
if (width < height)
radius = width / 2;
else
radius = height / 2;
arc_start = -G_PI_2 + 2 * G_PI * color_button->priv->fraction;
arc_end = -G_PI_2;
cairo_set_line_width (cr, 1);
// Draw external stroke and fill
if (color_button->priv->fraction < 0.01) {
cairo_arc (cr, (width / 2) + .5, (height / 2) + .5, 4.5,
0, 2 * G_PI);
} else if (color_button->priv->fraction > 0.99) {
cairo_arc (cr, (width / 2) + .5, (height / 2) + .5, radius - 2.25,
0, 2 * G_PI);
} else {
cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, radius - 2.25,
arc_start, arc_end);
cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, 4.5,
arc_end, arc_start);
cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, radius - 2.25,
arc_start, arc_start);
}
cairo_fill_preserve (cr);
cairo_set_source_rgba (cr, 0, 0, 0, 0.7);
cairo_stroke (cr);
// Draw internal highlight
cairo_set_source_rgba (cr, 1, 1, 1, 0.45);
cairo_set_line_width (cr, 1);
if (color_button->priv->fraction < 0.03) {
cairo_arc (cr, (width / 2) + .5, (height / 2) + .5, 3.25,
0, 2 * G_PI);
} else if (color_button->priv->fraction > 0.99) {
cairo_arc (cr, (width / 2) + .5, (height / 2) + .5, radius - 3.5,
0, 2 * G_PI);
} else {
cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, radius - 3.5,
arc_start + (1 / (radius - 3.75)),
arc_end - (1 / (radius - 3.75)));
cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, 3.25,
arc_end - (1 / (radius - 3.75)),
arc_start + (1 / (radius - 3.75)));
cairo_arc_negative (cr, (width / 2) + .5, (height / 2) + .5, radius - 3.5,
arc_start + (1 / (radius - 3.75)),
arc_start + (1 / (radius - 3.75)));
}
cairo_stroke (cr);
// Draw external shape
cairo_set_line_width (cr, 1);
cairo_set_source_rgba (cr, 0, 0, 0, 0.2);
cairo_arc (cr, (width / 2) + .5, (height / 2) + .5, radius - 1.25, 0,
G_PI * 2);
cairo_stroke (cr);
break;
case GSMCP_TYPE_NETWORK_IN:
if (color_button->priv->image_buffer == NULL)
color_button->priv->image_buffer =
fill_image_buffer_from_file (cr, DATADIR "/pixmaps/gnome-system-monitor/download.svg");
gtk_widget_set_size_request (widget, 32, 32);
cairo_move_to (cr, 8.5, 1.5);
cairo_line_to (cr, 23.5, 1.5);
cairo_line_to (cr, 23.5, 11.5);
cairo_line_to (cr, 29.5, 11.5);
cairo_line_to (cr, 16.5, 27.5);
cairo_line_to (cr, 15.5, 27.5);
cairo_line_to (cr, 2.5, 11.5);
cairo_line_to (cr, 8.5, 11.5);
cairo_line_to (cr, 8.5, 1.5);
cairo_close_path (cr);
path = cairo_copy_path (cr);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
cairo_set_line_width (cr, 1);
cairo_fill_preserve (cr);
cairo_set_miter_limit (cr, 5.0);
cairo_stroke (cr);
cairo_set_source_rgba (cr, 0, 0, 0, 0.5);
cairo_append_path (cr, path);
cairo_path_destroy(path);
cairo_stroke (cr);
cairo_set_source_surface (cr, color_button->priv->image_buffer, 0.0,
0.0);
cairo_paint (cr);
break;
case GSMCP_TYPE_NETWORK_OUT:
if (color_button->priv->image_buffer == NULL)
color_button->priv->image_buffer =
fill_image_buffer_from_file (cr, DATADIR "/pixmaps/gnome-system-monitor/upload.svg");
gtk_widget_set_size_request (widget, 32, 32);
cairo_move_to (cr, 16.5, 1.5);
cairo_line_to (cr, 29.5, 17.5);
cairo_line_to (cr, 23.5, 17.5);
cairo_line_to (cr, 23.5, 27.5);
cairo_line_to (cr, 8.5, 27.5);
cairo_line_to (cr, 8.5, 17.5);
cairo_line_to (cr, 2.5, 17.5);
cairo_line_to (cr, 15.5, 1.5);
cairo_line_to (cr, 16.5, 1.5);
cairo_close_path (cr);
path = cairo_copy_path (cr);
cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);
cairo_set_line_join (cr, CAIRO_LINE_JOIN_MITER);
cairo_set_line_width (cr, 1);
cairo_fill_preserve (cr);
cairo_set_miter_limit (cr, 5.0);
cairo_stroke (cr);
cairo_set_source_rgba (cr, 0, 0, 0, 0.5);
cairo_append_path (cr, path);
cairo_path_destroy(path);
cairo_stroke (cr);
cairo_set_source_surface (cr, color_button->priv->image_buffer, 0.0,
0.0);
cairo_paint (cr);
break;
}
cairo_destroy (cr);
}
guint16 widget_height(GtkWidget *w)
{
gint x, y;
gdk_drawable_get_size(w->window, &x, &y);
return(y);
}
/****************************************************************************
Return the dimensions of the area (container widget; maximum size) for
the overview.
****************************************************************************/
void get_overview_area_dimensions(int *width, int *height)
{
gdk_drawable_get_size(overview_canvas->window, width, height);
}
guint16 widget_width(GtkWidget *w)
{
gint x, y;
gdk_drawable_get_size(w->window, &x, &y);
return(x);
}