GtkWidget *
picture_create_widget (GtkWidget * dlg)
{
GtkWidget *sw;
sw = gtk_scrolled_window_new (NULL, NULL);
gtk_scrolled_window_set_shadow_type (GTK_SCROLLED_WINDOW (sw), GTK_SHADOW_NONE);
gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (sw), options.hscroll_policy, options.vscroll_policy);
viewport = gtk_viewport_new (gtk_scrolled_window_get_hadjustment (GTK_SCROLLED_WINDOW (sw)),
gtk_scrolled_window_get_vadjustment (GTK_SCROLLED_WINDOW (sw)));
gtk_container_add (GTK_CONTAINER (sw), viewport);
picture = gtk_image_new ();
gtk_container_add (GTK_CONTAINER (viewport), picture);
/* load picture */
if (options.common_data.uri &&
g_file_test (options.common_data.uri, G_FILE_TEST_EXISTS))
load_picture (options.common_data.uri);
else
gtk_image_set_from_stock (GTK_IMAGE (picture), "gtk-missing-image", GTK_ICON_SIZE_DIALOG);
if (loaded && !animated)
{
create_popup_menu ();
g_signal_connect (G_OBJECT (viewport), "button-press-event", G_CALLBACK (button_handler), NULL);
g_signal_connect (G_OBJECT (viewport), "key-press-event", G_CALLBACK (key_handler), NULL);
}
return sw;
}
void
ags_scrolled_scale_box_init(AgsScrolledScaleBox *scrolled_scale_box)
{
scrolled_scale_box->margin_top = 0;
scrolled_scale_box->margin_bottom = 0;
scrolled_scale_box->margin_left = 0;
scrolled_scale_box->margin_right = 0;
/* viewport */
scrolled_scale_box->viewport = gtk_viewport_new(NULL,
NULL);
g_object_set(scrolled_scale_box->viewport,
"shadow-type", GTK_SHADOW_NONE,
NULL);
gtk_container_add((GtkContainer *) scrolled_scale_box,
(GtkWidget *) scrolled_scale_box->viewport);
/* scale box */
scrolled_scale_box->scale_box = NULL;
#if 0
scrolled_scale_box->scale_box = ags_vscale_box_new();
gtk_container_add((GtkContainer *) scrolled_scale_box->viewport,
(GtkWidget *) scrolled_scale_box->scale_box);
#endif
}
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;
}
/**** Viewport constructor ****/
int
clip_GTK_VIEWPORTNEW(ClipMachine * cm)
{
ClipVar * cv = _clip_spar(cm, 1);
C_widget * chadj = _fetch_cwidget(cm,_clip_spar(cm, 2));
C_widget * cvadj = _fetch_cwidget(cm,_clip_spar(cm, 3));
GtkWidget *wid = NULL;
C_widget *cwid;
GtkAdjustment *hadj, *vadj;
CHECKOPT(1,MAP_t);
CHECKOPT2(2,MAP_t,NUMERIC_t);
CHECKCWIDOPT(chadj,GTK_IS_ADJUSTMENT);
CHECKOPT2(3,MAP_t,NUMERIC_t);
CHECKCWIDOPT(cvadj,GTK_IS_ADJUSTMENT);
hadj = chadj ? GTK_ADJUSTMENT(chadj->widget) : NULL;
vadj = cvadj ? GTK_ADJUSTMENT(cvadj->widget) : NULL;
wid = gtk_viewport_new(hadj,vadj);
if (!wid) goto err;
cwid = _register_widget(cm, wid, cv);
_clip_mclone(cm,RETPTR(cm),&cwid->obj);
return 0;
err:
return 1;
}
/* 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 *scrolledflowwidgetgtk_new(
int (*init_proc)(FlowCtx *ctx, void *client_data),
void *client_data, GtkWidget **flowwidget)
{
FlowWidgetGtk *w;
GtkWidget *form = gtk_scrolled_window_new( NULL, NULL);
w = (FlowWidgetGtk *) g_object_new( FLOWWIDGETGTK_TYPE, NULL);
w->init_proc = init_proc;
w->flow_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;
*flowwidget = 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_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);
}
/* Helper function to add contacts label/edit widget pairs to a table,
* with respect for structured field edits.
*/
void
contacts_append_to_edit_table (GtkTable *table, GtkWidget *label,
GtkWidget *edit, gboolean do_focus)
{
guint rows, cols;
g_object_get (table, "n-rows", &rows, NULL);
g_object_get (table, "n-columns", &cols, NULL);
gtk_widget_show (label);
gtk_widget_show (edit);
if (contacts_get_structured_field (
gtk_widget_get_name (GTK_WIDGET (label)), 0)) {
GtkWidget *expander = gtk_expander_new (NULL);
GtkWidget *viewport = gtk_viewport_new (NULL, NULL);
gtk_expander_set_label_widget (GTK_EXPANDER (expander), label);
gtk_container_add (GTK_CONTAINER (viewport), edit);
gtk_widget_show (viewport);
gtk_container_add (GTK_CONTAINER (expander), viewport);
gtk_expander_set_expanded (GTK_EXPANDER (expander),
TRUE);
gtk_widget_show (expander);
gtk_widget_set_name (expander, gtk_widget_get_name (edit));
/* Highlight selected field */
if (do_focus) {
expander = contacts_edit_add_focus_events (
expander, NULL, NULL);
}
gtk_table_attach (table,
GTK_WIDGET (expander), 0, cols,
rows, rows+1, GTK_FILL | GTK_EXPAND,
GTK_FILL, 0, 0);
} else {
/* Hide the label when the entry is hidden */
g_signal_connect_swapped (G_OBJECT (edit), "hide",
G_CALLBACK (gtk_widget_hide),
label);
/* Highlight selected field */
if (do_focus) {
GList *l;
GtkWidget *box = gtk_event_box_new ();
gtk_container_add (GTK_CONTAINER (box), edit);
gtk_widget_set_name (box, gtk_widget_get_name (edit));
gtk_widget_show (box);
l = g_list_prepend (NULL, box);
label = contacts_edit_add_focus_events (
label, NULL, l);
g_list_free (l);
l = g_list_prepend (NULL, label);
edit = contacts_edit_add_focus_events (edit, box, l);
g_list_free (l);
}
gtk_table_attach (table, label,
0, 1, rows, rows+1, GTK_FILL, GTK_FILL, 0, 0);
gtk_table_attach (table, edit, 1, cols, rows, rows+1,
GTK_FILL | GTK_EXPAND, GTK_FILL, 0, 0);
}
}
/*
* Creates a new GtkWidget of class GtkViewport, performing any specialized
* initialization needed for the widget to work correctly in this environment.
* If a dialog box is used to initialize the widget, return NULL from this
* function, and call data->callback with your new widget when it is done.
* If the widget needs a special destroy handler, add a signal here.
*/
GtkWidget *
gb_viewport_new (GbWidgetNewData * data)
{
GtkWidget *new_widget = gtk_viewport_new (NULL, NULL);
if (data->action != GB_LOADING)
gtk_container_add (GTK_CONTAINER (new_widget), editor_new_placeholder ());
return new_widget;
}
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)++;
}
/*
* 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;
}
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);
}
int
main (int argc, char **argv)
{
GtkWidget *window;
GtkWidget *scrolled_window;
GtkWidget *viewport;
GtkWidget *grid;
GError *error = NULL;
int i;
GOptionContext *context = g_option_context_new (NULL);
g_option_context_add_main_entries (context, options, NULL);
frame_stats_add_options (g_option_context_get_main_group (context));
if (!g_option_context_parse (context, &argc, &argv, &error))
{
g_printerr ("Option parsing failed: %s\n", error->message);
return 1;
}
gtk_init ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
frame_stats_ensure (GTK_WINDOW (window));
gtk_window_set_default_size (GTK_WINDOW (window), 800, 600);
scrolled_window = gtk_scrolled_window_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (window), scrolled_window);
viewport = gtk_viewport_new (NULL, NULL);
gtk_container_add (GTK_CONTAINER (scrolled_window), viewport);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (viewport), grid);
for (i = 0; i < 4; i++)
{
GtkWidget *content = create_widget_factory_content ();
gtk_grid_attach (GTK_GRID (grid), content,
i % 2, i / 2, 1, 1);
g_object_unref (content);
}
gtk_widget_add_tick_callback (viewport,
scroll_viewport,
NULL,
NULL);
gtk_widget_show (window);
g_signal_connect (window, "destroy",
G_CALLBACK (gtk_main_quit), NULL);
gtk_main ();
return 0;
}
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 GtkWidget *desktop_create()
{
GtkWidget *desktop = gtk_window_new(GTK_WINDOW_TOPLEVEL);
GtkWidget *fixed_pos_viewport = gtk_viewport_new(NULL,NULL);
GtkWidget *fixed_pos = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(fixed_pos_viewport),fixed_pos);
gtk_container_add(GTK_CONTAINER(desktop),fixed_pos_viewport);
g_signal_connect(G_OBJECT(desktop),"delete-event",G_CALLBACK(desktop_destroy),NULL);
g_signal_connect(G_OBJECT(desktop),"key-press-event",G_CALLBACK(desktop_keypress),NULL);
gtk_window_maximize(GTK_WINDOW(desktop));
gtk_window_fullscreen(GTK_WINDOW(desktop));
return desktop;
}
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 whiteb_show(struct question *data)
{
/* Reset question picture stored in whiteb_image */
whiteb_image = NULL;
/* Layout */
GtkWidget *window;
GtkWidget *table, *tool_table, *viewport, *header, *colour_table;
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_title(GTK_WINDOW(window),"PowerMaths Whiteboard");
gtk_window_fullscreen(GTK_WINDOW(window));
viewport = gtk_viewport_new(NULL,NULL);
table = gtk_table_new(3,8,0);
white_board = gtk_drawing_area_new();
gtk_widget_set_size_request(white_board,768,576);
draw_init_canvas(white_board);
gtk_widget_add_events(white_board,GDK_BUTTON_PRESS_MASK|GDK_BUTTON_RELEASE_MASK|GDK_POINTER_MOTION_MASK|GDK_BUTTON_MOTION_MASK|GDK_LEAVE_NOTIFY_MASK);
gtk_container_add(GTK_CONTAINER(viewport),white_board);
tool_table = tool_box_create();
colour_table = colour_box_create();
/* Pack */
gtk_container_add(GTK_CONTAINER(window),table);
header = misc_create_banner(data->caption,50);
gtk_widget_set_size_request(header,0,60);
gtk_table_attach(GTK_TABLE(table),header,0,3,0,1,GTK_FILL|GTK_EXPAND,GTK_FILL,0,0);
gtk_table_attach(GTK_TABLE(table),viewport,0,1,1,7,GTK_FILL|GTK_EXPAND,GTK_FILL|GTK_EXPAND,0,0);
gtk_table_attach(GTK_TABLE(table),tool_table,1,2,1,7,0,GTK_FILL,0,0);
gtk_table_attach(GTK_TABLE(table),colour_table,0,2,7,8,GTK_FILL,0,0,0);
/* Hook up callbacks */
g_signal_connect(G_OBJECT(window),"delete-event",G_CALLBACK(whiteb_window_delete),NULL);
g_signal_connect(G_OBJECT(white_board),"button-press-event",G_CALLBACK(whiteb_board_press),NULL);
g_signal_connect(G_OBJECT(white_board),"motion-notify-event",G_CALLBACK(whiteb_board_motion),NULL);
g_signal_connect(G_OBJECT(white_board),"leave-notify-event",G_CALLBACK(whiteb_board_leave),NULL);
g_signal_connect(G_OBJECT(white_board),"button-release-event",G_CALLBACK(whiteb_board_release),NULL);
g_signal_connect(G_OBJECT(white_board),"expose-event",G_CALLBACK(whiteb_expose_event),data);
gtk_widget_show_all(window);
}
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
scrolling (void)
{
GtkWidget *window;
GtkWidget *sw;
GtkWidget *viewport;
GtkWidget *grid;
GtkWidget *child;
gint i;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Scrolling");
sw = gtk_scrolled_window_new (NULL, NULL);
viewport = gtk_viewport_new (NULL, NULL);
grid = gtk_grid_new ();
gtk_container_add (GTK_CONTAINER (window), sw);
gtk_container_add (GTK_CONTAINER (sw), viewport);
gtk_container_add (GTK_CONTAINER (viewport), grid);
child = oriented_test_widget ("#800080", "#800080", -45.0);
gtk_grid_attach (GTK_GRID (grid), child, 0, 0, 1, 1);
gtk_widget_set_hexpand (child, TRUE);
gtk_widget_set_vexpand (child, TRUE);
for (i = 1; i < 16; i++)
{
gchar *color;
color = g_strdup_printf ("#%02x00%02x", 128 + 8*i, 128 - 8*i);
child = test_widget (color, color);
gtk_grid_attach (GTK_GRID (grid), child, 0, i, i + 1, 1);
gtk_widget_set_hexpand (child, TRUE);
g_free (color);
}
for (i = 1; i < 16; i++)
{
gchar *color;
color = g_strdup_printf ("#%02x00%02x", 128 - 8*i, 128 + 8*i);
child = oriented_test_widget (color, color, -90.0);
gtk_grid_attach (GTK_GRID (grid), child, i, 0, 1, i);
gtk_widget_set_vexpand (child, TRUE);
g_free (color);
}
gtk_widget_show_all (window);
}
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);
}
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 void
status_display_clicked (gpointer data)
{
GtkWidget *dialog;
GtkWidget *scrollwin;
GtkWidget *viewport;
GtkWidget *textview;
GtkTextBuffer *buffer;
dialog = gtk_dialog_new_with_buttons("Status",
NULL,
GTK_DIALOG_MODAL,
"OK",
GTK_RESPONSE_ACCEPT,
NULL);
scrollwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrollwin),
GTK_POLICY_AUTOMATIC,
GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), scrollwin, TRUE, TRUE, 0);
gtk_widget_show(scrollwin);
viewport = gtk_viewport_new(NULL, NULL);
gtk_widget_show(viewport);
gtk_container_add(GTK_CONTAINER(scrollwin), viewport);
textview = gtk_text_view_new();
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_set_text(buffer, statusstr->str, -1);
gtk_container_add(GTK_CONTAINER(viewport), textview);
gtk_widget_show(textview);
gtk_widget_set_size_request(GTK_WIDGET(dialog),
DIALOG_WIDTH, DIALOG_HEIGHT);
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
GtkWidget* create_gtkdemo_display_drawingarea (GtkWidget *window)
{
GtkWidget * drawingarea;
GtkWidget *Display_box;
GtkWidget *scrolledwindow;
GtkWidget *viewport;
Display_box = GTK_WIDGET(gtk_builder_get_object(Demo_builder, "Display_box"));
scrolledwindow = gtk_scrolled_window_new (NULL, NULL);
gtk_widget_show (scrolledwindow);
gtk_box_pack_start (GTK_BOX (Display_box), scrolledwindow, TRUE, TRUE, 0);
viewport = gtk_viewport_new (NULL, NULL);
gtk_widget_show (viewport);
gtk_container_add (GTK_CONTAINER (scrolledwindow), viewport);
gtk_container_set_border_width (GTK_CONTAINER (viewport), 2);
drawingarea = gtk_drawing_area_new ();
gtk_widget_show (drawingarea);
gtk_container_add (GTK_CONTAINER (viewport), drawingarea);
gtk_widget_set_size_request (drawingarea,DISPLAY_WIDTH,DISPLAY_HEIGHT);
gtk_widget_show(drawingarea);
g_signal_connect( G_OBJECT( drawingarea ), "expose_event",G_CALLBACK( preview_display ), NULL );
GLADE_HOOKUP_OBJECT (window, drawingarea, "display_drawingarea");
//显示画板大小
g_W_H_INFO.display_width=DISPLAY_WIDTH;
g_W_H_INFO.display_height=DISPLAY_HEIGHT;
return drawingarea;
}
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 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);
}
XAttOneGtk::XAttOneGtk(GtkWidget* xa_parent_wid, void* xa_parent_ctx,
pwr_sAttrRef* xa_aref, char* xa_title, unsigned int xa_priv, int* xa_sts)
: XAttOne(xa_parent_ctx, xa_aref, xa_title, xa_priv, xa_sts),
parent_wid(xa_parent_wid)
{
pwr_tAName title;
*xa_sts = gdh_AttrrefToName(&aref, title, sizeof(title), cdh_mNName);
if (EVEN(*xa_sts))
return;
toplevel = (GtkWidget*)g_object_new(GTK_TYPE_WINDOW, "default-height", 200,
"default-width", 500, "title", CoWowGtk::convert_utf8(title), NULL);
g_signal_connect(toplevel, "delete_event", G_CALLBACK(delete_event), this);
g_signal_connect(toplevel, "destroy", G_CALLBACK(destroy_event), this);
g_signal_connect(
toplevel, "focus-in-event", G_CALLBACK(action_inputfocus), this);
CoWowGtk::SetWindowIcon(toplevel);
// Menu
// Accelerators
GtkAccelGroup* accel_g
= (GtkAccelGroup*)g_object_new(GTK_TYPE_ACCEL_GROUP, NULL);
gtk_window_add_accel_group(GTK_WINDOW(toplevel), accel_g);
GtkMenuBar* menu_bar = (GtkMenuBar*)g_object_new(GTK_TYPE_MENU_BAR, NULL);
// File entry
GtkWidget* file_close
= gtk_image_menu_item_new_from_stock(GTK_STOCK_CLOSE, accel_g);
g_signal_connect(file_close, "activate", G_CALLBACK(activate_exit), this);
GtkMenu* file_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), file_close);
GtkWidget* file = gtk_menu_item_new_with_mnemonic("_File");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), GTK_WIDGET(file_menu));
// Help entry
GtkWidget* help_help
= gtk_image_menu_item_new_from_stock(GTK_STOCK_HELP, accel_g);
g_signal_connect(help_help, "activate", G_CALLBACK(activate_help), this);
GtkMenu* help_menu = (GtkMenu*)g_object_new(GTK_TYPE_MENU, NULL);
gtk_menu_shell_append(GTK_MENU_SHELL(help_menu), help_help);
GtkWidget* help = gtk_menu_item_new_with_mnemonic("_Help");
gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), help);
gtk_menu_item_set_submenu(GTK_MENU_ITEM(help), GTK_WIDGET(help_menu));
// Prompt, label, input entry
msg_label = gtk_label_new("");
gtk_widget_set_size_request(msg_label, -1, 25);
cmd_prompt = gtk_label_new("value > ");
gtk_widget_set_size_request(cmd_prompt, -1, 25);
cmd_label = gtk_label_new("");
gtk_widget_set_size_request(cmd_label, -1, 25);
gtk_misc_set_alignment(GTK_MISC(cmd_label), 0.0, 0.5);
cmd_entry = new CoWowEntryGtk(&value_recall);
cmd_input = cmd_entry->widget();
gtk_widget_set_size_request(cmd_input, -1, 25);
g_signal_connect(cmd_input, "activate", G_CALLBACK(activate_cmd_input), this);
// Scrolled text input
cmd_scrolled_buffer = gtk_text_buffer_new(NULL);
cmd_scrolledtextview = gtk_text_view_new_with_buffer(cmd_scrolled_buffer);
GtkWidget* viewport = gtk_viewport_new(NULL, NULL);
GtkWidget* scrolledwindow = gtk_scrolled_window_new(NULL, NULL);
gtk_container_add(GTK_CONTAINER(viewport), cmd_scrolledtextview);
gtk_container_add(GTK_CONTAINER(scrolledwindow), viewport);
cmd_scrolledinput = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(cmd_scrolledinput), scrolledwindow, TRUE, TRUE, 0);
// Buttons
cmd_scrolled_ok = gtk_button_new_with_label(CoWowGtk::translate_utf8("Ok"));
gtk_widget_set_size_request(cmd_scrolled_ok, 70, 25);
g_signal_connect(
cmd_scrolled_ok, "clicked", G_CALLBACK(activate_cmd_scrolled_ok), this);
cmd_scrolled_ap
= gtk_button_new_with_label(CoWowGtk::translate_utf8("Apply"));
gtk_widget_set_size_request(cmd_scrolled_ap, 70, 25);
g_signal_connect(
cmd_scrolled_ap, "clicked", G_CALLBACK(activate_cmd_scrolled_ap), this);
cmd_scrolled_ca
= gtk_button_new_with_label(CoWowGtk::translate_utf8("Cancel"));
gtk_widget_set_size_request(cmd_scrolled_ca, 70, 25);
g_signal_connect(
cmd_scrolled_ca, "clicked", G_CALLBACK(activate_cmd_scrolled_ca), this);
GtkWidget* hboxbuttons = gtk_hbox_new(TRUE, 40);
gtk_box_pack_start(GTK_BOX(hboxbuttons), cmd_scrolled_ok, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(hboxbuttons), cmd_scrolled_ap, FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(hboxbuttons), cmd_scrolled_ca, FALSE, FALSE, 0);
// Horizontal box
GtkWidget* statusbar = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(statusbar), msg_label, FALSE, FALSE, 15);
gtk_box_pack_start(GTK_BOX(statusbar), cmd_prompt, FALSE, FALSE, 15);
gtk_box_pack_start(GTK_BOX(statusbar), cmd_label, TRUE, TRUE, 15);
gtk_box_pack_start(GTK_BOX(statusbar), cmd_input, TRUE, TRUE, 15);
gtk_box_pack_start(GTK_BOX(statusbar), cmd_scrolledinput, TRUE, TRUE, 15);
GtkWidget* vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(menu_bar), FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(statusbar), TRUE, TRUE, 0);
gtk_box_pack_start(
GTK_BOX(vbox), GTK_WIDGET(gtk_hseparator_new()), FALSE, FALSE, 0);
gtk_box_pack_end(GTK_BOX(vbox), hboxbuttons, FALSE, FALSE, 5);
gtk_container_add(GTK_CONTAINER(toplevel), vbox);
gtk_widget_show_all(toplevel);
if (priv & pwr_mPrv_RtWrite || priv & pwr_mPrv_System)
access_rw = 1;
else
access_rw = 0;
if (access_rw)
g_object_set(cmd_label, "visible", FALSE, NULL);
else {
g_object_set(cmd_input, "visible", FALSE, NULL);
g_object_set(cmd_scrolledinput, "visible", FALSE, NULL);
g_object_set(cmd_scrolled_ok, "visible", FALSE, NULL);
g_object_set(cmd_scrolled_ap, "visible", FALSE, NULL);
}
change_value(1);
*xa_sts = XATT__SUCCESS;
}
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);
}
