static void setup_scale(CtkImageSliders *ctk_image_sliders,
int attribute,
GtkWidget *scale)
{
ReturnStatus ret0, ret1;
NVCTRLAttributeValidValuesRec valid;
NvCtrlAttributeHandle *handle = ctk_image_sliders->handle;
int val;
GtkAdjustment *adj = CTK_SCALE(scale)->gtk_adjustment;
/* Read settings from X server */
ret0 = NvCtrlGetValidAttributeValues(handle, attribute, &valid);
ret1 = NvCtrlGetAttribute(handle, attribute, &val);
if ((ret0 == NvCtrlSuccess) && (ret1 == NvCtrlSuccess) &&
(valid.type == ATTRIBUTE_TYPE_RANGE)) {
g_signal_handlers_block_by_func(adj, scale_value_changed,
ctk_image_sliders);
adj->lower = valid.u.range.min;
adj->upper = valid.u.range.max;
gtk_adjustment_changed(GTK_ADJUSTMENT(adj));
gtk_adjustment_set_value(GTK_ADJUSTMENT(adj), val);
g_signal_handlers_unblock_by_func(adj, scale_value_changed,
ctk_image_sliders);
gtk_widget_set_sensitive(scale, TRUE);
} else {
gtk_widget_set_sensitive(scale, FALSE);
}
} /* setup_scale() */
static void setup_scale(CtkImageSliders *ctk_image_sliders,
int attribute,
GtkWidget *scale)
{
CtrlTarget *ctrl_target = ctk_image_sliders->ctrl_target;
ReturnStatus ret0, ret1;
CtrlAttributeValidValues valid;
int val;
GtkAdjustment *adj = CTK_SCALE(scale)->gtk_adjustment;
/* Read settings from X server */
ret0 = NvCtrlGetValidAttributeValues(ctrl_target, attribute, &valid);
ret1 = NvCtrlGetAttribute(ctrl_target, attribute, &val);
if ((ret0 == NvCtrlSuccess) && (ret1 == NvCtrlSuccess) &&
(valid.valid_type == CTRL_ATTRIBUTE_VALID_TYPE_RANGE)) {
g_signal_handlers_block_by_func(adj, scale_value_changed,
ctk_image_sliders);
ctk_adjustment_set_lower(adj, valid.range.min);
ctk_adjustment_set_upper(adj, valid.range.max);
gtk_adjustment_changed(GTK_ADJUSTMENT(adj));
gtk_adjustment_set_value(GTK_ADJUSTMENT(adj), val);
g_signal_handlers_unblock_by_func(adj, scale_value_changed,
ctk_image_sliders);
gtk_widget_set_sensitive(scale, TRUE);
} else {
gtk_widget_set_sensitive(scale, FALSE);
}
} /* setup_scale() */
static int gtkCanvasSetDYAttrib(Ihandle* ih, const char *value)
{
if (ih->data->sb & IUP_SB_VERT)
{
double ymin, ymax, liney;
float dy;
int value_changed;
GtkAdjustment* sb_vert_adjust;
GtkWidget* sb_vert = (GtkWidget*)iupAttribGet(ih, "_IUPGTK_SBVERT");
if (!sb_vert) return 1;
if (!iupStrToFloat(value, &dy))
return 1;
ymin = iupAttribGetFloat(ih, "YMIN");
ymax = iupAttribGetFloat(ih, "YMAX");
if (!iupAttribGet(ih,"LINEY"))
{
liney = dy/10;
if (liney==0)
liney = 1;
}
else
liney = iupAttribGetFloat(ih,"LINEY");
sb_vert_adjust = gtk_range_get_adjustment(GTK_RANGE(sb_vert));
if (dy >= (ymax-ymin))
{
if (iupAttribGetBoolean(ih, "YAUTOHIDE"))
{
if (iupgtkIsVisible(sb_vert))
{
gtk_widget_hide(sb_vert);
gtkCanvasUpdateChildLayout(ih);
}
}
else
gtk_widget_set_sensitive(sb_vert, FALSE);
ih->data->posy = (float)ymin;
gtkCanvasAdjustmentSetValue(ih, sb_vert_adjust, ymin);
return 1;
}
else
{
if (!iupgtkIsVisible(sb_vert))
{
gtk_widget_show(sb_vert);
gtkCanvasUpdateChildLayout(ih);
}
gtk_widget_set_sensitive(sb_vert, TRUE);
}
#if GTK_CHECK_VERSION(2, 14, 0)
{
double page_size = dy;
double dvalue = gtk_adjustment_get_value(sb_vert_adjust);
value_changed = gtkCanvasCheckScroll(ymin, ymax, &page_size, &dvalue);
gtk_adjustment_configure(sb_vert_adjust, dvalue, ymin, ymax, liney, page_size, dy);
}
#else
{
sb_vert_adjust->lower = ymin;
sb_vert_adjust->upper = ymax;
sb_vert_adjust->step_increment = liney;
sb_vert_adjust->page_size = dy;
value_changed = gtkCanvasCheckScroll(ymin, ymax, &sb_vert_adjust->page_size, &sb_vert_adjust->value);
sb_vert_adjust->page_increment = sb_vert_adjust->page_size;
gtk_adjustment_changed(sb_vert_adjust);
}
#endif
if (value_changed)
gtk_adjustment_value_changed(sb_vert_adjust);
}
return 1;
}
static int gtkCanvasSetDXAttrib(Ihandle* ih, const char *value)
{
if (ih->data->sb & IUP_SB_HORIZ)
{
double xmin, xmax, linex;
float dx;
int value_changed;
GtkAdjustment* sb_horiz_adjust;
GtkWidget* sb_horiz = (GtkWidget*)iupAttribGet(ih, "_IUPGTK_SBHORIZ");
if (!sb_horiz) return 1;
if (!iupStrToFloat(value, &dx))
return 1;
xmin = iupAttribGetFloat(ih, "XMIN");
xmax = iupAttribGetFloat(ih, "XMAX");
if (!iupAttribGet(ih,"LINEX"))
{
linex = dx/10;
if (linex==0)
linex = 1;
}
else
linex = iupAttribGetFloat(ih,"LINEX");
sb_horiz_adjust = gtk_range_get_adjustment(GTK_RANGE(sb_horiz));
if (dx >= (xmax-xmin))
{
if (iupAttribGetBoolean(ih, "XAUTOHIDE"))
{
if (iupgtkIsVisible(sb_horiz))
{
gtk_widget_hide(sb_horiz);
gtkCanvasUpdateChildLayout(ih);
}
}
else
gtk_widget_set_sensitive(sb_horiz, FALSE);
ih->data->posx = (float)xmin;
gtkCanvasAdjustmentSetValue(ih, sb_horiz_adjust, xmin);
return 1;
}
else
{
if (!iupgtkIsVisible(sb_horiz))
{
gtk_widget_show(sb_horiz);
gtkCanvasUpdateChildLayout(ih);
}
gtk_widget_set_sensitive(sb_horiz, TRUE);
}
#if GTK_CHECK_VERSION(2, 14, 0)
{
double page_size = dx;
double dvalue = gtk_adjustment_get_value(sb_horiz_adjust);
value_changed = gtkCanvasCheckScroll(xmin, xmax, &page_size, &dvalue);
gtk_adjustment_configure(sb_horiz_adjust, dvalue, xmin, xmax, linex, page_size, dx);
}
#else
{
sb_horiz_adjust->lower = xmin;
sb_horiz_adjust->upper = xmax;
sb_horiz_adjust->step_increment = linex;
sb_horiz_adjust->page_size = dx;
value_changed = gtkCanvasCheckScroll(xmin, xmax, &sb_horiz_adjust->page_size, &sb_horiz_adjust->value);
sb_horiz_adjust->page_increment = sb_horiz_adjust->page_size;
gtk_adjustment_changed(sb_horiz_adjust);
}
#endif
if (value_changed)
gtk_adjustment_value_changed(sb_horiz_adjust);
}
return 1;
}
void ring_rate_changed()
{
/* Fixes all adjustments that depend on sample rate */
gfloat val = 0.0;
gfloat lower = 0.0;
gfloat upper = 0.0;
gfloat percentage = 0.0;
gfloat newval = 0.0;
if (!ready)
return;
/* The idea behind this is pretty cool.
* First off, if you increas the decimation or fft size, the
* lower/upper limit goes lower. What this does is gets the adjustments
* position as a percentage of range, alters the limits of that
* range and recalculates a new value and moves the pointer. This
* way if the pointer was at the min, and you increased the fft size
* the adjustment will auotmatically move to show you the increaed
* resolution...
*/
/* Store values BEFORE we change the limits... */
val = GTK_ADJUSTMENT(lf_adj)->value;
lower = GTK_ADJUSTMENT(lf_adj)->lower;
upper = GTK_ADJUSTMENT(lf_adj)->upper;
percentage = (val-lower)/(upper-lower);
/* Set new limits to the adjustment */
GTK_ADJUSTMENT(lf_adj)->lower =
(float)ring_rate/(float)decimation_factor/(float)nsamp;
GTK_ADJUSTMENT(lf_adj)->upper =
high_freq - 64.0*((float)ring_rate
/ (float)decimation_factor/(float)nsamp);
GTK_ADJUSTMENT(lf_adj)->step_increment = (float)ring_rate/(float)nsamp;
GTK_ADJUSTMENT(lf_adj)->page_increment = (float)ring_rate/(float)nsamp;
/* Copy new values to temp vars for new calc (cleaner code) */
lower = GTK_ADJUSTMENT(lf_adj)->lower;
upper = GTK_ADJUSTMENT(lf_adj)->upper;
newval = (percentage*(upper-lower)) + lower;
GTK_ADJUSTMENT(lf_adj)->value = newval;
/* Reset the value */
low_freq = GTK_ADJUSTMENT(lf_adj)->value;
/* Store values BEFORE we change the limits... */
val = GTK_ADJUSTMENT(hf_adj)->value;
lower = GTK_ADJUSTMENT(hf_adj)->lower;
upper = GTK_ADJUSTMENT(hf_adj)->upper;
percentage = (val-lower)/(upper-lower);
/* Set new limits to the adjustment */
GTK_ADJUSTMENT(hf_adj)->lower =
low_freq + 64.0*((float)ring_rate
/ (float)decimation_factor/(float)nsamp);
GTK_ADJUSTMENT(hf_adj)->upper =
(float)ring_rate/(float)(2*decimation_factor)
+ 10.001;
GTK_ADJUSTMENT(hf_adj)->step_increment = (float)ring_rate/(float)nsamp;
GTK_ADJUSTMENT(hf_adj)->page_increment = (float)ring_rate/(float)nsamp;
/* Copy new values to temp vars for new calc (cleaner code) */
lower = GTK_ADJUSTMENT(hf_adj)->lower;
upper = GTK_ADJUSTMENT(hf_adj)->upper;
newval = (percentage*(upper-lower)) + lower;
GTK_ADJUSTMENT(hf_adj)->value = newval;
high_freq = GTK_ADJUSTMENT(hf_adj)->value;
/* Reset the value */
/* Force the adjustments to update on screen */
gtk_adjustment_changed(GTK_ADJUSTMENT(lf_adj));
gtk_adjustment_changed(GTK_ADJUSTMENT(hf_adj));
/* Display lag control */
GTK_ADJUSTMENT(lag_adj)->upper = (int)(1000*ring_end/(ring_rate*sizeof(ring_type)));
gtk_adjustment_changed(GTK_ADJUSTMENT(lag_adj));
return;
}
/*!
\brief convert_temps() changes the values of controls based on the currently
selected temperature scale. IT works for labels, spinbuttons, etc...
\param widget (gpointer) pointer to the widget that contains the necessary
paramaters re temp (Alt label, etc)
\param units (gpointer) the temp scale selected
*/
G_MODULE_EXPORT void convert_temps(gpointer widget, gpointer units)
{
static void (*update_widget_f)(gpointer, gpointer);
static gboolean (*check_deps)(gconstpointer *) = NULL;
gconstpointer *dep_obj = NULL;
gfloat upper = 0.0;
gfloat lower = 0.0;
gfloat value = 0.0;
gchar * text = NULL;
GtkAdjustment * adj = NULL;
gboolean state = FALSE;
gint widget_temp = -1;
/*extern GdkColor black;*/
extern gconstpointer *global_data;
/* If this widgt depends on anything call check_dependancy which will
* return TRUE/FALSE. True if what it depends on is in the matching
* state, FALSE otherwise...
*/
if ((!widget) || (DATA_GET(global_data,"leaving")))
return;
if (!check_deps)
if (!get_symbol("check_dependancies",(void *)&check_deps))
dbg_func(CRITICAL|CONVERSIONS,g_strdup_printf(__FILE__": convert_temps()\n\tCan NOT locate \"check_dependancies\" function pointer in plugins, BUG!\n"));
if (!update_widget_f)
if(!get_symbol("update_widget",(void *)&update_widget_f))
dbg_func(CRITICAL|CONVERSIONS,g_strdup_printf(__FILE__": convert_temps()\n\tCan NOT locate \"update_widget\" function pointer in plugins, BUG!\n"));
dep_obj = (gconstpointer *)OBJ_GET(widget,"dep_object");
widget_temp = (GINT)OBJ_GET(widget,"widget_temp");
if (dep_obj)
{
if (check_deps)
state = check_deps(dep_obj);
else
dbg_func(CRITICAL|CONVERSIONS,g_strdup_printf(__FILE__": convert_temps()\n\tWidget %s has dependant object bound but can't locate function ptr for \"check_dependancies\" from plugins, BUG!\n",glade_get_widget_name(widget)));
}
switch ((TempUnits)units)
{
case FAHRENHEIT:
/*printf("fahr %s\n",glade_get_widget_name(widget));*/
if (GTK_IS_LABEL(widget))
{
if ((dep_obj) && (state))
text = (gchar *)OBJ_GET(widget,"alt_f_label");
else
text = (gchar *)OBJ_GET(widget,"f_label");
gtk_label_set_text(GTK_LABEL(widget),text);
//gtk_widget_modify_text(widget,GTK_STATE_NORMAL,&black);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
}
if ((GTK_IS_SPIN_BUTTON(widget)) && (widget_temp != FAHRENHEIT))
{
adj = (GtkAdjustment *) gtk_spin_button_get_adjustment(
GTK_SPIN_BUTTON(widget));
upper = adj->upper;
value = adj->value;
lower = adj->lower;
if (widget_temp == CELSIUS)
{
adj->value = c_to_f(value);
adj->lower = c_to_f(lower);
adj->upper = c_to_f(upper);
}
else /* Previous is kelvin */
{
adj->value = k_to_f(value);
adj->lower = k_to_f(lower);
adj->upper = k_to_f(upper);
}
gtk_adjustment_changed(adj);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
update_widget_f(widget,NULL);
}
if ((GTK_IS_ENTRY(widget)) && (widget_temp != FAHRENHEIT))
{
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
update_widget_f(widget,NULL);
}
if ((GTK_IS_RANGE(widget)) && (widget_temp != FAHRENHEIT))
{
adj = (GtkAdjustment *) gtk_range_get_adjustment(
GTK_RANGE(widget));
upper = adj->upper;
lower = adj->lower;
value = adj->value;
if (widget_temp == CELSIUS)
{
adj->value = c_to_f(value);
adj->lower = c_to_f(lower);
adj->upper = c_to_f(upper);
}
else /* Previous is kelvin */
{
adj->value = k_to_f(value);
adj->lower = k_to_f(lower);
adj->upper = k_to_f(upper);
}
gtk_range_set_adjustment(GTK_RANGE(widget),adj);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
}
break;
case CELSIUS:
/*printf("fahr %s\n",glade_get_widget_name(widget));*/
if (GTK_IS_LABEL(widget))
{
if ((dep_obj) && (state))
text = (gchar *)OBJ_GET(widget,"alt_c_label");
else
text = (gchar *)OBJ_GET(widget,"c_label");
gtk_label_set_text(GTK_LABEL(widget),text);
//gtk_widget_modify_text(widget,GTK_STATE_NORMAL,&black);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
}
if ((GTK_IS_SPIN_BUTTON(widget)) && (widget_temp != CELSIUS))
{
adj = (GtkAdjustment *) gtk_spin_button_get_adjustment(
GTK_SPIN_BUTTON(widget));
upper = adj->upper;
value = adj->value;
lower = adj->lower;
if (widget_temp == FAHRENHEIT)
{
adj->value = f_to_c(value);
adj->lower = f_to_c(lower);
adj->upper = f_to_c(upper);
}
else /* Previous is kelvin */
{
adj->value = k_to_c(value);
adj->lower = k_to_c(lower);
adj->upper = k_to_c(upper);
}
gtk_adjustment_changed(adj);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
update_widget_f(widget,NULL);
}
if ((GTK_IS_ENTRY(widget)) && (widget_temp != CELSIUS))
{
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
update_widget_f(widget,NULL);
}
if ((GTK_IS_RANGE(widget)) && (widget_temp != CELSIUS))
{
adj = (GtkAdjustment *) gtk_range_get_adjustment(
GTK_RANGE(widget));
upper = adj->upper;
lower = adj->lower;
value = adj->value;
if (widget_temp == FAHRENHEIT)
{
adj->value = f_to_c(value);
adj->lower = f_to_c(lower);
adj->upper = f_to_c(upper);
}
else /* Previous is kelvin */
{
adj->value = k_to_c(value);
adj->lower = k_to_c(lower);
adj->upper = k_to_c(upper);
}
gtk_range_set_adjustment(GTK_RANGE(widget),adj);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
}
break;
case KELVIN:
/*printf("fahr %s\n",glade_get_widget_name(widget));*/
if (GTK_IS_LABEL(widget))
{
if ((dep_obj) && (state))
text = (gchar *)OBJ_GET(widget,"alt_k_label");
else
text = (gchar *)OBJ_GET(widget,"k_label");
gtk_label_set_text(GTK_LABEL(widget),text);
//gtk_widget_modify_text(widget,GTK_STATE_NORMAL,&black);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
}
if ((GTK_IS_SPIN_BUTTON(widget)) && (widget_temp != KELVIN))
{
adj = (GtkAdjustment *) gtk_spin_button_get_adjustment(
GTK_SPIN_BUTTON(widget));
upper = adj->upper;
value = adj->value;
lower = adj->lower;
if (widget_temp == FAHRENHEIT)
{
adj->value = f_to_k(value);
adj->lower = f_to_k(lower);
adj->upper = f_to_k(upper);
}
else /* Previous is celsius */
{
adj->value = c_to_k(value);
adj->lower = c_to_k(lower);
adj->upper = c_to_k(upper);
}
gtk_adjustment_changed(adj);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
update_widget_f(widget,NULL);
}
if ((GTK_IS_ENTRY(widget)) && (widget_temp != KELVIN))
{
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
update_widget_f(widget,NULL);
}
if ((GTK_IS_RANGE(widget)) && (widget_temp != KELVIN))
{
adj = (GtkAdjustment *) gtk_range_get_adjustment(
GTK_RANGE(widget));
upper = adj->upper;
lower = adj->lower;
value = adj->value;
if (widget_temp == FAHRENHEIT)
{
adj->value = f_to_k(value);
adj->lower = f_to_k(lower);
adj->upper = f_to_k(upper);
}
else /* Previous is celsius */
{
adj->value = c_to_k(value);
adj->lower = c_to_k(lower);
adj->upper = c_to_k(upper);
}
gtk_range_set_adjustment(GTK_RANGE(widget),adj);
OBJ_SET(widget,"widget_temp",GINT_TO_POINTER(units));
}
break;
}
}
static VALUE
rg_changed(VALUE self)
{
gtk_adjustment_changed(_SELF(self));
return self;
}
static gboolean scroll_callback_cb( void *d)
{
flow_sScroll *data = &((FlowWidgetGtk *)d)->scroll_data;
flowwidget_sScroll *scroll_data = (flowwidget_sScroll *) data->scroll_data;
((FlowWidgetGtk *)scroll_data->flow)->scroll_timerid = 0;
if ( data->total_width <= data->window_width) {
if ( data->offset_x == 0)
data->total_width = data->window_width;
if ( scroll_data->scroll_h_managed) {
// Remove horizontal scrollbar
}
}
else {
if ( !scroll_data->scroll_h_managed) {
// Insert horizontal scrollbar
}
}
if ( data->total_height <= data->window_height) {
if ( data->offset_y == 0)
data->total_height = data->window_height;
if ( scroll_data->scroll_v_managed) {
// Remove vertical scrollbar
}
}
else {
if ( !scroll_data->scroll_v_managed) {
// Insert vertical scrollbar
}
}
if ( data->offset_x < 0) {
data->total_width += -data->offset_x;
data->offset_x = 0;
}
if ( data->offset_y < 0) {
data->total_height += -data->offset_y;
data->offset_y = 0;
}
if ( data->total_height < data->window_height + data->offset_y)
data->total_height = data->window_height + data->offset_y;
if ( data->total_width < data->window_width + data->offset_x)
data->total_width = data->window_width + data->offset_x;
if ( data->window_width < 1)
data->window_width = 1;
if ( data->window_height < 1)
data->window_height = 1;
if ( scroll_data->scroll_h_managed) {
((FlowWidgetGtk *)scroll_data->flow)->scroll_h_ignore = 1;
if ( data->window_width != ((FlowWidgetGtk *)scroll_data->flow)->scroll_h_pagesize ||
data->total_width != ((FlowWidgetGtk *)scroll_data->flow)->scroll_h_upper ||
((FlowWidgetGtk *)scroll_data->flow)->scroll_configure) {
g_object_set( ((GtkScrollbar *)scroll_data->scroll_h)->range.adjustment,
"upper", (gdouble)data->total_width,
"page-size", (gdouble)data->window_width,
"value", (gdouble)data->offset_x,
NULL);
gtk_adjustment_changed( ((GtkScrollbar *)scroll_data->scroll_h)->range.adjustment);
}
else {
gtk_range_set_value( GTK_RANGE(scroll_data->scroll_h), (gdouble)data->offset_x);
}
((FlowWidgetGtk *)scroll_data->flow)->scroll_h_value = (gdouble)data->offset_x;
((FlowWidgetGtk *)scroll_data->flow)->scroll_h_pagesize = data->window_width;
((FlowWidgetGtk *)scroll_data->flow)->scroll_h_upper = data->total_width;
}
if ( scroll_data->scroll_v_managed) {
((FlowWidgetGtk *)scroll_data->flow)->scroll_v_ignore = 1;
if ( data->window_height != ((FlowWidgetGtk *)scroll_data->flow)->scroll_v_pagesize ||
data->total_height != ((FlowWidgetGtk *)scroll_data->flow)->scroll_v_upper ||
((FlowWidgetGtk *)scroll_data->flow)->scroll_configure) {
g_object_set( ((GtkScrollbar *)scroll_data->scroll_v)->range.adjustment,
"upper", (gdouble)data->total_height,
"page-size", (gdouble)data->window_height,
"value", (gdouble)data->offset_y,
NULL);
gtk_adjustment_changed( ((GtkScrollbar *)scroll_data->scroll_v)->range.adjustment);
}
else {
g_object_set( ((GtkScrollbar *)scroll_data->scroll_v)->range.adjustment,
"value", (gdouble)data->offset_y,
NULL);
gtk_adjustment_value_changed( ((GtkScrollbar *)scroll_data->scroll_v)->range.adjustment);
}
((FlowWidgetGtk *)scroll_data->flow)->scroll_v_value = (gdouble)data->offset_y;
((FlowWidgetGtk *)scroll_data->flow)->scroll_h_pagesize = data->window_width;
((FlowWidgetGtk *)scroll_data->flow)->scroll_h_upper = data->total_width;
}
((FlowWidgetGtk *)scroll_data->flow)->scroll_configure = 0;
return FALSE;
}
static gint
moz_gtk_scrollbar_thumb_paint(GtkThemeWidgetType widget,
GdkDrawable* drawable, GdkRectangle* rect,
GdkRectangle* cliprect, GtkWidgetState* state,
GtkTextDirection direction)
{
GtkStateType state_type = (state->inHover || state->active) ?
GTK_STATE_PRELIGHT : GTK_STATE_NORMAL;
GtkShadowType shadow_type = GTK_SHADOW_OUT;
GtkStyle* style;
GtkScrollbar *scrollbar;
GtkAdjustment *adj;
gboolean activate_slider;
ensure_scrollbar_widget();
if (widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL)
scrollbar = GTK_SCROLLBAR(gParts->horizScrollbarWidget);
else
scrollbar = GTK_SCROLLBAR(gParts->vertScrollbarWidget);
gtk_widget_set_direction(GTK_WIDGET(scrollbar), direction);
/* Make sure to set the scrollbar range before painting so that
everything is drawn properly. At least the bluecurve (and
maybe other) themes don't draw the top or bottom black line
surrounding the scrollbar if the theme thinks that it's butted
up against the scrollbar arrows. Note the increases of the
clip rect below. */
/* Changing the cliprect is pretty bogus. This lets themes draw
outside the frame, which means we don't invalidate them
correctly. See bug 297508. But some themes do seem to need
it. So we modify the frame's overflow area to account for what
we're doing here; see nsNativeThemeGTK::GetWidgetOverflow. */
adj = gtk_range_get_adjustment(GTK_RANGE(scrollbar));
if (widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL) {
cliprect->x -= 1;
cliprect->width += 2;
gtk_adjustment_set_page_size(adj, rect->width);
}
else {
cliprect->y -= 1;
cliprect->height += 2;
gtk_adjustment_set_page_size(adj, rect->height);
}
#if GTK_CHECK_VERSION(2, 14, 0)
gtk_adjustment_configure(adj,
state->curpos,
0,
state->maxpos,
gtk_adjustment_get_step_increment(adj),
gtk_adjustment_get_page_increment(adj),
gtk_adjustment_get_page_size(adj));
#else
adj->lower = 0;
adj->value = state->curpos;
adj->upper = state->maxpos;
gtk_adjustment_changed(adj);
#endif
style = gtk_widget_get_style(GTK_WIDGET(scrollbar));
gtk_widget_style_get(GTK_WIDGET(scrollbar), "activate-slider",
&activate_slider, NULL);
if (activate_slider && state->active) {
shadow_type = GTK_SHADOW_IN;
state_type = GTK_STATE_ACTIVE;
}
TSOffsetStyleGCs(style, rect->x, rect->y);
gtk_paint_slider(style, drawable, state_type, shadow_type, cliprect,
GTK_WIDGET(scrollbar), "slider", rect->x, rect->y,
rect->width, rect->height,
(widget == MOZ_GTK_SCROLLBAR_THUMB_HORIZONTAL) ?
GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL);
return MOZ_GTK_SUCCESS;
}
static gboolean prefswindow_row_selected(GtkTreeSelection *selector,
GtkTreeModel *model,
GtkTreePath *path,
gboolean currently_selected,
gpointer data)
{
PrefsTreeNode *prefsnode;
PrefsPage *page;
PrefsWindow *prefswindow = (PrefsWindow *) data;
gfloat lower;
gchar *labeltext;
gint pagenum, i;
GtkTreeIter iter;
GtkAdjustment *adj;
#ifndef GENERIC_UMPC
if (currently_selected)
return TRUE;
#endif
if (!gtk_tree_model_get_iter(GTK_TREE_MODEL(model), &iter, path))
return TRUE;
gtk_tree_model_get(model, &iter, PREFS_PAGE_DATA, &prefsnode, -1);
page = prefsnode->page;
debug_print("%f\n", prefsnode->treeweight);
if (page == NULL) {
gtk_label_set_text(GTK_LABEL(prefswindow->pagelabel), "");
pagenum = gtk_notebook_page_num(GTK_NOTEBOOK(prefswindow->notebook),
prefswindow->empty_page);
gtk_notebook_set_current_page(GTK_NOTEBOOK(prefswindow->notebook),
pagenum);
return TRUE;
}
prefswindow_build_page(prefswindow, page);
i = 0;
while (page->path[i + 1] != 0)
i++;
labeltext = page->path[i];
gtk_label_set_text(GTK_LABEL(prefswindow->pagelabel), labeltext);
pagenum = gtk_notebook_page_num(GTK_NOTEBOOK(prefswindow->notebook),
page->widget);
gtk_notebook_set_current_page(GTK_NOTEBOOK(prefswindow->notebook),
pagenum);
adj = gtk_scrolled_window_get_vadjustment(
GTK_SCROLLED_WINDOW(page->widget));
lower = gtk_adjustment_get_lower(adj);
gtk_adjustment_set_value(adj, lower);
gtk_adjustment_changed(adj);
adj = gtk_scrolled_window_get_hadjustment(
GTK_SCROLLED_WINDOW(page->widget));
gtk_adjustment_set_value(adj, lower);
gtk_adjustment_changed(adj);
#ifdef GENERIC_UMPC
prefs_show_page(prefswindow);
#endif
return TRUE;
}
void prefswindow_open_full(const gchar *title, GSList *prefs_pages,
gpointer data, GDestroyNotify func,
gint *save_width, gint *save_height,
gboolean preload_pages,
PrefsOpenCallbackFunc open_cb,
PrefsApplyCallbackFunc apply_cb,
PrefsCloseCallbackFunc close_cb)
{
PrefsWindow *prefswindow;
gint x = gdk_screen_width();
gint y = gdk_screen_height();
static GdkGeometry geometry;
GtkAdjustment *adj;
prefswindow = g_new0(PrefsWindow, 1);
prefswindow->data = data;
prefswindow->func = func;
prefswindow->prefs_pages = g_slist_copy(prefs_pages);
prefswindow->save_width = save_width;
prefswindow->save_height = save_height;
prefswindow->open_cb = open_cb;
prefswindow->apply_cb = apply_cb;
prefswindow->close_cb = close_cb;
prefswindow->dialog_response = PREFSWINDOW_RESPONSE_CANCEL;
prefswindow->window = gtkut_window_new(GTK_WINDOW_TOPLEVEL, "prefswindow");
gtk_window_set_title(GTK_WINDOW(prefswindow->window), title);
gtk_window_set_position (GTK_WINDOW(prefswindow->window), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (prefswindow->window), TRUE);
gtk_window_set_resizable (GTK_WINDOW(prefswindow->window), TRUE);
gtk_window_set_transient_for (GTK_WINDOW(prefswindow->window),
GTK_WINDOW(mainwindow_get_mainwindow()->window));
gtk_container_set_border_width(GTK_CONTAINER(prefswindow->window), 4);
prefswindow->vbox = gtk_vbox_new(FALSE, 6);
gtk_widget_show(prefswindow->vbox);
prefswindow->paned = gtk_hpaned_new();
gtk_widget_show(prefswindow->paned);
gtk_container_add(GTK_CONTAINER(prefswindow->window), prefswindow->vbox);
gtk_box_pack_start(GTK_BOX(prefswindow->vbox), prefswindow->paned, TRUE, TRUE, 0);
prefswindow->scrolledwindow1 = gtk_scrolled_window_new(NULL, NULL);
gtk_widget_show(prefswindow->scrolledwindow1);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(prefswindow->scrolledwindow1),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(prefswindow->scrolledwindow1),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_paned_add1(GTK_PANED(prefswindow->paned), prefswindow->scrolledwindow1);
prefswindow->tree_view = prefswindow_tree_view_create(prefswindow);
gtk_widget_show(prefswindow->tree_view);
gtk_container_add(GTK_CONTAINER(prefswindow->scrolledwindow1),
prefswindow->tree_view);
prefswindow->vbox2 = gtk_vbox_new(FALSE, 2);
gtk_widget_show(prefswindow->vbox2);
gtk_paned_add2(GTK_PANED(prefswindow->paned), prefswindow->vbox2);
prefswindow->table2 = gtk_table_new(1, 2, FALSE);
gtk_widget_show(prefswindow->table2);
gtk_container_add(GTK_CONTAINER(prefswindow->vbox2), prefswindow->table2);
prefswindow->labelframe = gtk_frame_new(NULL);
gtk_widget_show(prefswindow->labelframe);
gtk_frame_set_shadow_type(GTK_FRAME(prefswindow->labelframe), GTK_SHADOW_OUT);
gtk_table_attach(GTK_TABLE(prefswindow->table2), prefswindow->labelframe,
0, 1, 0, 1, GTK_FILL | GTK_EXPAND, GTK_FILL, 1, 1);
prefswindow->pagelabel = gtk_label_new("");
gtk_widget_show(prefswindow->pagelabel);
gtk_label_set_justify(GTK_LABEL(prefswindow->pagelabel), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(prefswindow->pagelabel), 0, 0.0);
gtk_container_add(GTK_CONTAINER(prefswindow->labelframe), prefswindow->pagelabel);
prefswindow->notebook = gtk_notebook_new();
gtk_widget_show(prefswindow->notebook);
gtk_notebook_set_scrollable(GTK_NOTEBOOK(prefswindow->notebook), TRUE);
gtk_notebook_set_show_tabs(GTK_NOTEBOOK(prefswindow->notebook), FALSE);
gtk_notebook_set_show_border(GTK_NOTEBOOK(prefswindow->notebook), FALSE);
gtk_table_attach(GTK_TABLE(prefswindow->table2), prefswindow->notebook,
0, 1, 1, 2, GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 0, 4);
prefswindow->empty_page = gtk_label_new("");
gtk_widget_show(prefswindow->empty_page);
gtk_container_add(GTK_CONTAINER(prefswindow->notebook), prefswindow->empty_page);
prefswindow_build_tree(prefswindow->tree_view, prefs_pages, prefswindow,
preload_pages);
if (open_cb)
open_cb(prefswindow);
gtk_widget_grab_focus(prefswindow->tree_view);
#ifndef GENERIC_UMPC
gtkut_stock_button_set_create(&prefswindow->confirm_area,
&prefswindow->apply_btn, GTK_STOCK_APPLY,
&prefswindow->cancel_btn, GTK_STOCK_CANCEL,
&prefswindow->ok_btn, GTK_STOCK_OK);
#else
gtkut_stock_button_set_create(&prefswindow->confirm_area,
&prefswindow->apply_btn, GTK_STOCK_APPLY,
&prefswindow->ok_btn, GTK_STOCK_CLOSE,
NULL, NULL);
#endif
gtk_widget_show_all(prefswindow->confirm_area);
gtk_widget_show(prefswindow->vbox);
gtk_widget_show(prefswindow->scrolledwindow1);
gtk_box_pack_start(GTK_BOX(prefswindow->vbox), prefswindow->confirm_area, FALSE, FALSE, 0);
#ifndef GENERIC_UMPC
g_signal_connect(G_OBJECT(prefswindow->ok_btn), "clicked",
G_CALLBACK(ok_button_clicked), prefswindow);
g_signal_connect(G_OBJECT(prefswindow->cancel_btn), "clicked",
G_CALLBACK(cancel_button_clicked), prefswindow);
g_signal_connect(G_OBJECT(prefswindow->apply_btn), "clicked",
G_CALLBACK(apply_button_clicked), prefswindow);
#else
g_signal_connect(G_OBJECT(prefswindow->ok_btn), "clicked",
G_CALLBACK(ok_button_clicked), prefswindow);
g_signal_connect(G_OBJECT(prefswindow->apply_btn), "clicked",
G_CALLBACK(apply_button_clicked), prefswindow);
#endif
g_signal_connect(G_OBJECT(prefswindow->window), "delete_event",
G_CALLBACK(window_closed), prefswindow);
g_signal_connect(G_OBJECT(prefswindow->window), "key_press_event",
G_CALLBACK(prefswindow_key_pressed), &(prefswindow->window));
/* connect to callback only if we have non-NULL pointers to store size to */
if (prefswindow->save_width && prefswindow->save_height) {
g_signal_connect(G_OBJECT(prefswindow->window), "size_allocate",
G_CALLBACK(prefs_size_allocate_cb), prefswindow);
}
MANAGE_WINDOW_SIGNALS_CONNECT(prefswindow->window);
if (!geometry.min_height) {
if (x < 800 && y < 600) {
geometry.min_width = 600;
geometry.min_height = 440;
} else {
geometry.min_width = 700;
geometry.min_height = 550;
}
}
gtk_window_set_geometry_hints(GTK_WINDOW(prefswindow->window), NULL, &geometry,
GDK_HINT_MIN_SIZE);
if (prefswindow->save_width && prefswindow->save_height) {
gtk_widget_set_size_request(prefswindow->window, *(prefswindow->save_width),
*(prefswindow->save_height));
}
#ifdef GENERIC_UMPC
prefs_show_sections(prefswindow);
#endif
gtk_widget_show(prefswindow->window);
adj = gtk_scrolled_window_get_vadjustment(
GTK_SCROLLED_WINDOW(prefswindow->scrolledwindow1));
gtk_adjustment_set_value(adj, gtk_adjustment_get_lower(adj));
gtk_adjustment_changed(adj);
}
/**
* @param ddisp The diagram display object that a window is created for
* @param width Diagram widgth
* @param height Diagram Height
* @param title Window title
* @param use_mbar Flag to indicate whether to add a menubar to the window
*/
void
create_display_shell(DDisplay *ddisp,
int width, int height,
char *title, int use_mbar)
{
GtkWidget *table, *widget;
GtkWidget *status_hbox;
GtkWidget *root_vbox = NULL;
GtkWidget *zoom_hbox, *zoom_label;
int s_width, s_height;
if (app_is_interactive() && is_integrated_ui())
{
use_integrated_ui_for_display_shell(ddisp, title);
return;
}
ddisp->is_standalone_window = TRUE;
ddisp->container = NULL;
s_width = gdk_screen_width ();
s_height = gdk_screen_height ();
if (width > s_width)
width = s_width;
if (height > s_height)
height = s_height;
/* The toplevel shell */
ddisp->shell = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (ddisp->shell), title);
gtk_window_set_role (GTK_WINDOW (ddisp->shell), "diagram_window");
gtk_window_set_icon_name (GTK_WINDOW (ddisp->shell), "dia");
gtk_window_set_default_size(GTK_WINDOW (ddisp->shell), width, height);
/* set_icon_name needs registered theme icons, not always available: provide fallback */
if (!gtk_window_get_icon (GTK_WINDOW (ddisp->shell))) {
static GdkPixbuf *pixbuf = NULL;
if (!pixbuf)
pixbuf = gdk_pixbuf_new_from_inline(-1, dia_diagram_icon, FALSE, NULL);
if (pixbuf)
gtk_window_set_icon (GTK_WINDOW (ddisp->shell), pixbuf);
}
g_object_set_data (G_OBJECT (ddisp->shell), "user_data", (gpointer) ddisp);
_ddisplay_setup_events (ddisp, ddisp->shell);
/* following two not shared with integrated UI */
g_signal_connect (G_OBJECT (ddisp->shell), "delete_event",
G_CALLBACK (ddisplay_delete), ddisp);
g_signal_connect (G_OBJECT (ddisp->shell), "destroy",
G_CALLBACK (ddisplay_destroy), ddisp);
/* the table containing all widgets */
table = gtk_table_new (4, 3, FALSE);
gtk_table_set_col_spacing (GTK_TABLE (table), 0, 1);
gtk_table_set_col_spacing (GTK_TABLE (table), 1, 2);
gtk_table_set_row_spacing (GTK_TABLE (table), 0, 1);
gtk_table_set_row_spacing (GTK_TABLE (table), 1, 2);
gtk_container_set_border_width (GTK_CONTAINER (table), 2);
if (use_mbar)
{
root_vbox = gtk_vbox_new (FALSE, 1);
gtk_container_add (GTK_CONTAINER (ddisp->shell), root_vbox);
gtk_box_pack_end (GTK_BOX (root_vbox), table, TRUE, TRUE, 0);
}
else
{
gtk_container_add (GTK_CONTAINER (ddisp->shell), table);
}
/* scrollbars, rulers, canvas, menu popup button */
if (!use_mbar) {
ddisp->origin = gtk_button_new();
#if GTK_CHECK_VERSION(2,18,0)
gtk_widget_set_can_focus (ddisp->origin, FALSE);
#else
GTK_WIDGET_UNSET_FLAGS(ddisp->origin, GTK_CAN_FOCUS);
#endif
widget = gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_OUT);
gtk_container_add(GTK_CONTAINER(ddisp->origin), widget);
gtk_widget_set_tooltip_text(widget, _("Diagram menu."));
gtk_widget_show(widget);
g_signal_connect(G_OBJECT(ddisp->origin), "button_press_event",
G_CALLBACK(origin_button_press), ddisp);
}
else {
ddisp->origin = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (ddisp->origin), GTK_SHADOW_OUT);
}
_ddisplay_setup_rulers (ddisp, ddisp->shell, table);
_ddisplay_setup_scrollbars (ddisp, table, width, height);
_ddisplay_setup_navigation (ddisp, table);
ddisp->canvas = create_canvas (ddisp);
/* pack all remaining widgets */
gtk_table_attach (GTK_TABLE (table), ddisp->origin, 0, 1, 0, 1,
GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (GTK_TABLE (table), ddisp->canvas, 1, 2, 1, 2,
GTK_EXPAND | GTK_SHRINK | GTK_FILL,
GTK_EXPAND | GTK_SHRINK | GTK_FILL, 0, 0);
/* TODO rob use per window accel */
ddisp->accel_group = menus_get_display_accels ();
gtk_window_add_accel_group(GTK_WINDOW(ddisp->shell), ddisp->accel_group);
if (use_mbar)
{
ddisp->menu_bar = menus_create_display_menubar (&ddisp->ui_manager, &ddisp->actions);
g_assert (ddisp->menu_bar);
gtk_box_pack_start (GTK_BOX (root_vbox), ddisp->menu_bar, FALSE, TRUE, 0);
}
/* the statusbars */
status_hbox = gtk_hbox_new (FALSE, 2);
/* Zoom status pseudo-optionmenu */
ddisp->zoom_status = create_zoom_widget(ddisp);
zoom_hbox = gtk_hbox_new(FALSE, 0);
zoom_label = gtk_label_new(_("Zoom"));
gtk_box_pack_start (GTK_BOX(zoom_hbox), zoom_label,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX(zoom_hbox), ddisp->zoom_status,
FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (status_hbox), zoom_hbox, FALSE, FALSE, 0);
/* Grid on/off button */
ddisp->grid_status = dia_toggle_button_new_with_icons(dia_on_grid_icon,
dia_off_grid_icon);
g_signal_connect(G_OBJECT(ddisp->grid_status), "toggled",
G_CALLBACK (grid_toggle_snap), ddisp);
gtk_widget_set_tooltip_text(ddisp->grid_status,
_("Toggles snap-to-grid for this window."));
gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->grid_status,
FALSE, FALSE, 0);
ddisp->mainpoint_status = dia_toggle_button_new_with_icons(dia_mainpoints_on_icon,
dia_mainpoints_off_icon);
g_signal_connect(G_OBJECT(ddisp->mainpoint_status), "toggled",
G_CALLBACK (interface_toggle_mainpoint_magnetism), ddisp);
gtk_widget_set_tooltip_text(ddisp->mainpoint_status,
_("Toggles object snapping for this window."));
gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->mainpoint_status,
FALSE, FALSE, 0);
/* Statusbar */
ddisp->modified_status = gtk_statusbar_new ();
gtk_box_pack_start (GTK_BOX (status_hbox), ddisp->modified_status,
TRUE, TRUE, 0);
gtk_table_attach (GTK_TABLE (table), status_hbox, 0, 3, 3, 4,
GTK_FILL, GTK_FILL, 0, 0);
display_rulers_show (ddisp);
gtk_widget_show (ddisp->zoom_status);
gtk_widget_show (zoom_hbox);
gtk_widget_show (zoom_label);
gtk_widget_show (ddisp->grid_status);
gtk_widget_show (ddisp->mainpoint_status);
gtk_widget_show (ddisp->modified_status);
gtk_widget_show (status_hbox);
gtk_widget_show (table);
if (use_mbar)
{
gtk_widget_show (ddisp->menu_bar);
gtk_widget_show (root_vbox);
}
gtk_widget_show (ddisp->shell);
/* before showing up, checking canvas's REAL size */
if (use_mbar && ddisp->hrule->allocation.width > width)
{
/* The menubar is not shrinkable, so the shell will have at least
* the menubar's width. If the diagram's requested width is smaller,
* the canvas will be enlarged to fit the place. In this case, we
* need to adjust the horizontal scrollbar according to the size
* that will be allocated, which the same as the hrule got.
*/
width = ddisp->hrule->allocation.width;
gtk_adjustment_set_upper (ddisp->hsbdata, width);
gtk_adjustment_set_page_increment (ddisp->hsbdata, (width - 1) / 4);
gtk_adjustment_set_page_size (ddisp->hsbdata, width - 1);
gtk_adjustment_changed (GTK_ADJUSTMENT(ddisp->hsbdata));
}
gtk_widget_show (ddisp->canvas);
/* set the focus to the canvas area */
gtk_widget_grab_focus (ddisp->canvas);
}
static gboolean
e_reflow_event (GnomeCanvasItem *item, GdkEvent *event)
{
EReflow *reflow;
int return_val = FALSE;
reflow = E_REFLOW (item);
switch( event->type )
{
case GDK_KEY_PRESS:
return_val = e_selection_model_key_press(reflow->selection, (GdkEventKey *) event);
break;
#if 0
if (event->key.keyval == GDK_Tab ||
event->key.keyval == GDK_KP_Tab ||
event->key.keyval == GDK_ISO_Left_Tab) {
int i;
int count;
count = reflow->count;
for (i = 0; i < count; i++) {
int unsorted = e_sorter_sorted_to_model (E_SORTER (reflow->sorter), i);
GnomeCanvasItem *item = reflow->items[unsorted];
EFocus has_focus;
if (item) {
g_object_get(item,
"has_focus", &has_focus,
NULL);
if (has_focus) {
if (event->key.state & GDK_SHIFT_MASK) {
if (i == 0)
return FALSE;
i--;
} else {
if (i == count - 1)
return FALSE;
i++;
}
unsorted = e_sorter_sorted_to_model (E_SORTER (reflow->sorter), i);
if (reflow->items[unsorted] == NULL) {
reflow->items[unsorted] = e_reflow_model_incarnate (reflow->model, unsorted, GNOME_CANVAS_GROUP (reflow));
}
item = reflow->items[unsorted];
gnome_canvas_item_set(item,
"has_focus", (event->key.state & GDK_SHIFT_MASK) ? E_FOCUS_END : E_FOCUS_START,
NULL);
return TRUE;
}
}
}
}
#endif
case GDK_BUTTON_PRESS:
switch(event->button.button)
{
case 1:
{
GdkEventButton *button = (GdkEventButton *) event;
double n_x, max_x;
n_x = button->x;
n_x += E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH;
n_x = fmod(n_x,(reflow->column_width + E_REFLOW_FULL_GUTTER));
max_x = E_REFLOW_BORDER_WIDTH;
max_x += (reflow->column_width + E_REFLOW_FULL_GUTTER) * reflow->column_count;
if ( button->y >= E_REFLOW_BORDER_WIDTH && button->y <= reflow->height - E_REFLOW_BORDER_WIDTH && n_x < E_REFLOW_FULL_GUTTER && max_x > button->x ) {
/* don't allow to drag the first line*/
if (e_reflow_pick_line(reflow, button->x) == 0)
return TRUE;
reflow->which_column_dragged = e_reflow_pick_line(reflow, button->x);
reflow->start_x = reflow->which_column_dragged * (reflow->column_width + E_REFLOW_FULL_GUTTER) - E_REFLOW_DIVIDER_WIDTH / 2;
reflow->temp_column_width = reflow->column_width;
reflow->column_drag = TRUE;
gnome_canvas_item_grab (item,
GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
reflow->arrow_cursor,
button->time);
reflow->previous_temp_column_width = -1;
reflow->need_column_resize = TRUE;
gnome_canvas_item_request_update(item);
return TRUE;
}
}
break;
case 4:
{
GtkAdjustment *adjustment = gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas));
gdouble new_value = adjustment->value;
new_value -= adjustment->step_increment;
gtk_adjustment_set_value(adjustment, new_value);
}
break;
case 5:
{
GtkAdjustment *adjustment = gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas));
gdouble new_value = adjustment->value;
new_value += adjustment->step_increment;
if ( new_value > adjustment->upper - adjustment->page_size )
new_value = adjustment->upper - adjustment->page_size;
gtk_adjustment_set_value(adjustment, new_value);
}
break;
}
break;
case GDK_BUTTON_RELEASE:
if (reflow->column_drag) {
gdouble old_width = reflow->column_width;
GdkEventButton *button = (GdkEventButton *) event;
GtkAdjustment *adjustment = gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas));
reflow->temp_column_width = reflow->column_width +
(button->x - reflow->start_x)/(reflow->which_column_dragged - e_reflow_pick_line(reflow, adjustment->value));
if ( reflow->temp_column_width < 50 )
reflow->temp_column_width = 50;
reflow->column_drag = FALSE;
if ( old_width != reflow->temp_column_width ) {
gtk_adjustment_set_value(adjustment, adjustment->value + e_reflow_pick_line(reflow, adjustment->value) * (reflow->temp_column_width - reflow->column_width));
reflow->column_width = reflow->temp_column_width;
adjustment->step_increment = (reflow->column_width + E_REFLOW_FULL_GUTTER) / 2;
adjustment->page_increment = adjustment->page_size - adjustment->step_increment;
gtk_adjustment_changed(adjustment);
e_reflow_resize_children(item);
e_canvas_item_request_reflow(item);
gnome_canvas_request_redraw(item->canvas, 0, 0, reflow->width, reflow->height);
column_width_changed (reflow);
}
reflow->need_column_resize = TRUE;
gnome_canvas_item_request_update(item);
gnome_canvas_item_ungrab (item, button->time);
return TRUE;
}
break;
case GDK_MOTION_NOTIFY:
if (reflow->column_drag) {
double old_width = reflow->temp_column_width;
GdkEventMotion *motion = (GdkEventMotion *) event;
GtkAdjustment *adjustment = gtk_layout_get_hadjustment(GTK_LAYOUT(item->canvas));
reflow->temp_column_width = reflow->column_width +
(motion->x - reflow->start_x)/(reflow->which_column_dragged - e_reflow_pick_line(reflow, adjustment->value));
if (reflow->temp_column_width < 50)
reflow->temp_column_width = 50;
if (old_width != reflow->temp_column_width) {
reflow->need_column_resize = TRUE;
gnome_canvas_item_request_update(item);
}
return TRUE;
} else {
GdkEventMotion *motion = (GdkEventMotion *) event;
double n_x, max_x;
n_x = motion->x;
n_x += E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH;
n_x = fmod(n_x,(reflow->column_width + E_REFLOW_FULL_GUTTER));
max_x = E_REFLOW_BORDER_WIDTH;
max_x += (reflow->column_width + E_REFLOW_FULL_GUTTER) * reflow->column_count;
if ( motion->y >= E_REFLOW_BORDER_WIDTH && motion->y <= reflow->height - E_REFLOW_BORDER_WIDTH && n_x < E_REFLOW_FULL_GUTTER && max_x > motion->x) {
if ( reflow->default_cursor_shown ) {
gdk_window_set_cursor(GTK_WIDGET(item->canvas)->window, reflow->arrow_cursor);
reflow->default_cursor_shown = FALSE;
}
} else
if ( ! reflow->default_cursor_shown ) {
gdk_window_set_cursor(GTK_WIDGET(item->canvas)->window, reflow->default_cursor);
reflow->default_cursor_shown = TRUE;
}
}
break;
case GDK_ENTER_NOTIFY:
if (!reflow->column_drag) {
GdkEventCrossing *crossing = (GdkEventCrossing *) event;
double n_x, max_x;
n_x = crossing->x;
n_x += E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH;
n_x = fmod(n_x,(reflow->column_width + E_REFLOW_FULL_GUTTER));
max_x = E_REFLOW_BORDER_WIDTH;
max_x += (reflow->column_width + E_REFLOW_FULL_GUTTER) * reflow->column_count;
if ( crossing->y >= E_REFLOW_BORDER_WIDTH && crossing->y <= reflow->height - E_REFLOW_BORDER_WIDTH && n_x < E_REFLOW_FULL_GUTTER && max_x > crossing->x) {
if ( reflow->default_cursor_shown ) {
gdk_window_set_cursor(GTK_WIDGET(item->canvas)->window, reflow->arrow_cursor);
reflow->default_cursor_shown = FALSE;
}
}
}
break;
case GDK_LEAVE_NOTIFY:
if (!reflow->column_drag) {
GdkEventCrossing *crossing = (GdkEventCrossing *) event;
double n_x;
n_x = crossing->x;
n_x += E_REFLOW_BORDER_WIDTH + E_REFLOW_DIVIDER_WIDTH;
n_x = fmod(n_x,(reflow->column_width + E_REFLOW_FULL_GUTTER));
if ( !( crossing->y >= E_REFLOW_BORDER_WIDTH && crossing->y <= reflow->height - E_REFLOW_BORDER_WIDTH && n_x < E_REFLOW_FULL_GUTTER ) ) {
if ( ! reflow->default_cursor_shown ) {
gdk_window_set_cursor(GTK_WIDGET(item->canvas)->window, reflow->default_cursor);
reflow->default_cursor_shown = TRUE;
}
}
}
break;
default:
break;
}
if (return_val)
return return_val;
else if (GNOME_CANVAS_ITEM_CLASS( e_reflow_parent_class )->event)
return (* GNOME_CANVAS_ITEM_CLASS( e_reflow_parent_class )->event) (item, event);
else
return FALSE;
}
static void update_view(PussVConsole* self) {
VConsole* vcon = self->vcon;
SMALL_RECT* range;
DWORD i, j, h, w, sz;
DWORD cx, cy;
gchar text[(MAX_SCR_LEN+1)*6 + MAX_SCR_ROW];
gchar* pd = text;
CHAR_INFO* ps;
GtkTextIter it, end;
GtkTextView* txt_view = GTK_TEXT_VIEW(self->view);
GtkTextBuffer* txt_buf = gtk_text_view_get_buffer(txt_view);
if( !self->vcon || !self->need_update )
return;
self->need_update = FALSE;
range = &(vcon->screen_info->srWindow);
h = range->Bottom - range->Top + 1;
w = range->Right - range->Left + 1;
cy = vcon->screen_info->dwCursorPosition.Y - range->Top;
cx = vcon->screen_info->dwCursorPosition.X - range->Left;
// scroll bar update
self->adjust->lower = 1;
self->adjust->upper = vcon->screen_info->dwSize.Y;
self->adjust->step_increment = 1;
self->adjust->page_size = h;
self->adjust->page_increment = h;
self->adjust->value = range->Top;
// screen buffer update
ps = vcon->screen_buffer;
for( i=0; i<h; ++i ) {
for( j=0; j<w; ++j ) {
if( ps->Char.UnicodeChar && g_unichar_validate(ps->Char.UnicodeChar) ) {
sz = g_unichar_to_utf8(ps->Char.UnicodeChar, pd);
pd += sz;
if( ps->Char.UnicodeChar > 0xff ) {
++j;
if( cy==i )
--cx;
}
} else {
//g_print("unknown = %d\n", ps->Char.UnicodeChar);
}
++ps;
}
// remove end space
while(*(pd-1)=='\t' || *(pd-1)==' ' ) --pd;
*pd = '\n';
++pd;
}
*pd = '\0';
sz = (DWORD)(pd - text);
gtk_text_buffer_set_text(txt_buf, text, sz);
// cursor update
h = gtk_text_buffer_get_line_count(txt_buf);
if( cy >= h ) {
gtk_text_view_set_cursor_visible(txt_view, FALSE);
} else {
gtk_text_buffer_get_iter_at_line(txt_buf, &it, cy);
end = it;
if( gtk_text_iter_forward_chars(&end, cx) ) {
it = end;
} else {
if( gtk_text_iter_forward_to_line_end(&end) ) {
it = end;
} else {
gtk_text_buffer_get_iter_at_line(txt_buf, &it, cy);
}
}
gtk_text_buffer_place_cursor(txt_buf, &it);
gtk_text_view_set_cursor_visible(txt_view, TRUE);
}
gtk_adjustment_changed(self->adjust);
}
