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);
}
/* 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);
}
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 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 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;
}
/*
* 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");
*/
}
/*
* CBoardDevice::Init()
*
* Initializes the device
*
* Returns: True if the initializing was successful and false if it failed.
*/
bool CBoardDevice::Init(GtkFixed *board_area, CBoardDeviceGroup *device_group)
{
this->device_group = device_group;
// Load the bitmap
GdkPixbuf *bg_pixbuf = gdk_pixbuf_new_from_stream(CFile(image_file.c_str()).get_input_stream(), NULL, NULL);
if(bg_pixbuf == NULL)
return false;
bitmap_x = bitmap_y = 0;
width = gdk_pixbuf_get_width(bg_pixbuf);
height = gdk_pixbuf_get_height(bg_pixbuf);
// Check if the type is LED, PUSH or TOGGLE
if(!strcmp(type.c_str(), "LED") ||
!strcmp(type.c_str(), "PUSH") ||
!strcmp(type.c_str(), "TOGGLE"))
{
// Set the appropriate width and height of the bitmap
width = width / 2;
// Check if PUSH because pushbuttons have the value 1 if they are up
if(!strcmp(type.c_str(), "PUSH"))
bitmap_x = 1;
}
// Check if the type is SSLED
else if(!strcmp(type.c_str(), "SSLED"))
{
// Set the appropriate width and height of the bitmap
width = width / 8;
height = height / 16;
}
GtkWidget *bg_viewport = gtk_viewport_new(NULL, NULL);
gtk_widget_set_events(bg_viewport, GDK_BUTTON_RELEASE_MASK);
g_signal_connect(G_OBJECT(bg_viewport), "button-press-event", G_CALLBACK(device_button_pressed), this);
g_signal_connect(G_OBJECT(bg_viewport), "button-release-event", G_CALLBACK(device_button_released), this);
gtk_widget_show(bg_viewport);
GtkWidget *bg_image = gtk_image_new_from_pixbuf(bg_pixbuf);
gtk_widget_show(bg_image);
gtk_container_add((GtkContainer*)bg_viewport, bg_image);
gtk_viewport_set_shadow_type((GtkViewport*)bg_viewport, GTK_SHADOW_NONE);
gtk_widget_set_size_request(bg_viewport, width, height);
gtk_adjustment_set_upper(gtk_viewport_get_hadjustment((GtkViewport*)bg_viewport), width);
gtk_adjustment_set_upper(gtk_viewport_get_vadjustment((GtkViewport*)bg_viewport), height);
gtk_fixed_put(board_area, bg_viewport, coords.x, coords.y);
g_object_unref(bg_pixbuf);
viewport = (GtkViewport*)bg_viewport;
ShowCorrectImage();
return true;
}
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)++;
}
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);
}
/* 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);
}
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;
}
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;
}
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;
}
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 );
}
}
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);
}
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;
}
static void
gdaui_cloud_init (GdauiCloud *cloud)
{
cloud->priv = g_new0 (GdauiCloudPriv, 1);
cloud->priv->min_scale = .8;
cloud->priv->max_scale = 2.;
cloud->priv->selected_tags = NULL;
cloud->priv->selection_mode = GTK_SELECTION_SINGLE;
gtk_orientable_set_orientation (GTK_ORIENTABLE (cloud), GTK_ORIENTATION_VERTICAL);
/* text buffer */
cloud->priv->tbuffer = gtk_text_buffer_new (NULL);
gtk_text_buffer_create_tag (cloud->priv->tbuffer, "section",
"weight", PANGO_WEIGHT_BOLD,
"foreground", "blue", NULL);
/* text view */
GtkWidget *sw, *vbox, *vp;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start (GTK_BOX (cloud), sw, TRUE, TRUE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
vp = gtk_viewport_new (NULL, NULL);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (vp), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (sw), vp);
gtk_container_add (GTK_CONTAINER (vp), vbox);
cloud->priv->tview = gtk_text_view_new_with_buffer (cloud->priv->tbuffer);
gtk_text_view_set_wrap_mode (GTK_TEXT_VIEW (cloud->priv->tview), GTK_WRAP_WORD);
gtk_text_view_set_editable (GTK_TEXT_VIEW (cloud->priv->tview), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (cloud->priv->tview), FALSE);
gtk_box_pack_start (GTK_BOX (vbox), cloud->priv->tview, TRUE, TRUE, 0);
gtk_widget_show_all (sw);
g_signal_connect (cloud->priv->tview, "key-press-event",
G_CALLBACK (key_press_event), cloud);
g_signal_connect (cloud->priv->tview, "event-after",
G_CALLBACK (event_after), cloud);
g_signal_connect (cloud->priv->tview, "motion-notify-event",
G_CALLBACK (motion_notify_event), cloud);
g_signal_connect (cloud->priv->tview, "visibility-notify-event",
G_CALLBACK (visibility_notify_event), cloud);
}
JNIEXPORT void JNICALL
Java_gnu_java_awt_peer_gtk_GtkComponentPeer_gtkWidgetSetParent
(JNIEnv *env, jobject obj, jobject parent)
{
void *ptr;
void *parent_ptr;
GtkWidget *widget;
GtkWidget *parent_widget;
gdk_threads_enter ();
ptr = gtkpeer_get_widget (env, obj);
parent_ptr = gtkpeer_get_widget (env, parent);
widget = GTK_WIDGET (ptr);
parent_widget = get_widget(GTK_WIDGET (parent_ptr));
if (widget->parent == NULL)
{
if (GTK_IS_WINDOW (parent_widget))
{
GList *children = gtk_container_get_children
(GTK_CONTAINER (parent_widget));
if (GTK_IS_MENU_BAR (children->data))
gtk_fixed_put (GTK_FIXED (children->next->data), widget, 0, 0);
else
gtk_fixed_put (GTK_FIXED (children->data), widget, 0, 0);
}
else
if (GTK_IS_SCROLLED_WINDOW (parent_widget))
{
gtk_scrolled_window_add_with_viewport
(GTK_SCROLLED_WINDOW (parent_widget), widget);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (widget->parent),
GTK_SHADOW_NONE);
}
else
{
if (widget->parent == NULL)
gtk_fixed_put (GTK_FIXED (parent_widget), widget, 0, 0);
}
}
gdk_threads_leave ();
}
GtkWidget *
utl_gui_insert_in_scrolled_window (GtkWidget *widget, GtkShadowType type)
{
GtkWidget *scrolledwindow, *viewport;
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledwindow),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
viewport = gtk_viewport_new (NULL, NULL);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport), type);
gtk_container_add (GTK_CONTAINER (scrolledwindow), viewport);
gtk_container_add (GTK_CONTAINER (viewport), widget);
return scrolledwindow;
}
static GtkWidget* main_window (OGDProvider *provider)
{
GtkWidget *window;
GtkWidget *container;
GtkWidget *categories;
GtkWidget *contents;
GtkWidget *scrollable;
GtkWidget *viewport;
GtkListStore *store;
GtkCellRenderer *rend;
mainStatus = gtk_statusbar_new ();
gtk_statusbar_push (GTK_STATUSBAR (mainStatus), 1, "Fetching categories...");
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (G_OBJECT (window), "delete_event", G_CALLBACK (delete_event), NULL);
gtk_window_set_default_size (GTK_WINDOW (window), 300, 300);
container = gtk_vbox_new (FALSE, 5);
gtk_container_add (GTK_CONTAINER (window), container);
contents = gtk_vbox_new (TRUE, 2);
store = gtk_list_store_new (2, G_TYPE_STRING, G_TYPE_OBJECT);
categories = gtk_combo_box_new_with_model (GTK_TREE_MODEL (store));
rend = gtk_cell_renderer_text_new ();
gtk_cell_layout_pack_start (GTK_CELL_LAYOUT (categories), rend, TRUE);
gtk_cell_layout_add_attribute (GTK_CELL_LAYOUT (categories), rend, "text", 0);
g_signal_connect (G_OBJECT (categories), "changed", G_CALLBACK (fetch_contents_by_category), contents);
ogd_category_fetch_all_async (provider, add_category, categories);
gtk_container_add (GTK_CONTAINER (container), categories);
scrollable = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrollable), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_widget_set_size_request (scrollable, 300, 250);
gtk_container_add (GTK_CONTAINER (container), scrollable);
viewport = gtk_viewport_new (NULL, NULL);
gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport), GTK_SHADOW_NONE);
gtk_container_add (GTK_CONTAINER (scrollable), viewport);
gtk_container_add (GTK_CONTAINER (viewport), contents);
gtk_container_add (GTK_CONTAINER (container), mainStatus);
return window;
}
static GObject*
lyric_show_viewport_constructor(GType type,
guint n_construct_properties,
GObjectConstructParam *construct_properties)
{
GObject *object;
LyricShowViewport *lsv;
GtkWidget *hbox;
object = G_OBJECT_CLASS(lyric_show_viewport_parent_class)->constructor(
type,
n_construct_properties,
construct_properties);
lsv = LYRIC_SHOW_VIEWPORT(object);
lsv->priv->msg = gtk_label_new("");
lsv->priv->lyricbox =
#if GTK_CHECK_VERSION(3,2,0)
gtk_box_new(GTK_ORIENTATION_VERTICAL,0);
gtk_box_set_homogeneous(GTK_BOX(lsv->priv->lyricbox),TRUE);
#else
gtk_vbox_new(TRUE,2);
#endif
hbox =
#if GTK_CHECK_VERSION(3,2,0)
gtk_box_new(GTK_ORIENTATION_HORIZONTAL,0);
#else
gtk_hbox_new(FALSE,0);
#endif
lsv->priv->box_bin = gtk_bin_instance_new();
gtk_box_pack_start(GTK_BOX(hbox),lsv->priv->msg,TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(hbox),lsv->priv->lyricbox,TRUE,TRUE,0);
gtk_widget_set_no_show_all(lsv->priv->lyricbox,TRUE);
gtk_widget_set_no_show_all(lsv->priv->msg,TRUE);
gtk_container_add(GTK_CONTAINER(lsv->priv->box_bin),hbox);
gtk_widget_show_all(hbox);
gtk_widget_show_all(lsv->priv->box_bin);
gtk_container_add(GTK_CONTAINER(lsv),lsv->priv->box_bin);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(lsv),GTK_SHADOW_IN);
return object;
}
static GtkWidget *splash_build_page(void)
{
GtkWidget *pm;
GtkWidget *viewport;
gchar *filename;
filename = g_build_filename(DATADIR, "pixmaps", "pioneers",
"splash.png", NULL);
pm = gtk_image_new_from_file(filename);
g_free(filename);
/* The viewport avoids that the pixmap is drawn up into the tab area if
* it's too large for the space provided. */
viewport = gtk_viewport_new(NULL, NULL);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport),
GTK_SHADOW_NONE);
gtk_widget_show(viewport);
gtk_widget_set_size_request(pm, 1, 1);
gtk_widget_show(pm);
gtk_container_add(GTK_CONTAINER(viewport), pm);
return viewport;
}
GtkWidget *
eel_scrolled_wrap_table_new (gboolean homogeneous,
GtkShadowType shadow_type,
GtkWidget **wrap_table_out)
{
GtkWidget *scrolled_window;
GtkWidget *wrap_table;
GtkWidget *viewport;
g_return_val_if_fail (wrap_table_out != NULL, NULL);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolled_window),
GTK_POLICY_NEVER,
GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_overlay_scrolling (GTK_SCROLLED_WINDOW (scrolled_window), FALSE);
viewport = gtk_viewport_new (gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (scrolled_window)),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (scrolled_window)));
gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport),
shadow_type);
gtk_container_add (GTK_CONTAINER (scrolled_window),
viewport);
wrap_table = eel_wrap_table_new (homogeneous);
gtk_container_add (GTK_CONTAINER (viewport),
wrap_table);
gtk_widget_show (wrap_table);
gtk_widget_show (viewport);
EEL_WRAP_TABLE (wrap_table)->details->is_scrolled = 1;
*wrap_table_out = wrap_table;
return scrolled_window;
}
static void
prop_dialog_add_properties(PropDialog *dialog, GPtrArray *props)
{
guint i;
gboolean scrollable = (props->len > 16);
if (scrollable) {
GtkWidget *swin = gtk_scrolled_window_new (NULL, NULL);
GtkWidget *vbox = gtk_vbox_new(FALSE,2);
gtk_box_pack_start(GTK_BOX (dialog->widget), swin, TRUE, TRUE, 0);
gtk_widget_show (swin);
gtk_scrolled_window_add_with_viewport (GTK_SCROLLED_WINDOW (swin), vbox);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_bin_get_child(GTK_BIN(swin))), GTK_SHADOW_NONE);
gtk_widget_show (vbox);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (swin), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
prop_dialog_container_push (dialog, swin);
prop_dialog_container_push (dialog, vbox);
}
for (i = 0; i < props->len; i++) {
Property *prop = (Property*)g_ptr_array_index(props,i);
prop_dialog_add_property(dialog, prop);
}
if (scrollable) {
GtkRequisition requisition;
GtkWidget *vbox = prop_dialog_container_pop(dialog);
GtkWidget *swin = prop_dialog_container_pop(dialog);
GdkScreen *screen = gtk_widget_get_screen(swin);
gint sheight = screen ? (2 * gdk_screen_get_height(screen)) / 3 : 400;
gtk_widget_size_request (vbox, &requisition);
/* I'd say default size calculation for scrollable is quite broken */
gtk_widget_set_size_request (swin, -1, requisition.height > sheight ? sheight : requisition.height);
}
}
void
port_setup_dialog(void) {
GtkWidget * vbox;
GtkWidget * table;
GtkWidget * button_rescan;
GtkWidget * button_close;
GtkWidget * button_clear_outs;
GtkWidget * frame_dl;
GtkWidget * frame_dr;
GtkCellRenderer * renderer_out_L;
GtkCellRenderer * renderer_out_R;
GtkTreeSelection * select_out_L;
GtkTreeSelection * select_out_R;
GtkWidget * viewp_out_L;
GtkWidget * viewp_out_R;
GtkWidget * hbox_L;
GtkWidget * hbox_R;
GtkWidget * label_L;
GtkWidget * label_R;
GdkColor color = { 0, 0, 0, 0 };
store_out_L = gtk_list_store_new(1, G_TYPE_STRING);
store_out_R = gtk_list_store_new(1, G_TYPE_STRING);
ports_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(ports_window), _("JACK Port Setup"));
gtk_window_set_position(GTK_WINDOW(ports_window), GTK_WIN_POS_CENTER);
gtk_window_set_modal(GTK_WINDOW(ports_window), TRUE);
gtk_window_set_transient_for(GTK_WINDOW(ports_window), GTK_WINDOW(main_window));
g_signal_connect(G_OBJECT(ports_window), "delete_event", G_CALLBACK(port_window_close), NULL);
vbox = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(ports_window), vbox);
table = gtk_table_new(2, 2, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 2);
button_rescan = gui_stock_label_button(_("Rescan"), GTK_STOCK_REFRESH);
gtk_table_attach(GTK_TABLE(table), button_rescan, 0, 1, 1, 2,
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 5);
g_signal_connect(G_OBJECT(button_rescan), "clicked", G_CALLBACK(clicked_rescan), NULL);
button_close = gtk_button_new_from_stock (GTK_STOCK_CLOSE);
gtk_table_attach(GTK_TABLE(table), button_close, 1, 2, 1, 2,
GTK_FILL | GTK_EXPAND, GTK_FILL, 5, 5);
g_signal_connect(G_OBJECT(button_close), "clicked", G_CALLBACK(ports_clicked_close), NULL);
frame_dl = gtk_frame_new(_("Outputs"));
gtk_table_attach(GTK_TABLE(table), frame_dl, 0, 1, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 5, 5);
frame_dr = gtk_frame_new(_("Available connections"));
gtk_table_attach(GTK_TABLE(table), frame_dr, 1, 2, 0, 1,
GTK_FILL | GTK_EXPAND, GTK_FILL | GTK_EXPAND, 5, 5);
vbox_dl = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox_dl), 8);
gtk_container_add(GTK_CONTAINER(frame_dl), vbox_dl);
vbox_dr = gtk_vbox_new(FALSE, 5);
gtk_container_set_border_width(GTK_CONTAINER(vbox_dr), 8);
gtk_container_add(GTK_CONTAINER(frame_dr), vbox_dr);
button_clear_outs = gui_stock_label_button(_("Clear connections"), GTK_STOCK_CLEAR);
gtk_box_pack_start(GTK_BOX(vbox_dl), button_clear_outs, FALSE, TRUE, 2);
g_signal_connect(G_OBJECT(button_clear_outs), "clicked", G_CALLBACK(clear_outs), NULL);
nb_outs = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(vbox_dr), nb_outs, TRUE, TRUE, 2);
scan_connections(out_L_port, store_out_L);
scan_connections(out_R_port, store_out_R);
tree_out_L = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store_out_L));
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(tree_out_L), FALSE);
tree_out_R = gtk_tree_view_new_with_model(GTK_TREE_MODEL(store_out_R));
gtk_tree_view_set_enable_search(GTK_TREE_VIEW(tree_out_R), FALSE);
renderer_out_L = gtk_cell_renderer_text_new();
renderer_out_R = gtk_cell_renderer_text_new();
column_out_L = gtk_tree_view_column_new_with_attributes(NULL, renderer_out_L, "text", 0, NULL);
column_out_R = gtk_tree_view_column_new_with_attributes(NULL, renderer_out_R, "text", 0, NULL);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_out_L), column_out_L);
gtk_tree_view_append_column(GTK_TREE_VIEW(tree_out_R), column_out_R);
g_signal_connect(G_OBJECT(column_out_L->button), "clicked", G_CALLBACK(clicked_out_L_header), NULL);
g_signal_connect(G_OBJECT(column_out_R->button), "clicked", G_CALLBACK(clicked_out_R_header), NULL);
gtk_widget_set_name(column_out_L->button, "nostyle");
gtk_widget_set_name(column_out_R->button, "nostyle");
select_out_L = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_out_L));
gtk_tree_selection_set_mode(select_out_L, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select_out_L), "changed", G_CALLBACK(tree_out_L_selection_changed), NULL);
select_out_R = gtk_tree_view_get_selection(GTK_TREE_VIEW(tree_out_R));
gtk_tree_selection_set_mode(select_out_R, GTK_SELECTION_SINGLE);
g_signal_connect(G_OBJECT(select_out_R), "changed", G_CALLBACK(tree_out_R_selection_changed), NULL);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(tree_out_L), TRUE);
gtk_tree_view_set_headers_clickable(GTK_TREE_VIEW(tree_out_R), TRUE);
viewp_out_L = gtk_viewport_new(NULL, NULL);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewp_out_L), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(viewp_out_L), tree_out_L);
gtk_widget_set_size_request(GTK_WIDGET(viewp_out_L), LIST_WIDTH, LIST_HEIGHT);
viewp_out_R = gtk_viewport_new(NULL, NULL);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewp_out_R), GTK_SHADOW_IN);
gtk_container_add(GTK_CONTAINER(viewp_out_R), tree_out_R);
gtk_widget_set_size_request(GTK_WIDGET(viewp_out_R), LIST_WIDTH, LIST_HEIGHT);
gtk_box_pack_start(GTK_BOX(vbox_dl), viewp_out_L, TRUE, TRUE, 2);
gtk_box_pack_start(GTK_BOX(vbox_dl), viewp_out_R, TRUE, TRUE, 2);
setup_notebook_out();
set_active(GTK_WIDGET(column_out_L->button), TRUE);
set_active(GTK_WIDGET(column_out_R->button), FALSE);
gtk_widget_show_all(ports_window);
gtk_widget_destroy(gtk_bin_get_child(GTK_BIN(column_out_L->button)));
gtk_widget_destroy(gtk_bin_get_child(GTK_BIN(column_out_R->button)));
hbox_L = gtk_hbox_new(FALSE, 0);
hbox_R = gtk_hbox_new(FALSE, 0);
label_L = gtk_label_new(_(" out L"));
label_R = gtk_label_new(_(" out R"));
gtk_container_add(GTK_CONTAINER(column_out_L->button), hbox_L);
gtk_container_add(GTK_CONTAINER(column_out_R->button), hbox_R);
gtk_box_pack_start(GTK_BOX(hbox_L), label_L, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox_R), label_R, FALSE, FALSE, 0);
gtk_widget_modify_fg(label_L, GTK_STATE_NORMAL, &color);
gtk_widget_modify_fg(label_L, GTK_STATE_PRELIGHT, &color);
gtk_widget_modify_fg(label_L, GTK_STATE_ACTIVE, &color);
gtk_widget_modify_fg(label_R, GTK_STATE_NORMAL, &color);
gtk_widget_modify_fg(label_R, GTK_STATE_PRELIGHT, &color);
gtk_widget_modify_fg(label_R, GTK_STATE_ACTIVE, &color);
gtk_widget_show_all(hbox_L);
gtk_widget_show_all(hbox_R);
}
static void midi_section_init(MidiSection* self)
{
MidiSectionPrivate* p = MIDI_SECTION_GET_PRIVATE(self);
GtkBox* box = GTK_BOX(self);
GtkWidget* pad;
GtkWidget* view;
GtkWidget* scroll;
GnomeCanvas* canvas;
GnomeCanvasPoints* points;
int x1, x2, y1, y2;
p->patch = -1;
p->ignore = FALSE;
x1 = 0;
y1 = 0;
x2 = (PHIN_KEYBOARD_KEY_WIDTH * MIDI_NOTES);
y2 = HEIGHT;
/* adjustment */
p->adj = (GtkAdjustment*) gtk_adjustment_new(0, 0, 0, 0, 0, 0);
/* viewport */
view = gtk_viewport_new(p->adj, NULL);
gtk_box_pack_start(box, view, FALSE, FALSE, 0);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(view), GTK_SHADOW_NONE);
gtk_widget_set_size_request(view, 0, y2);
gtk_widget_show(view);
/* canvas */
canvas = (GnomeCanvas*) gnome_canvas_new();
gtk_widget_set_size_request(GTK_WIDGET(canvas), x2, y2);
gnome_canvas_set_scroll_region(canvas, 0, 0, x2 - 1, y2 -1);
gtk_container_add(GTK_CONTAINER(view), GTK_WIDGET(canvas));
g_signal_connect(G_OBJECT(canvas), "event",
G_CALLBACK(range_cb), (gpointer)p);
gtk_widget_show(GTK_WIDGET(canvas));
/* range display backdrop */
gnome_canvas_item_new(gnome_canvas_root(canvas),
gnome_canvas_rect_get_type(),
"x1", (gdouble)0,
"y1", (gdouble)0,
"x2", (gdouble)x2,
"y2", (gdouble)y2,
"fill-color-rgba", BG_COLOR,
NULL);
/* range */
p->range = gnome_canvas_item_new(gnome_canvas_root(canvas),
gnome_canvas_rect_get_type(),
"x1", (gdouble)x1,
"y1", (gdouble)y1,
"x2", (gdouble)PHIN_KEYBOARD_KEY_WIDTH,
"y2", (gdouble)y2,
"fill-color-rgba", RANGE_COLOR,
"outline-color", "black",
NULL);
gnome_canvas_item_hide(p->range);
/* range root note */
p->note = gnome_canvas_item_new(gnome_canvas_root(canvas),
gnome_canvas_rect_get_type(),
"x1", (gdouble)x1,
"y1", (gdouble)y1,
"x2", (gdouble)PHIN_KEYBOARD_KEY_WIDTH,
"y2", (gdouble)y2,
"fill-color-rgba", NOTE_COLOR,
"outline-color", "black",
NULL);
gnome_canvas_item_hide(p->note);
p->canvas = canvas;
/* range display border */
points = gnome_canvas_points_new(4);
points->coords[0] = x1;
points->coords[1] = y2;
points->coords[2] = x1;
points->coords[3] = y1;
points->coords[4] = x2-1;
points->coords[5] = y1;
points->coords[6] = x2-1;
points->coords[7] = y2;
gnome_canvas_item_new(gnome_canvas_root(canvas),
gnome_canvas_line_get_type(),
"points", points,
"width-units", (gdouble)1,
"fill-color-rgba", 0,
NULL);
gnome_canvas_points_unref(points);
/* keyboard */
p->keyboard = phin_hkeyboard_new(p->adj, MIDI_NOTES, TRUE);
gtk_box_pack_start(box, p->keyboard, FALSE, FALSE, 0);
gtk_widget_show(p->keyboard);
/* vpad */
pad = gui_vpad_new(GUI_SCROLLSPACE);
gtk_box_pack_start(box, pad, FALSE, FALSE, 0);
gtk_widget_show(pad);
/* scrollbar */
scroll = gtk_hscrollbar_new(p->adj);
gtk_box_pack_start(box, scroll, FALSE, FALSE, 0);
gtk_widget_show(scroll);
/* done */
connect(p);
}
bg_nle_timeline_t * bg_nle_timeline_create(bg_nle_project_t * p)
{
GtkWidget * box;
// GtkWidget * table;
GtkSizeGroup * size_group;
// GtkWidget * table1;
GtkStyle *style;
GtkWidget * frame;
int i;
bg_nle_timeline_t * ret = calloc(1, sizeof(*ret));
// GtkObject *adj = gtk_adjustment_new( 0, 0, 100, 1, 10, 0 );
ret->p = p;
bg_nle_time_range_copy(&ret->tr.selection,
&p->selection);
bg_nle_time_range_copy(&ret->tr.visible,
&p->visible);
bg_nle_time_range_copy(&ret->tr.in_out,
&p->in_out);
ret->tr.cursor_pos = p->cursor_pos;
// ret->tr.set_visible = visibility_changed_callback;
// ret->tr.set_zoom = zoom_changed_callback;
// ret->tr.set_selection = selection_changed_callback;
// ret->tr.set_in_out = in_out_changed_callback;
ret->tr.motion_callback = timewidget_motion_callback;
ret->tr.motion_callback_data = ret;
ret->tr.ti = &ret->time_info;
ret->ruler = bg_nle_time_ruler_create(&ret->tr);
// ret->paned = gtk_hpaned_new();
ret->edit_insert =
create_pixmap_radio_button(ret, "gmerlerra/edit_insert.png",
TRS("Insert mode"), &ret->edit_insert_id,
&ret->edit_mode_group);
ret->edit_overwrite =
create_pixmap_radio_button(ret, "gmerlerra/edit_overwrite.png",
TRS("Overwrite mode"), &ret->edit_overwrite_id,
&ret->edit_mode_group);
ret->preview_window = gtk_viewport_new(NULL, NULL);
gtk_widget_set_events(ret->preview_window,
GDK_POINTER_MOTION_MASK|GDK_BUTTON_PRESS_MASK);
g_signal_connect(ret->preview_window,
"scroll-event",
G_CALLBACK(scroll_callback), ret);
g_signal_connect(ret->preview_window,
"motion-notify-event",
G_CALLBACK(motion_notify_callback), ret);
g_signal_connect(ret->preview_window,
"size-allocate", G_CALLBACK(size_allocate_callback),
ret);
ret->scrollbar =
gtk_vscrollbar_new(gtk_viewport_get_vadjustment(GTK_VIEWPORT(ret->preview_window)));
gtk_widget_show(ret->scrollbar);
// gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ret->preview_window),
// GTK_POLICY_NEVER, GTK_POLICY_NEVER);
ret->panel_window =
gtk_viewport_new(NULL, gtk_viewport_get_vadjustment(GTK_VIEWPORT(ret->preview_window)));
gtk_widget_set_events(ret->panel_window,
GDK_BUTTON_PRESS_MASK);
g_signal_connect(ret->panel_window,
"scroll-event",
G_CALLBACK(scroll_callback), ret);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(ret->preview_window),
GTK_SHADOW_NONE);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(ret->panel_window),
GTK_SHADOW_NONE);
gtk_widget_set_size_request(ret->panel_window, -1, 0);
gtk_widget_set_size_request(ret->preview_window, -1, 0);
// ret->panel_window =
// gtk_scrolled_window_new((GtkAdjustment *)0,
// GTK_ADJUSTMENT(adj));
// gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(ret->panel_window),
// GTK_POLICY_NEVER, GTK_POLICY_NEVER);
ret->preview_box = gtk_vbox_new(FALSE, 1);
ret->panel_box = gtk_vbox_new(FALSE, 1);
gtk_container_add(GTK_CONTAINER(ret->preview_window), ret->preview_box);
gtk_container_add(GTK_CONTAINER(ret->panel_window), ret->panel_box);
gtk_widget_show(ret->preview_box);
gtk_widget_show(ret->panel_box);
gtk_widget_show(ret->preview_window);
gtk_widget_show(ret->panel_window);
/* Pack */
box = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(box),
ret->edit_insert, FALSE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(box),
ret->edit_overwrite, FALSE, TRUE, 0);
gtk_widget_show(box);
size_group = gtk_size_group_new(GTK_SIZE_GROUP_VERTICAL);
gtk_size_group_add_widget(size_group, box);
gtk_size_group_add_widget(size_group, bg_nle_time_ruler_get_widget(ret->ruler));
g_object_unref(size_group);
ret->table = gtk_table_new(2, 3, 0);
/* Button box */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_OUT);
gtk_container_set_border_width(GTK_CONTAINER(frame), 0);
style = gtk_style_copy(frame->style);
style->xthickness = 1;
style->ythickness = 1;
gtk_widget_set_style(frame, style);
g_object_unref(style);
gtk_container_add(GTK_CONTAINER(frame), box);
gtk_widget_show(frame);
gtk_table_attach(GTK_TABLE(ret->table),
frame,
0, 1, 0, 1,
GTK_FILL|GTK_SHRINK, GTK_FILL|GTK_SHRINK, 0, 0);
/* Panel window */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_container_set_border_width(GTK_CONTAINER(frame), 0);
style = gtk_style_copy(frame->style);
style->xthickness = 1;
style->ythickness = 1;
gtk_widget_set_style(frame, style);
g_object_unref(style);
gtk_container_add(GTK_CONTAINER(frame), ret->panel_window);
gtk_widget_show(frame);
gtk_table_attach(GTK_TABLE(ret->table),
frame,
0, 1, 1, 2,
GTK_FILL|GTK_SHRINK, GTK_EXPAND|GTK_FILL, 0, 0);
// gtk_widget_show(table);
// gtk_paned_add1(GTK_PANED(ret->paned), table);
// table = gtk_table_new(2, 1, 0);
/* Time ruler */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_container_set_border_width(GTK_CONTAINER(frame), 0);
style = gtk_style_copy(frame->style);
style->xthickness = 1;
style->ythickness = 1;
gtk_widget_set_style(frame, style);
g_object_unref(style);
gtk_container_add(GTK_CONTAINER(frame), bg_nle_time_ruler_get_widget(ret->ruler));
gtk_widget_show(frame);
gtk_table_attach(GTK_TABLE(ret->table),
frame,
1, 2, 0, 1,
GTK_EXPAND|GTK_FILL, GTK_FILL|GTK_SHRINK, 0, 0);
/* Preview window */
frame = gtk_frame_new(NULL);
gtk_frame_set_shadow_type(GTK_FRAME(frame), GTK_SHADOW_IN);
gtk_container_set_border_width(GTK_CONTAINER(frame), 0);
style = gtk_style_copy(frame->style);
style->xthickness = 1;
style->ythickness = 1;
gtk_widget_set_style(frame, style);
g_object_unref(style);
gtk_container_add(GTK_CONTAINER(frame), ret->preview_window);
gtk_widget_show(frame);
gtk_table_attach(GTK_TABLE(ret->table),
frame,
1, 2, 1, 2,
GTK_EXPAND|GTK_FILL, GTK_EXPAND|GTK_FILL, 0, 0);
gtk_table_attach(GTK_TABLE(ret->table),
ret->scrollbar,
2, 3, 1, 2,
GTK_FILL|GTK_SHRINK, GTK_EXPAND|GTK_FILL, 0, 0);
gtk_widget_show(ret->table);
// gtk_paned_add2(GTK_PANED(ret->paned), table);
// gtk_widget_show(ret->paned);
/* Add tracks */
if(ret->p->num_tracks)
ret->tracks = calloc(ret->p->num_tracks, sizeof(*ret->tracks));
for(i = 0; i < ret->p->num_tracks; i++)
{
ret->tracks[ret->num_tracks] =
bg_nle_track_widget_create(ret->p->tracks[i], &ret->tr, ret->ruler);
gtk_box_pack_start(GTK_BOX(ret->panel_box),
bg_nle_track_widget_get_panel(ret->tracks[ret->num_tracks]),
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ret->preview_box),
bg_nle_track_widget_get_preview(ret->tracks[ret->num_tracks]),
FALSE, FALSE, 0);
ret->num_tracks++;
}
/* Add outstreams */
if(ret->p->num_outstreams)
{
ret->outstreams = calloc(ret->p->num_outstreams, sizeof(*ret->outstreams));
for(i = 0; i < ret->p->num_outstreams; i++)
{
ret->outstreams[ret->num_outstreams] =
bg_nle_outstream_widget_create(ret->p->outstreams[i], ret->ruler, &ret->tr);
gtk_box_pack_start(GTK_BOX(ret->panel_box),
bg_nle_outstream_widget_get_panel(ret->outstreams[ret->num_outstreams]),
FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(ret->preview_box),
bg_nle_outstream_widget_get_preview(ret->outstreams[ret->num_outstreams]),
FALSE, FALSE, 0);
ret->num_outstreams++;
}
}
/* Set radio buttons */
bg_nle_timeline_set_edit_mode(ret, ret->p->edit_mode);
return ret;
}
static GtkWidget *create_dialog(void)
{
GtkWidget *dialog;
GtkWidget *header_image;
GtkWidget *header_label;
GtkWidget *label_info;
GtkWidget *codename_label;
GtkWidget *builddate_label;
GtkWidget *url_button;
GtkWidget *cop_label;
GtkWidget *label;
GtkWidget *license_textview;
GtkWidget *notebook;
GtkWidget *box;
GtkWidget *credits_scrollwin;
GtkWidget *table;
GtkWidget *license_scrollwin;
GtkWidget *info_box;
GtkWidget *header_hbox;
GtkWidget *header_eventbox;
GdkPixbuf *icon;
GtkTextBuffer* tb;
gchar *license_text = NULL;
gchar buffer[512];
gchar buffer2[128];
guint i, row = 0;
dialog = gtk_dialog_new();
/* configure dialog */
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(main_widgets.window));
gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_CENTER_ON_PARENT);
gtk_window_set_title(GTK_WINDOW(dialog), _("About Geany"));
gtk_widget_set_name(dialog, "GeanyDialog");
gtk_dialog_add_button(GTK_DIALOG(dialog), GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_CLOSE);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
g_signal_connect(dialog, "key-press-event", G_CALLBACK(gb_on_key_pressed), NULL);
/* create header */
header_eventbox = gtk_event_box_new();
gtk_widget_show(header_eventbox);
header_hbox = gtk_hbox_new(FALSE, 12);
gtk_container_set_border_width(GTK_CONTAINER(header_hbox), 4);
gtk_widget_show(header_hbox);
gtk_container_add(GTK_CONTAINER(header_eventbox), header_hbox);
header_image = gtk_image_new();
gtk_box_pack_start(GTK_BOX(header_hbox), header_image, FALSE, FALSE, 0);
header_label = gtk_label_new(NULL);
gtk_label_set_use_markup(GTK_LABEL(header_label), TRUE);
/* print the subversion revision generated by ./configure if it is available */
g_snprintf(buffer, sizeof(buffer), HEADER, main_get_version_string());
gtk_label_set_markup(GTK_LABEL(header_label), buffer);
gtk_widget_show(header_label);
gtk_box_pack_start(GTK_BOX(header_hbox), header_label, FALSE, FALSE, 0);
header_eventbox_style_set(header_eventbox);
header_label_style_set(header_label);
g_signal_connect_after(header_eventbox, "style-set", G_CALLBACK(header_eventbox_style_set), NULL);
g_signal_connect_after(header_label, "style-set", G_CALLBACK(header_label_style_set), NULL);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), header_eventbox, FALSE, FALSE, 0);
/* set image */
icon = ui_new_pixbuf_from_inline(GEANY_IMAGE_LOGO);
gtk_image_set_from_pixbuf(GTK_IMAGE(header_image), icon);
gtk_window_set_icon(GTK_WINDOW(dialog), icon);
g_object_unref(icon); /* free our reference */
/* create notebook */
notebook = gtk_notebook_new();
gtk_widget_show(notebook);
gtk_container_set_border_width(GTK_CONTAINER(notebook), 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), notebook, TRUE, TRUE, 0);
/* create "Info" tab */
info_box = gtk_vbox_new(FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(info_box), 6);
gtk_widget_show(info_box);
label_info = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(label_info), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(label_info), TRUE);
gtk_label_set_use_markup(GTK_LABEL(label_info), TRUE);
g_snprintf(buffer, sizeof(buffer), INFO, _("A fast and lightweight IDE"));
gtk_label_set_markup(GTK_LABEL(label_info), buffer);
gtk_misc_set_padding(GTK_MISC(label_info), 2, 11);
gtk_widget_show(label_info);
gtk_box_pack_start(GTK_BOX(info_box), label_info, FALSE, FALSE, 0);
/* Codename label */
codename_label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(codename_label), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(codename_label), TRUE);
gtk_label_set_use_markup(GTK_LABEL(codename_label), TRUE);
gtk_label_set_markup(GTK_LABEL(codename_label), CODENAME);
gtk_misc_set_padding(GTK_MISC(codename_label), 2, 8);
gtk_widget_show(codename_label);
gtk_box_pack_start(GTK_BOX(info_box), codename_label, FALSE, FALSE, 0);
/* build date label */
builddate_label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(builddate_label), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(builddate_label), TRUE);
gtk_label_set_use_markup(GTK_LABEL(builddate_label), TRUE);
g_snprintf(buffer2, sizeof(buffer2), _("(built on or after %s)"), __DATE__);
g_snprintf(buffer, sizeof(buffer), BUILDDATE, buffer2);
gtk_label_set_markup(GTK_LABEL(builddate_label), buffer);
gtk_misc_set_padding(GTK_MISC(builddate_label), 2, 2);
gtk_widget_show(builddate_label);
gtk_box_pack_start(GTK_BOX(info_box), builddate_label, FALSE, FALSE, 0);
box = gtk_hbutton_box_new();
url_button = gtk_button_new();
gtk_button_set_relief(GTK_BUTTON(url_button), GTK_RELIEF_NONE);
g_signal_connect(url_button, "clicked", G_CALLBACK(homepage_clicked), (gpointer)GEANY_HOMEPAGE);
label = gtk_label_new(NULL);
gtk_label_set_text(GTK_LABEL(label), GEANY_HOMEPAGE);
gtk_widget_show(label);
gtk_container_add(GTK_CONTAINER(url_button), label);
gtk_widget_show(url_button);
gtk_box_pack_start(GTK_BOX(box), url_button, FALSE, FALSE, 0);
gtk_widget_show(box);
gtk_box_pack_start(GTK_BOX(info_box), box, FALSE, FALSE, 10);
/* copyright label */
cop_label = gtk_label_new(NULL);
gtk_label_set_justify(GTK_LABEL(cop_label), GTK_JUSTIFY_CENTER);
gtk_label_set_selectable(GTK_LABEL(cop_label), FALSE);
gtk_label_set_use_markup(GTK_LABEL(cop_label), TRUE);
gtk_label_set_markup(GTK_LABEL(cop_label), COPYRIGHT);
gtk_misc_set_padding(GTK_MISC(cop_label), 2, 10);
gtk_widget_show(cop_label);
gtk_box_pack_start(GTK_BOX(info_box), cop_label, FALSE, FALSE, 0);
/*gtk_container_add(GTK_CONTAINER(info_box), cop_label); */
label = gtk_label_new(_("Info"));
gtk_widget_show(label);
gtk_widget_show_all(info_box);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), info_box, label);
/* create "Credits" tab */
credits_scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(credits_scrollwin), 6);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(credits_scrollwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
table = gtk_table_new(23 + translators_len + prev_translators_len, 3, FALSE);
gtk_table_set_col_spacings(GTK_TABLE(table), 10);
row = 0;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Developers"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1, GTK_FILL, 0, 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Colomban Wendling - %s", _("maintainer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Nick Treleaven - %s", _("developer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Enrico Tröger - %s", _("developer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Matthew Brush - %s", _("developer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer), "Frank Lanitz - %s", _("translation maintainer"));
ROW(buffer, row, 0, 0, 0, 1);
row++;
ROW("<[email protected]>", row, 0, 0, 0, 1);
row++;
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Translators"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
for (i = 0; i < translators_len; i++)
{
ROW(translators[i][0], row, 0, 1, 4, 0);
ROW(translators[i][1], row, 1, 0, 4, 0);
row++;
}
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Previous Translators"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
for (i = 0; i < prev_translators_len; i++)
{
ROW(prev_translators[i][0], row, 0, 1, 4, 0);
ROW(prev_translators[i][1], row, 1, 0, 4, 0);
row++;
}
ROW("", row, 0, 0, 0, 0);
row++;
g_snprintf(buffer, sizeof(buffer),
"<span size=\"larger\" weight=\"bold\">%s</span>", _("Contributors"));
label = gtk_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
g_snprintf(buffer, sizeof(buffer),
_("Some of the many contributors (for a more detailed list, see the file %s):"),
#ifdef G_OS_WIN32
"Thanks.txt"
#else
"THANKS"
#endif
);
label = geany_wrap_label_new(buffer);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
label = geany_wrap_label_new(contributors);
gtk_table_attach(GTK_TABLE(table), label, 0, 2, row, row + 1,
(GtkAttachOptions) (GTK_FILL | GTK_EXPAND),
(GtkAttachOptions) (0), 0, 5);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
row++;
gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(credits_scrollwin), table);
gtk_viewport_set_shadow_type(GTK_VIEWPORT(gtk_widget_get_parent(table)), GTK_SHADOW_NONE);
gtk_widget_show_all(table);
label = gtk_label_new(_("Credits"));
gtk_widget_show(label);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), credits_scrollwin, label);
/* create "License" tab */
license_scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_container_set_border_width(GTK_CONTAINER(license_scrollwin), 6);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(license_scrollwin),
GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
gtk_scrolled_window_set_shadow_type(GTK_SCROLLED_WINDOW(license_scrollwin), GTK_SHADOW_IN);
license_textview = gtk_text_view_new();
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(license_textview), 2);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(license_textview), 2);
gtk_text_view_set_editable(GTK_TEXT_VIEW(license_textview), FALSE);
gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(license_textview), FALSE);
gtk_widget_show(license_textview);
gtk_container_add(GTK_CONTAINER(license_scrollwin), license_textview);
label = gtk_label_new(_("License"));
gtk_widget_show(label);
g_snprintf(buffer, sizeof(buffer), "%s" G_DIR_SEPARATOR_S "GPL-2", app->datadir);
g_file_get_contents(buffer, &license_text, NULL, NULL);
if (license_text == NULL)
{
license_text = g_strdup(
_("License text could not be found, please visit http://www.gnu.org/licenses/gpl-2.0.txt to view it online."));
}
tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(license_textview));
gtk_text_buffer_set_text(tb, license_text, -1);
g_free(license_text);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), license_scrollwin, label);
gtk_widget_show_all(dialog);
return dialog;
}
