static gboolean
wrap_table_child_focus_in (GtkWidget *widget,
GdkEventFocus *event,
gpointer data)
{
gint x, y;
GtkWidget *container, *viewport;
GtkAdjustment *hadj, *vadj;
container = gtk_widget_get_parent (widget);
if (container)
{
viewport = gtk_widget_get_parent (container);
}
g_assert (container && viewport);
g_assert (GTK_IS_VIEWPORT (viewport));
g_return_val_if_fail (gtk_widget_get_realized (viewport), FALSE);
if (!wrap_table_child_visible_in (widget, viewport))
{
hadj = gtk_viewport_get_hadjustment (GTK_VIEWPORT (viewport));
vadj = gtk_viewport_get_vadjustment (GTK_VIEWPORT (viewport));
gtk_widget_translate_coordinates (widget, container, 0, 0, &x, &y);
gtk_adjustment_set_value (hadj, MIN (x, hadj->upper - hadj->page_size));
gtk_adjustment_set_value (vadj, MIN (y, vadj->upper - vadj->page_size));
}
return FALSE;
}
static void
cv_tabs_sizealloc (GtkWidget *widget, GtkAllocation *allocation, chanview *cv)
{
GdkWindow *parent_win;
GtkAdjustment *adj;
GtkWidget *inner;
gint viewport_size;
inner = ((tabview *)cv)->inner;
parent_win = gtk_widget_get_window (gtk_widget_get_parent (inner));
if (cv->vertical)
{
adj = gtk_viewport_get_vadjustment (GTK_VIEWPORT (gtk_widget_get_parent (inner)));
gdk_window_get_geometry (parent_win, 0, 0, 0, &viewport_size, 0);
} else
{
adj = gtk_viewport_get_hadjustment (GTK_VIEWPORT (gtk_widget_get_parent (inner)));
gdk_window_get_geometry (parent_win, 0, 0, &viewport_size, 0, 0);
}
if (gtk_adjustment_get_upper (adj) <= viewport_size)
{
gtk_widget_hide (((tabview *)cv)->b1);
gtk_widget_hide (((tabview *)cv)->b2);
} else
{
gtk_widget_show (((tabview *)cv)->b1);
gtk_widget_show (((tabview *)cv)->b2);
}
}
static void
tab_scroll_right_down_clicked (GtkWidget *widget, chanview *cv)
{
GtkAdjustment *adj;
gint viewport_size;
gfloat new_value;
GtkWidget *inner;
GdkWindow *parent_win;
gdouble i;
inner = ((tabview *)cv)->inner;
parent_win = gtk_widget_get_window (gtk_widget_get_parent (inner));
if (cv->vertical)
{
adj = gtk_viewport_get_vadjustment (GTK_VIEWPORT (gtk_widget_get_parent(inner)));
gdk_window_get_geometry (parent_win, 0, 0, 0, &viewport_size, 0);
} else
{
adj = gtk_viewport_get_hadjustment (GTK_VIEWPORT (gtk_widget_get_parent(inner)));
gdk_window_get_geometry (parent_win, 0, 0, &viewport_size, 0, 0);
}
new_value = tab_search_offset (inner, gtk_adjustment_get_value (adj), 1, cv->vertical);
if (new_value == 0 || new_value + viewport_size > gtk_adjustment_get_upper (adj))
new_value = gtk_adjustment_get_upper (adj) - viewport_size;
if (!tab_right_is_moving)
{
tab_right_is_moving = 1;
for (i = gtk_adjustment_get_value (adj); ((i < new_value) && (tab_right_is_moving)); i += 0.1)
{
gtk_adjustment_set_value (adj, i);
while (g_main_context_pending (NULL))
g_main_context_iteration (NULL, TRUE);
}
gtk_adjustment_set_value (adj, new_value);
tab_right_is_moving = 0; /* hSP: set to false in case we didnt get stopped (the normal case) */
}
else
{
tab_right_is_moving = 0; /* hSP: jump directly to next element if user is clicking faster than we can scroll.. */
}
}
static void
gimp_container_grid_view_init (GimpContainerGridView *grid_view)
{
GimpContainerBox *box = GIMP_CONTAINER_BOX (grid_view);
GtkWidget *viewport;
grid_view->rows = 1;
grid_view->columns = 1;
grid_view->visible_rows = 0;
grid_view->selected_item = NULL;
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (box->scrolled_win),
GTK_SHADOW_IN);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (box->scrolled_win),
GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
gimp_editor_set_show_name (GIMP_EDITOR (grid_view), TRUE);
grid_view->wrap_box = gtk_hwrap_box_new (FALSE);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (box->scrolled_win),
grid_view->wrap_box);
viewport = gtk_widget_get_parent (grid_view->wrap_box);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport), GTK_SHADOW_NONE);
gtk_widget_show (grid_view->wrap_box);
g_signal_connect (viewport, "size-allocate",
G_CALLBACK (gimp_container_grid_view_viewport_resized),
grid_view);
g_signal_connect (viewport, "button-press-event",
G_CALLBACK (gimp_container_grid_view_button_press),
grid_view);
gtk_widget_set_can_focus (GTK_WIDGET (grid_view), TRUE);
}
void browser_show()
{
/* Main Window */
GtkWidget *window, *scroller, *scroller_vp, *header_hbox, *home, *search, *exit_button;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window),"PowerMaths");
//gtk_window_set_decorated(GTK_WINDOW(window),FALSE);
//gtk_window_maximize(GTK_WINDOW(window));
gtk_widget_set_size_request(window,gdk_screen_get_width(gdk_screen_get_default()),gdk_screen_get_height(gdk_screen_get_default()));
gtk_window_set_resizable(GTK_WINDOW(window),FALSE);
gtk_window_fullscreen(GTK_WINDOW(window));
scroller = gtk_hbox_new(0,5);
scroller_vp = gtk_viewport_new(NULL,NULL);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(scroller_vp),GTK_SHADOW_NONE);
gtk_container_add(GTK_CONTAINER(scroller_vp),scroller);
browser_viewport = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(browser_viewport),GTK_SHADOW_NONE);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(browser_viewport),GTK_POLICY_NEVER,GTK_POLICY_AUTOMATIC);
int height = gdk_screen_get_height(gdk_screen_get_default());
browser_scroll_hbox = gtk_hbox_new(0,5);
header_hbox = gtk_hbox_new(0,0);
home = gtk_pmhbutton_new("Home");
search = gtk_pmhbutton_new("Search");
gtk_widget_set_size_request(home,height/7,height/7);
gtk_widget_set_size_request(search,height/7,height/7);
gtk_widget_set_size_request(browser_scroll_hbox,0,height/7);
gtk_widget_set_size_request(header_hbox,0,height/7);
gtk_box_pack_start(GTK_BOX(scroller),home,0,0,0);
gtk_box_pack_start(GTK_BOX(scroller),browser_scroll_hbox,1,1,0);
gtk_box_pack_start(GTK_BOX(scroller),search,0,0,0);
vbox = gtk_vbox_new(0,0);
groups_create_table();
misc_set_background(scroller_vp,42405,0,8481);
misc_set_background(header_hbox,42405,0,8481);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(browser_viewport),browser_table);
GtkWidget *logo = gtk_vimage_new("pmlogo.svg");
gtk_widget_set_size_request(logo,height/7,height/7);
gtk_box_pack_start(GTK_BOX(header_hbox),logo,0,1,0);
gtk_box_pack_start(GTK_BOX(header_hbox),misc_create_banner("PowerMaths",80),1,1,0);
exit_button = gtk_pmhbutton_new("X");
gtk_widget_set_size_request(exit_button,height/7,height/7);
gtk_box_pack_end(GTK_BOX(header_hbox),exit_button,0,1,0);
gtk_box_pack_start(GTK_BOX(vbox),header_hbox,0,0,0);
gtk_box_pack_start(GTK_BOX(vbox),browser_viewport,TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(vbox),scroller_vp,0,0,0);
gtk_container_add(GTK_CONTAINER(window),vbox);
g_signal_connect(G_OBJECT(window),"delete-event",G_CALLBACK(browser_window_close),NULL);
g_signal_connect(G_OBJECT(home),"clicked",G_CALLBACK(browser_home_clicked),NULL);
g_signal_connect(G_OBJECT(search),"clicked",G_CALLBACK(search_create_table),NULL);
g_signal_connect(G_OBJECT(exit_button),"clicked",G_CALLBACK(gtk_exit),NULL);
gtk_widget_show_all(window);
}
static void add_credits_page(GtkWidget *notebook,
const gchar *title, gchar **people)
{
GtkWidget *label, *sw;
GString *string;
gint i;
gchar *tmp;
label = gtk_label_new(NULL);
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_label_set_justify(GTK_LABEL(label), GTK_JUSTIFY_LEFT);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
gtk_misc_set_padding(GTK_MISC(label), 8, 8);
sw = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(sw),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(sw), label);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(GTK_BIN(sw)->child),
GTK_SHADOW_NONE);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
sw, gtk_label_new(title));
string = g_string_new(NULL);
for (i = 0; people[i]; i++) {
tmp = g_markup_escape_text(people[i], -1);
g_string_append(string, tmp);
g_free(tmp);
if (people[i + 1])
g_string_append_c(string, '\n');
}
gtk_label_set_markup(GTK_LABEL(label), string->str);
g_string_free(string, TRUE);
}
GtkWidget * gw_status_bar_create ( GtkWindow *w)
{
GtkWidget *gw_status_bar_box;
GtkWidget *hbox;
GtkWidget *status_bar1;
GtkWidget *status_bar2;
#ifdef GW_DEBUG_GUI_COMPONENT
g_print ( "*** GW - %s (%d) :: %s()\n", __FILE__, __LINE__, __PRETTY_FUNCTION__);
#endif
gw_status_bar_box = gtk_viewport_new ( NULL, NULL);
gtk_viewport_set_shadow_type ( GTK_VIEWPORT ( gw_status_bar_box), GTK_SHADOW_NONE);
hbox = gtk_hbox_new ( FALSE, 0);
gtk_container_add ( GTK_CONTAINER ( gw_status_bar_box), hbox);
/* First status bar */
status_bar1 = gtk_statusbar_new ( );
gtk_widget_ref ( status_bar1);
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_STATUS_BAR_FIRST_STATUS, status_bar1, (GtkDestroyNotify) gtk_widget_unref);
gtk_box_pack_start ( GTK_BOX ( hbox), status_bar1, FALSE, FALSE, 0);
gtk_widget_set_usize ( status_bar1, 500, -2);
/* Second status bar */
status_bar2 = gtk_statusbar_new ( );
gtk_widget_ref ( status_bar2);
gtk_object_set_data_full ( GTK_OBJECT ( w), GW_REF_STATUS_BAR_SECOND_STATUS, status_bar2, (GtkDestroyNotify) gtk_widget_unref);
gtk_box_pack_start ( GTK_BOX ( hbox), status_bar2, TRUE, TRUE, 0);
return gw_status_bar_box;
}
static gboolean scroll_callback(GtkWidget * w, GdkEventScroll * evt,
gpointer data)
{
bg_nle_timeline_t * t = data;
double new_val;
GtkAdjustment * adj = gtk_viewport_get_vadjustment(GTK_VIEWPORT(t->preview_window));
// gtk_scrollbar_get_adjustment(GTK_SCROLLBAR(t->scrollbar));
if(evt->direction == GDK_SCROLL_UP)
{
new_val = adj->value - 3 * adj->step_increment;
gtk_adjustment_set_value(adj, new_val);
return TRUE;
}
else if(evt->direction == GDK_SCROLL_DOWN)
{
new_val = adj->value + 3 * adj->step_increment;
if(new_val > adj->upper - adj->page_size)
new_val = adj->upper - adj->page_size;
gtk_adjustment_set_value(adj, new_val);
return TRUE;
}
return FALSE;
}
GtkWidget *scrolledbrowwidgetgtk_new(
int (*init_proc)(FlowCtx *ctx, void *client_data),
void *client_data, GtkWidget **browwidget)
{
BrowWidgetGtk *w;
GtkWidget *form = gtk_scrolled_window_new( NULL, NULL);
w = (BrowWidgetGtk *) g_object_new( BROWWIDGETGTK_TYPE, NULL);
w->init_proc = init_proc;
w->brow_ctx = 0;
w->is_navigator = 0;
w->client_data = client_data;
w->scroll_h = GTK_SCROLLED_WINDOW(form)->hscrollbar;
w->scroll_v = GTK_SCROLLED_WINDOW(form)->vscrollbar;
w->scroll_h_ignore = 0;
w->scroll_v_ignore = 0;
w->scroll_h_value = 0;
w->scroll_v_value = 0;
w->scroll_configure = 0;
w->form = form;
*browwidget = GTK_WIDGET( w);
g_signal_connect( ((GtkScrollbar *)w->scroll_h)->range.adjustment,
"value-changed", G_CALLBACK(scroll_h_action), w);
g_signal_connect( ((GtkScrollbar *)w->scroll_v)->range.adjustment,
"value-changed", G_CALLBACK(scroll_v_action), w);
GtkWidget *viewport = gtk_viewport_new( NULL, NULL);
gtk_viewport_set_shadow_type( GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
gtk_container_add( GTK_CONTAINER(viewport), GTK_WIDGET(w));
gtk_container_add( GTK_CONTAINER(form), GTK_WIDGET(viewport));
return (GtkWidget *) form;
}
void ensure_scrolled_window_row_visible(widget_t list, int row, int num_rows)
{
/* view files file list */
/* called in snd-file.c on vdat->file_list which is a vbox; its parent is a viewport */
/* also used in slist_moveto below */
GtkWidget *parent;
GtkAdjustment *v;
gdouble maximum, size, new_value, minimum;
parent = gtk_widget_get_parent(list);
v = gtk_viewport_get_vadjustment(GTK_VIEWPORT(parent));
maximum = v->upper;
minimum = v->lower;
size = v->page_size;
maximum -= size;
if (row == 0)
new_value = 0.0;
else
{
if (row >= (num_rows - 1))
new_value = maximum;
else new_value = ((row + 0.5) * ((maximum - minimum) / (float)(num_rows - 1)));
}
if (new_value != v->value)
gtk_adjustment_set_value(v, new_value);
}
/*
* Sets the properties of the widget. This is used for both applying the
* properties changed in the property editor, and also for loading.
*/
static void
gb_viewport_set_properties (GtkWidget * widget, GbWidgetSetArgData * data)
{
gint i;
gchar *shadow;
shadow = gb_widget_input_choice (data, Shadow);
if (data->apply)
{
for (i = 0; i < sizeof (GbShadowValues) / sizeof (GbShadowValues[0]); i
++)
{
if (!strcmp (shadow, GbShadowChoices[i])
|| !strcmp (shadow, GbShadowSymbols[i]))
{
gtk_viewport_set_shadow_type (GTK_VIEWPORT (widget), GbShadowValues
[i]);
break;
}
}
}
/*
if (gb_widget_input_adjustment(data, HValues,
GTK_VIEWPORT(widget)->hadjustment))
gtk_signal_emit_by_name (GTK_OBJECT (GTK_VIEWPORT(widget)->hadjustment),
"value_changed");
if (gb_widget_input_adjustment(data, VValues,
GTK_VIEWPORT(widget)->vadjustment))
gtk_signal_emit_by_name (GTK_OBJECT (GTK_VIEWPORT(widget)->vadjustment),
"value_changed");
*/
}
static GtkTreeStore *_local_create_treestore_2cols(GtkWidget *popup,
int x, int y)
{
GtkScrolledWindow *window = create_scrolled_window();
GtkBin *bin = NULL;
GtkViewport *view = NULL;
GtkTable *table = NULL;
GtkTreeView *treeview = NULL;
GtkTreeStore *treestore = NULL;
bin = GTK_BIN(&window->container);
view = GTK_VIEWPORT(bin->child);
bin = GTK_BIN(&view->bin);
table = GTK_TABLE(bin->child);
gtk_window_set_default_size(GTK_WINDOW(popup),
x, y);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(popup)->vbox),
GTK_WIDGET(window), TRUE, TRUE, 0);
treeview = create_treeview_2cols_attach_to_table(table);
treestore = GTK_TREE_STORE(gtk_tree_view_get_model(treeview));
return treestore;
}
static GtkWidget *
scrolledwindow_new (GladeXML *xml, GladeWidgetInfo *info)
{
GtkWidget *win = gtk_scrolled_window_new(NULL, NULL);
GList *tmp;
GtkPolicyType hpol = GTK_POLICY_ALWAYS, vpol = GTK_POLICY_ALWAYS;
for (tmp = info->attributes; tmp; tmp = tmp->next) {
GladeAttribute *attr = tmp->data;
if (!strcmp(attr->name, "hscrollbar_policy"))
hpol = glade_enum_from_string(GTK_TYPE_POLICY_TYPE,
attr->value);
else if (!strcmp(attr->name, "hupdate_policy"))
gtk_range_set_update_policy(
GTK_RANGE(GTK_SCROLLED_WINDOW(win)->hscrollbar),
glade_enum_from_string(GTK_TYPE_UPDATE_TYPE,
attr->value));
else if (!strcmp(attr->name, "shadow_type"))
gtk_viewport_set_shadow_type(GTK_VIEWPORT(win),
glade_enum_from_string(GTK_TYPE_SHADOW_TYPE,
attr->value));
else if (!strcmp(attr->name, "vscrollbar_policy"))
vpol = glade_enum_from_string(GTK_TYPE_POLICY_TYPE,
attr->value);
else if (!strcmp(attr->name, "vupdate_policy"))
gtk_range_set_update_policy(
GTK_RANGE(GTK_SCROLLED_WINDOW(win)->vscrollbar),
glade_enum_from_string(GTK_TYPE_UPDATE_TYPE,
attr->value));
}
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(win), hpol, vpol);
return win;
}
/* Display a window containing the standard calendar widget. */
static GtkWidget * dclock_create_calendar(DClockPlugin * dc)
{
/* Create a new window. */
GtkWindow * window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
gtk_window_set_skip_taskbar_hint(window, TRUE);
gtk_window_set_skip_pager_hint(window, TRUE);
gtk_window_set_default_size(window, 180, 180);
gtk_window_set_decorated(window, FALSE);
gtk_window_set_resizable(window, FALSE);
gtk_window_stick(window);
gtk_container_set_border_width(GTK_CONTAINER(window), 0);
GtkWidget * viewport = gtk_viewport_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(window), viewport);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_OUT);
gtk_widget_show(viewport);
/* Create a vertical box as a child of the window. */
GtkWidget * box = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(viewport), GTK_WIDGET(box));
/* Create a standard calendar widget as a child of the vertical box. */
GtkWidget * calendar = gtk_calendar_new();
gtk_calendar_set_display_options(
GTK_CALENDAR(calendar),
GTK_CALENDAR_SHOW_WEEK_NUMBERS | GTK_CALENDAR_SHOW_DAY_NAMES | GTK_CALENDAR_SHOW_HEADING);
gtk_box_pack_start(GTK_BOX(box), calendar, TRUE, TRUE, 0);
/* Connect signals. */
g_signal_connect(G_OBJECT(window), "map", G_CALLBACK(dclock_popup_map), dc);
/* Return the widget. */
return GTK_WIDGET(window);
}
static void
add_row(GtkWidget *table, gint *row_p,
const gchar *name, const gchar *value, gboolean multiline,
gboolean expand)
{
gchar *bold_name;
GtkWidget *name_w;
bold_name = g_strconcat("<b>", name, "</b>", NULL);
name_w = gtk_label_new(bold_name);
g_free(bold_name);
gtk_misc_set_alignment(GTK_MISC(name_w), 0.0, 0.0);
gtk_label_set_use_markup(GTK_LABEL(name_w), TRUE);
gtk_table_attach(GTK_TABLE(table), name_w, 0, 1, *row_p, *row_p + 1,
GTK_FILL, GTK_FILL, 0, 0);
if (multiline) {
GtkWidget *label, *viewport;
GtkScrolledWindow *swin;
guint flags;
label = gtk_label_new (value);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_selectable (GTK_LABEL (label), TRUE);
gtk_widget_set_size_request (label, 200, -1);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
swin = GTK_SCROLLED_WINDOW(gtk_scrolled_window_new(NULL, NULL));
gtk_scrolled_window_set_policy(swin,
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
viewport = gtk_viewport_new (gtk_scrolled_window_get_hadjustment (swin),
gtk_scrolled_window_get_vadjustment (swin));
gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER(swin), viewport);
(*row_p)++;
if (expand)
flags = GTK_FILL|GTK_EXPAND;
else
flags = GTK_FILL;
gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(swin), 0, 2, *row_p, *row_p + 1,
GTK_FILL|GTK_EXPAND, flags, 0, 0);
gtk_container_add (GTK_CONTAINER (viewport), label);
} else {
GtkWidget *label = gtk_label_new(value);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_label_set_selectable(GTK_LABEL(label), TRUE);
gtk_table_attach(GTK_TABLE(table), label, 1, 2, *row_p, *row_p + 1,
GTK_FILL|GTK_EXPAND, GTK_FILL, 0, 0);
}
(*row_p)++;
}
/* mixer_scrolled_window_add */
static void _mixer_scrolled_window_add(GtkWidget * window, GtkWidget * widget)
{
GtkWidget * viewport;
viewport = gtk_viewport_new(NULL, NULL);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
gtk_container_add(GTK_CONTAINER(viewport), widget);
gtk_container_add(GTK_CONTAINER(window), viewport);
}
void
thunar_progress_dialog_add_job (ThunarProgressDialog *dialog,
ThunarJob *job,
const gchar *icon_name,
const gchar *title)
{
GtkWidget *viewport;
GtkWidget *view;
_thunar_return_if_fail (THUNAR_IS_PROGRESS_DIALOG (dialog));
_thunar_return_if_fail (THUNAR_IS_JOB (job));
_thunar_return_if_fail (g_utf8_validate (title, -1, NULL));
view = thunar_progress_view_new_with_job (job);
thunar_progress_view_set_icon_name (THUNAR_PROGRESS_VIEW (view), icon_name);
thunar_progress_view_set_title (THUNAR_PROGRESS_VIEW (view), title);
gtk_box_pack_start (GTK_BOX (dialog->content_box), view, FALSE, TRUE, 0);
gtk_widget_show (view);
/* use the first job's icon-name for the dialog */
if (dialog->views == NULL)
gtk_window_set_icon_name (GTK_WINDOW (dialog), icon_name);
/* add the view to the list of known views */
dialog->views = g_list_prepend (dialog->views, view);
/* check if we need to wrap the views in a scroll window (starting
* at SCROLLVIEW_THRESHOLD parallel operations */
if (g_list_length (dialog->views) == SCROLLVIEW_THRESHOLD)
{
/* create a scrolled window and add it to the dialog */
dialog->scrollwin = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (dialog->scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_container_add (GTK_CONTAINER (dialog->vbox), dialog->scrollwin);
gtk_widget_show (dialog->scrollwin);
/* create a viewport for the content box */
viewport = gtk_viewport_new (gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (dialog->scrollwin)),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (dialog->scrollwin)));
gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (dialog->scrollwin), viewport);
gtk_widget_show (viewport);
/* move the content box into the viewport */
gtk_widget_reparent (dialog->content_box, viewport);
}
g_signal_connect_swapped (view, "need-attention",
G_CALLBACK (thunar_progress_dialog_view_needs_attention), dialog);
g_signal_connect_swapped (view, "finished",
G_CALLBACK (thunar_progress_dialog_job_finished), dialog);
if (dialog->status_icon != NULL)
thunar_progress_dialog_update_status_icon (dialog);
}
int
clip_GTK_VIEWPORTGETSHADOWTYPE (ClipMachine *cm)
{
C_widget *cvp = _fetch_cw_arg(cm);
CHECKCWID(cvp,GTK_IS_VIEWPORT);
_clip_retni(cm,GTK_VIEWPORT(cvp->widget)->shadow_type);
return 0;
err:
return 1;
}
GtkWidget *groups_create_viewport()
{
if(groups_list == NULL)
{
error_dialog("Failed to load group list!\n");
}
groups_viewport = gtk_viewport_new(NULL,NULL);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(groups_viewport),GTK_SHADOW_NONE);
GtkWidget *details = gtk_text_view_new();
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(details),GTK_WRAP_WORD_CHAR);
gtk_text_view_set_editable(GTK_TEXT_VIEW(details),0);
details_buf = gtk_text_view_get_buffer(GTK_TEXT_VIEW(details));
GtkWidget *text_scroll = gtk_scrolled_window_new(NULL,NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(text_scroll),GTK_POLICY_AUTOMATIC,GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(text_scroll),GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(text_scroll),details);
GtkWidget *table = gtk_table_new(11,8,1);
GtkWidget *group[3];
struct groups_node *temp = groups_list;
int i = 0;
while(temp)
{
group[i] = gtk_button_new_with_label(temp->name);
g_signal_connect(G_OBJECT(group[i]),"enter",G_CALLBACK(groups_button_hover),temp->caption);
g_signal_connect(G_OBJECT(group[i]),"leave",G_CALLBACK(groups_button_leave),NULL);
g_signal_connect(G_OBJECT(group[i++]),"clicked",G_CALLBACK(groups_button_click),temp);
temp = temp->next;
}
gtk_table_attach(GTK_TABLE(table),misc_create_banner("Select a Category",50),0,8,0,1,GTK_FILL,GTK_FILL,0,0);
gtk_table_attach(GTK_TABLE(table),group[0],1,2,2,4,GTK_FILL,GTK_FILL,0,0);
gtk_table_attach(GTK_TABLE(table),group[1],1,2,5,7,GTK_FILL,GTK_FILL,0,0);
if(groups_count==3)
{
gtk_table_attach(GTK_TABLE(table),group[2],1,2,8,10,GTK_FILL,GTK_FILL,0,0);
gtk_table_attach(GTK_TABLE(table),text_scroll,3,7,2,10,GTK_FILL,GTK_FILL|GTK_EXPAND,0,0);
}
else
{
gtk_table_attach(GTK_TABLE(table),text_scroll,3,7,2,10,GTK_FILL,GTK_FILL|GTK_EXPAND,0,0);
}
gtk_container_add(GTK_CONTAINER(groups_viewport),table);
g_signal_connect(G_OBJECT(table),"expose-event",G_CALLBACK(browser_viewport_expose),NULL);
return groups_viewport;
}
static gboolean
lyric_show_viewport_expose(GtkWidget *widget,GdkEventExpose *event)
{
LyricShowViewport *lsv;
lsv = LYRIC_SHOW_VIEWPORT(widget);
GdkWindow *view = gtk_viewport_get_view_window(GTK_VIEWPORT(widget));
#if 1 ///必须启用否则widget大小变化时view上的东西不会被自动清除，界面混乱
gint view_width,view_height;
view_width = gdk_window_get_width(view);
view_height = gdk_window_get_height(view);
gtk_paint_flat_box(widget->style,
view,
GTK_STATE_NORMAL,
GTK_SHADOW_NONE,
NULL,
widget,
NULL,
0,0,
view_width,
view_height);
#endif
GTK_WIDGET_CLASS(lyric_show_viewport_parent_class)->expose_event(widget,event);
/// g_warning("is_pressed:%d",lsv->priv->is_pressed);
if(lsv->priv->is_pressed)
{
gtk_paint_hline(widget->style,
gtk_viewport_get_bin_window(GTK_VIEWPORT(widget)),
GTK_STATE_NORMAL,
NULL,
widget,
NULL,
0,widget->allocation.width,
lsv->priv->pos+lsv->priv->pressed_pos+widget->allocation.height/2.0);
}
return FALSE;
}
int
clip_GTK_VIEWPORTSETSHADOWTYPE (ClipMachine *cm)
{
C_widget *cvp = _fetch_cw_arg(cm);
GtkShadowType type = _clip_parni(cm, 2);
CHECKCWID(cvp,GTK_IS_VIEWPORT);
CHECKOPT(2,NUMERIC_t);
gtk_viewport_set_shadow_type (GTK_VIEWPORT(cvp->widget), type);
return 0;
err:
return 1;
}
/* Sets the Adjustment for the vertical scrollbar. */
int
clip_GTK_VIEWPORTSETVADJUSTMENT (ClipMachine *cm)
{
C_widget *cvp = _fetch_cw_arg(cm);
C_widget *cadj = _fetch_cwidget(cm,_clip_spar(cm, 2));
CHECKCWID(cvp,GTK_IS_VIEWPORT);
CHECKOPT2(2,MAP_t,NUMERIC_t); CHECKCWIDOPT(cadj,GTK_IS_ADJUSTMENT);
gtk_viewport_set_vadjustment (GTK_VIEWPORT(cvp->widget),
GTK_ADJUSTMENT(cadj->widget));
return 0;
err:
return 1;
}
static GObject *
carrick_list_constructor (GType gtype,
guint n_properties,
GObjectConstructParam *properties)
{
GObject *obj;
GObjectClass *parent_class;
CarrickListPrivate *priv;
GtkWidget *viewport, *box;
parent_class = G_OBJECT_CLASS (carrick_list_parent_class);
obj = parent_class->constructor (gtype, n_properties, properties);
priv = LIST_PRIVATE (obj);
priv->adjustment = gtk_scrolled_window_get_vadjustment
(GTK_SCROLLED_WINDOW (obj));
g_signal_connect (priv->adjustment, "value-changed",
G_CALLBACK (_adjustment_value_changed_cb), obj);
viewport = gtk_viewport_new (gtk_scrolled_window_get_hadjustment
(GTK_SCROLLED_WINDOW (obj)),
gtk_scrolled_window_get_vadjustment
(GTK_SCROLLED_WINDOW (obj)));
gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport),
GTK_SHADOW_NONE);
gtk_widget_show (viewport);
gtk_container_add (GTK_CONTAINER (obj), viewport);
box = gtk_vbox_new (FALSE, 0);
gtk_widget_show (box);
gtk_container_add (GTK_CONTAINER (viewport),
box);
gtk_label_set_line_wrap (GTK_LABEL (priv->fallback),
TRUE);
gtk_widget_set_size_request (priv->fallback,
550,
-1);
gtk_widget_show (priv->fallback);
gtk_misc_set_padding (GTK_MISC (priv->fallback), 0, 12);
gtk_box_pack_start (GTK_BOX (box), priv->fallback,
FALSE, FALSE, 2);
priv->box = gtk_vbox_new (FALSE, 0);
gtk_container_add (GTK_CONTAINER (box),
priv->box);
return obj;
}
void
picture_fit_to_window ()
{
gdouble width, height, ww, wh;
gdouble factor;
if (animated)
return;
width = gdk_pixbuf_get_width (orig_pb);
height = gdk_pixbuf_get_height (orig_pb);
ww = gdk_window_get_width (gtk_viewport_get_view_window (GTK_VIEWPORT (viewport)));
wh = gdk_window_get_height (gtk_viewport_get_view_window (GTK_VIEWPORT (viewport)));
factor = MIN (ww / width, wh / height);
if (factor < 1.0)
{
GdkPixbuf *pb = gdk_pixbuf_scale_simple (g_object_ref (orig_pb), width * factor, height * factor, GDK_INTERP_HYPER);
if (pb)
gtk_image_set_from_pixbuf (GTK_IMAGE (picture), pb);
}
}
static void
prefs_build( GtkWidget *widget )
{
Prefs *prefs = PREFS( widget );
GtkWidget *work;
#ifdef DEBUG
printf( "prefs_build: %p\n", prefs );
#endif /*DEBUG*/
/* Call all builds in superclasses.
*/
IWINDOW_CLASS( parent_class )->build( widget );
work = IDIALOG( prefs )->work;
prefs->pwview = PREFWORKSPACEVIEW( prefworkspaceview_new() );
prefworkspaceview_set_caption_filter( prefs->pwview,
prefs->caption_filter );
view_link( VIEW( prefs->pwview ), MODEL( prefs->ws ), NULL );
if( prefs->caption_filter ) {
gtk_box_pack_start( GTK_BOX( work ),
GTK_WIDGET( prefs->pwview ), TRUE, TRUE, 0 );
gtk_widget_show( GTK_WIDGET( prefs->pwview ) );
}
else {
/* No caption_filter set, so this is probably a big prefs
* window. Build a scrolledwindow for the content.
*/
GtkWidget *window;
window = gtk_scrolled_window_new( NULL, NULL );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( window ),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC );
gtk_scrolled_window_add_with_viewport(
GTK_SCROLLED_WINDOW( window ),
GTK_WIDGET( prefs->pwview ) );
gtk_viewport_set_shadow_type(
GTK_VIEWPORT( GTK_BIN( window )->child ),
GTK_SHADOW_NONE );
gtk_box_pack_start( GTK_BOX( work ),
GTK_WIDGET( window ), TRUE, TRUE, 0 );
gtk_widget_show( GTK_WIDGET( prefs->pwview ) );
gtk_widget_show( window );
}
}
/*
* Gets the properties of the widget. This is used for both displaying the
* properties in the property editor, and also for saving the properties.
*/
static void
gb_viewport_get_properties (GtkWidget * widget, GbWidgetGetArgData * data)
{
gint i;
for (i = 0; i < sizeof (GbShadowValues) / sizeof (GbShadowValues[0]); i++)
{
if (GbShadowValues[i] == GTK_VIEWPORT (widget)->shadow_type)
gb_widget_output_choice (data, Shadow, i, GbShadowSymbols[i]);
}
/*
gb_widget_output_adjustment(data, HValues, GTK_VIEWPORT(widget)->hadjustment);
gb_widget_output_adjustment(data, VValues, GTK_VIEWPORT(widget)->vadjustment);
*/
}
/*
* Writes the source code needed to create this widget.
* You have to output everything necessary to create the widget here, though
* there are some convenience functions to help.
*/
static void
gb_viewport_write_source (GtkWidget * widget, GbWidgetWriteSourceData * data)
{
gint i;
if (data->create_widget)
{
source_add (data, " %s = gtk_viewport_new (NULL, NULL);\n", data->wname);
}
gb_widget_write_standard_source (widget, data);
if (GTK_VIEWPORT (widget)->shadow_type != GTK_SHADOW_IN)
{
for (i = 0; i < sizeof (GbShadowValues) / sizeof (GbShadowValues[0]); i
++)
{
if (GbShadowValues[i] == GTK_VIEWPORT (widget)->shadow_type)
source_add (data,
" gtk_viewport_set_shadow_type (GTK_VIEWPORT (%s), %s);\n",
data->wname, GbShadowSymbols[i]);
}
}
}
static void
_new_page (OlPlayerChooser *window,
const char *page_name)
{
OlPlayerChooserPrivate *priv = OL_PLAYER_CHOOSER_GET_PRIVATE (window);
OlPlayerChooserPage *page = g_new (OlPlayerChooserPage, 1);
page->page_button = GTK_TOGGLE_BUTTON (gtk_radio_button_new_with_label (priv->page_button_group,
page_name));
priv->page_button_group = gtk_radio_button_get_group (GTK_RADIO_BUTTON (page->page_button));
gtk_toggle_button_set_mode (page->page_button, FALSE);
gtk_button_set_relief (GTK_BUTTON (page->page_button), GTK_RELIEF_NONE);
page->chooser = OL_APP_CHOOSER_WIDGET (ol_app_chooser_widget_new ());
gtk_widget_show (GTK_WIDGET (page->chooser));
page->panel = GTK_SCROLLED_WINDOW (gtk_scrolled_window_new (NULL, NULL));
gtk_scrolled_window_add_with_viewport (page->panel, GTK_WIDGET (page->chooser));
GtkViewport *viewport = GTK_VIEWPORT (gtk_bin_get_child (GTK_BIN (page->panel)));
gtk_viewport_set_shadow_type (viewport, GTK_SHADOW_NONE);
gtk_scrolled_window_set_policy (page->panel,
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
g_signal_connect (page->page_button,
"toggled",
G_CALLBACK (_page_button_toggled),
page);
g_signal_connect (page->chooser,
"app-activate",
G_CALLBACK (_app_activate_cb),
window);
_page_button_toggled (page->page_button, page);
if (priv->pages->len > 0)
gtk_box_pack_start (priv->page_button_panel,
gtk_vseparator_new (),
FALSE,
FALSE,
5);
gtk_box_pack_start (priv->page_button_panel,
GTK_WIDGET (page->page_button),
FALSE, /* expand */
FALSE, /* fill */
0); /* padding */
gtk_box_pack_start (priv->chooser_panel,
GTK_WIDGET (page->panel),
TRUE, /* expand */
TRUE, /* fill */
0); /* padding */
g_ptr_array_add (priv->pages, page);
}
/* Returns the vertical scrollbar's adjustment, used to
* connect the vertical scrollbar to the child widget's
* vertical scroll functionality. */
int
clip_GTK_VIEWPORTGETVADJUSTMENT (ClipMachine *cm)
{
C_widget *cvp = _fetch_cw_arg(cm);
ClipVar * cv = RETPTR(cm);
GtkAdjustment* adj;
C_widget *cadj;
CHECKCWID(cvp,GTK_IS_VIEWPORT);
adj = gtk_viewport_get_vadjustment (GTK_VIEWPORT(cvp->widget));
cadj = _list_get_cwidget(cm, adj);
if (!cadj) cadj = _register_widget(cm, (GtkWidget*)adj, NULL);
if (cadj) _clip_mclone(cm, cv, &cadj->obj);
return 0;
err:
return 1;
}
static GtkWidget *
viewport_new(GladeXML *xml, GladeWidgetInfo *info)
{
GtkWidget *port = gtk_viewport_new(NULL, NULL);
GList *tmp;
for (tmp = info->attributes; tmp; tmp = tmp->next) {
GladeAttribute *attr = tmp->data;
if (!strcmp(attr->name, "shadow_type"))
gtk_viewport_set_shadow_type(GTK_VIEWPORT(port),
glade_enum_from_string(GTK_TYPE_SHADOW_TYPE,
attr->value));
}
return port;
}
