/*create a new t_disk_display from t_disk infos */
static t_disk_display * disk_display_new(t_disk * disk, t_mounter * mounter)
{
if (disk != NULL)
{
t_disk_display * dd ;
dd = g_new0(t_disk_display,1) ;
dd->menu_item = gtk_menu_item_new();
g_signal_connect(G_OBJECT(dd->menu_item),"activate",G_CALLBACK(on_activate_disk_display),disk);
g_object_set_data(G_OBJECT(dd->menu_item),"mounter",(gpointer)mounter);
dd->hbox = gtk_hbox_new(FALSE,10);
gtk_container_add(GTK_CONTAINER(dd->menu_item), dd->hbox);
dd->label_disk = gtk_label_new(g_strconcat(disk->device," -> ",disk->mount_point,NULL));
/*change to uniform label size*/
gtk_label_set_width_chars(GTK_LABEL(dd->label_disk),28);
gtk_label_set_justify(GTK_LABEL(dd->label_disk),GTK_JUSTIFY_LEFT);
gtk_box_pack_start(GTK_BOX(dd->hbox),dd->label_disk,FALSE,TRUE,0);
dd->label_mount_info = gtk_label_new("");
/*change to uniform label size*/
gtk_label_set_width_chars(GTK_LABEL(dd->label_mount_info),25);
gtk_label_set_use_markup(GTK_LABEL(dd->label_mount_info),TRUE);
gtk_label_set_justify(GTK_LABEL(dd->label_mount_info),GTK_JUSTIFY_RIGHT);
gtk_box_pack_start(GTK_BOX(dd->hbox),dd->label_mount_info,TRUE,TRUE,0);
dd->progress_bar = gtk_progress_bar_new();
gtk_box_pack_start(GTK_BOX(dd->hbox),dd->progress_bar,TRUE,TRUE,0);
return dd ;
}
return NULL ;
}
void resize_title(WindowckPlugin *wckp)
{
switch (wckp->prefs->size_mode)
{
case SHRINK:
gtk_label_set_max_width_chars(wckp->title, wckp->prefs->title_size);
break;
case EXPAND:
gtk_label_set_width_chars(wckp->title, TITLE_SIZE_MAX);
break;
default:
gtk_label_set_width_chars(wckp->title, wckp->prefs->title_size);
}
}
static void
gimp_perspective_tool_dialog (GimpTransformTool *tr_tool)
{
GimpPerspectiveTool *perspective = GIMP_PERSPECTIVE_TOOL (tr_tool);
GtkWidget *frame;
GtkWidget *table;
gint x, y;
frame = gimp_frame_new (_("Transformation Matrix"));
gtk_box_pack_start (GTK_BOX (gimp_tool_gui_get_vbox (tr_tool->gui)), frame,
FALSE, FALSE, 0);
gtk_widget_show (frame);
table = gtk_table_new (3, 3, FALSE);
gtk_table_set_row_spacings (GTK_TABLE (table), 2);
gtk_table_set_col_spacings (GTK_TABLE (table), 2);
gtk_container_add (GTK_CONTAINER (frame), table);
gtk_widget_show (table);
for (y = 0; y < 3; y++)
for (x = 0; x < 3; x++)
{
GtkWidget *label = gtk_label_new (" ");
gtk_label_set_xalign (GTK_LABEL (label), 1.0);
gtk_label_set_width_chars (GTK_LABEL (label), 12);
gtk_table_attach (GTK_TABLE (table), label,
x, x + 1, y, y + 1, GTK_EXPAND, GTK_FILL, 0, 0);
gtk_widget_show (label);
perspective->label[y][x] = label;
}
}
GtkWidget *init_psk() {
int i;
psk_index=0;
detector=createPSKDet(8000);
if(detector==NULL) {
fprintf(stderr,"init_psk: createPSKDet return null!\n");
return NULL;
}
SetRXFrequency(detector,1500);
ResetDetector(detector);
for(i=0;i<TEXT_LINES;i++) {
text_label[i][0]='\0';
}
build_temp_text();
psk_label=gtk_label_new(temp_text);
gtk_label_set_single_line_mode (GTK_LABEL(psk_label), FALSE);
gtk_label_set_width_chars (GTK_LABEL(psk_label), 80);
gtk_label_set_lines (GTK_LABEL(psk_label), TEXT_LINES);
gtk_label_set_line_wrap (GTK_LABEL(psk_label), TRUE);
gtk_misc_set_alignment (GTK_MISC(psk_label), 0, 0);
//gtk_widget_set_halign(psk_label,GTK_ALIGN_START);
//gtk_widget_set_valign(psk_label,GTK_ALIGN_START);
return psk_label;
}
G_REMINDER_VISIBLE GtkWidget *
g_reminder_row_new (GReminderItem *item)
{
g_return_val_if_fail (G_REMINDER_IS_ITEM (item), NULL);
static const gchar *blacklist = " \t\n\r";
G_REMINDER_CLEANUP_FREE gchar *txt = g_strdup (g_reminder_item_get_contents (item));
for (gchar *c = txt; *c; ++c)
{
for (const gchar *b = blacklist; *b; ++b)
{
if (*c == *b)
*c = ' ';
}
}
GtkWidget *self = gtk_widget_new (G_REMINDER_TYPE_ROW, NULL);
GReminderRowPrivate *priv = g_reminder_row_get_instance_private (G_REMINDER_ROW (self));
priv->item = g_object_ref (item);
GtkWidget *label = gtk_label_new (txt);
GtkLabel *l = GTK_LABEL (label);
gtk_label_set_line_wrap (l, TRUE);
gtk_label_set_width_chars (l, 80);
gtk_label_set_max_width_chars (l, 80);
gtk_label_set_ellipsize (l, PANGO_ELLIPSIZE_END);
gtk_container_add (GTK_CONTAINER (self), label);
return self;
}
GtkWidget *dive_info_frame(void)
{
GtkWidget *frame;
GtkWidget *hbox, *hbox2;
GtkWidget *vbox;
frame = gtk_frame_new("Dive info");
gtk_widget_show(frame);
vbox = gtk_vbox_new(TRUE, 6);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 3);
gtk_container_add(GTK_CONTAINER(frame), vbox);
hbox = gtk_hbox_new(TRUE, 6);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 3);
gtk_container_add(GTK_CONTAINER(vbox), hbox);
hbox2 = gtk_hbox_new(FALSE, 6);
gtk_container_set_border_width(GTK_CONTAINER(hbox2), 3);
gtk_container_add(GTK_CONTAINER(vbox), hbox2);
divedate = info_label(hbox, "date", GTK_JUSTIFY_RIGHT);
divetime = info_label(hbox, "time", GTK_JUSTIFY_RIGHT);
depth = info_label(hbox, "depth", GTK_JUSTIFY_RIGHT);
duration = info_label(hbox, "duration", GTK_JUSTIFY_RIGHT);
temperature = info_label(hbox, "temperature", GTK_JUSTIFY_RIGHT);
locationnote = info_label(hbox2, "location", GTK_JUSTIFY_LEFT);
gtk_label_set_width_chars(GTK_LABEL(locationnote), 80);
return frame;
}
static void
populate_flowbox_wrappy (GtkFlowBox *flowbox)
{
GtkWidget *widget, *frame;
gint i;
const gchar *strings[] = {
"These are", "some wrappy label", "texts", "of various", "lengths.",
"They should always be", "shown", "consecutively. Except it's",
"hard to say", "where exactly the", "label", "will wrap", "and where exactly",
"the actual", "container", "will wrap.", "This label is really really really long !",
"Let's add some more", "labels to the",
"mix. Just to", "make sure we", "got something to work", "with here."
};
for (i = 0; i < G_N_ELEMENTS (strings); i++)
{
widget = gtk_label_new (strings[i]);
frame = gtk_frame_new (NULL);
gtk_widget_show (widget);
gtk_widget_show (frame);
if (text_orientation == GTK_ORIENTATION_VERTICAL)
gtk_label_set_angle (GTK_LABEL (widget), 90);
gtk_container_add (GTK_CONTAINER (frame), widget);
gtk_label_set_line_wrap (GTK_LABEL (widget), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (widget), PANGO_WRAP_WORD);
gtk_label_set_width_chars (GTK_LABEL (widget), 10);
g_object_set_data_full (G_OBJECT (frame), "id", (gpointer)g_strdup (strings[i]), g_free);
gtk_container_add (GTK_CONTAINER (flowbox), frame);
}
}
void GtkLabel_::set_width_chars(Php::Parameters ¶meters)
{
gint n_chars = (gint)parameters[0];
gtk_label_set_width_chars (GTK_LABEL(instance), n_chars);
}
static gint
luaH_label_set_width(lua_State *L)
{
widget_t *w = luaH_checkwidget(L, 1);
gint len = luaL_checknumber(L, 2);
gtk_label_set_width_chars(GTK_LABEL(w->widget), len);
return 0;
}
void xmonadlog_applet_size_change(GConfClient *client,
guint cnxn_id,
GConfEntry *entry,
gpointer user_data) {
gint width = gconf_client_get_int (client,
"/apps/xmonad-log-applet/width-chars",
NULL);
gtk_label_set_width_chars(GTK_LABEL(user_data), width);
}
static gint
luaH_label_newindex(lua_State *L, widget_t *w, luakit_token_t token)
{
size_t len;
const gchar *tmp;
GdkColor c;
PangoFontDescription *font;
switch(token) {
LUAKIT_WIDGET_NEWINDEX_COMMON(w)
case L_TK_PADDING:
return luaH_label_set_padding(L, w);
case L_TK_ALIGN:
return luaH_label_set_align(L, w);
case L_TK_TEXT:
gtk_label_set_markup(GTK_LABEL(w->widget),
luaL_checklstring(L, 3, &len));
break;
case L_TK_FG:
tmp = luaL_checklstring(L, 3, &len);
if (!gdk_color_parse(tmp, &c)) {
warn("invalid color: %s", tmp);
return 0;
}
gtk_widget_modify_fg(GTK_WIDGET(w->widget), GTK_STATE_NORMAL, &c);
g_object_set_data_full(G_OBJECT(w->widget), "fg", g_strdup(tmp), g_free);
break;
case L_TK_FONT:
tmp = luaL_checklstring(L, 3, &len);
font = pango_font_description_from_string(tmp);
gtk_widget_modify_font(GTK_WIDGET(w->widget), font);
pango_font_description_free(font);
g_object_set_data_full(G_OBJECT(w->widget), "font", g_strdup(tmp), g_free);
break;
case L_TK_SELECTABLE:
gtk_label_set_selectable(GTK_LABEL(w->widget), luaH_checkboolean(L, 3));
break;
case L_TK_WIDTH:
gtk_label_set_width_chars(GTK_LABEL(w->widget),
(gint)luaL_checknumber(L, 3));
return 0;
default:
warn("unknown property: %s", luaL_checkstring(L, 2));
return 0;
}
return luaH_object_property_signal(L, 1, token);
}
void set_page_width(struct Window *win_data, struct Page *page_data)
{
#ifdef DETAIL
g_debug("! Launch set_page_width() with win_data = %p, page_data = %p", win_data, page_data);
#endif
#ifdef SAFEMODE
if ((win_data==NULL) || (page_data==NULL) || (page_data->label_text==NULL)) return;
#endif
gtk_label_set_width_chars(GTK_LABEL(page_data->label_text), win_data->page_width);
}
static void windowck_screen_position_changed(XfcePanelPlugin *plugin, XfceScreenPosition *position, WindowckPlugin *wckp)
{
if (wckp->prefs->size_mode != SHRINK)
{
xfce_panel_plugin_set_shrink (plugin, FALSE);
gtk_label_set_width_chars(wckp->title, 1);
xfce_panel_plugin_set_shrink (plugin, TRUE);
resize_title(wckp);
}
}
static void
text_grid (void)
{
GtkWidget *window;
GtkWidget *grid;
GtkWidget *paned1;
GtkWidget *box;
GtkWidget *label;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_title (GTK_WINDOW (window), "Height-for-Width");
paned1 = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
gtk_container_add (GTK_CONTAINER (window), paned1);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_paned_pack1 (GTK_PANED (paned1), box, TRUE, FALSE);
gtk_paned_pack2 (GTK_PANED (paned1), gtk_label_new ("Space"), TRUE, FALSE);
grid = gtk_grid_new ();
gtk_orientable_set_orientation (GTK_ORIENTABLE (grid), GTK_ORIENTATION_VERTICAL);
gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("Above"));
gtk_container_add (GTK_CONTAINER (box), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
gtk_container_add (GTK_CONTAINER (box), grid);
gtk_container_add (GTK_CONTAINER (box), gtk_separator_new (GTK_ORIENTATION_HORIZONTAL));
gtk_container_add (GTK_CONTAINER (box), gtk_label_new ("Below"));
label = gtk_label_new ("Some text that may wrap if it has to");
gtk_label_set_width_chars (GTK_LABEL (label), 10);
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_grid_attach (GTK_GRID (grid), label, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), test_widget ("1", "red"), 1, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), test_widget ("2", "blue"), 0, 1, 1, 1);
label = gtk_label_new ("Some text that may wrap if it has to");
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_END);
gtk_label_set_width_chars (GTK_LABEL (label), 10);
gtk_grid_attach (GTK_GRID (grid), label, 1, 1, 1, 1);
gtk_widget_show_all (window);
}
static GtkWidget *
track_info_label_new ()
{
GtkWidget *label;
label = gtk_label_new (NULL);
gtk_label_set_width_chars (GTK_LABEL (label), 25);
gtk_label_set_max_width_chars (GTK_LABEL (label), 25);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_widget_set_halign (label, GTK_ALIGN_START);
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE);
return label;
}
int
clip_GTK_LABELSETWIDTHCHARS(ClipMachine * cm)
{
C_widget *clbl = _fetch_cw_arg(cm);
gint width = _clip_parni(cm, 2);
CHECKCWID(clbl,GTK_IS_LABEL);
CHECKARG(2, NUMERIC_t);
gtk_label_set_width_chars(GTK_LABEL(clbl->widget), width);
return 0;
err:
return 1;
}
LifereaHtmlView *
browser_tabs_add_new (const gchar *url, const gchar *title, gboolean activate)
{
GtkWidget *close_button, *labelBox;
tabInfo *tab;
int i;
tab = g_new0 (tabInfo, 1);
tab->htmlview = liferea_htmlview_new (TRUE /* internal browsing */);
tab->widget = liferea_htmlview_get_widget (tab->htmlview);
tabs->priv->list = g_slist_append (tabs->priv->list, tab);
g_object_set_data (G_OBJECT (tab->widget), "tabInfo", tab);
g_signal_connect (tab->htmlview, "title-changed", G_CALLBACK (on_htmlview_title_changed), tab);
g_signal_connect (tab->htmlview, "statusbar-changed", G_CALLBACK (on_htmlview_status_message), NULL);
/* create tab widgets */
tab->label = gtk_label_new (create_label_text (title));
gtk_label_set_ellipsize (GTK_LABEL (tab->label), PANGO_ELLIPSIZE_END);
gtk_label_set_width_chars (GTK_LABEL (tab->label), 17);
labelBox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 4);
gtk_box_pack_start (GTK_BOX (labelBox), tab->label, FALSE, FALSE, 0);
close_button = gedit_close_button_new ();
gtk_box_pack_end (GTK_BOX (labelBox), close_button, FALSE, FALSE, 0);
g_signal_connect ((gpointer)close_button, "clicked", G_CALLBACK (on_htmlview_close_tab), (gpointer)tab);
gtk_widget_show_all (labelBox);
i = gtk_notebook_append_page (tabs->priv->notebook, tab->widget, labelBox);
g_signal_connect (gtk_notebook_get_nth_page (tabs->priv->notebook, i),
"key-press-event", G_CALLBACK (on_tab_key_press), (gpointer)tab);
gtk_notebook_set_show_tabs (tabs->priv->notebook, TRUE);
gtk_notebook_set_tab_reorderable (tabs->priv->notebook, tab->widget, TRUE);
if (activate && (i != -1))
gtk_notebook_set_current_page (tabs->priv->notebook, i);
if (url)
liferea_htmlview_launch_URL_internal (tab->htmlview, (gchar *)url);
return tab->htmlview;
}
/* Helper for construct_data_widget. Returns the label widget. */
static GtkLabel *
add_table_row (GtkWidget *table, int *rowidx,
const char *labelstr, GtkWidget *widget, GtkWidget *widget2,
int readonly)
{
GtkWidget *label;
int is_label = GTK_IS_LABEL (widget);
label = gtk_label_new (labelstr);
gtk_label_set_width_chars (GTK_LABEL (label), 22);
gtk_misc_set_alignment (GTK_MISC (label), 0, 0.5);
gtk_table_attach (GTK_TABLE (table), label, 0, 1,
*rowidx, *rowidx + 1, GTK_FILL, GTK_SHRINK, 0, 0);
if (is_label)
gtk_misc_set_alignment (GTK_MISC (widget), 0, 0.5);
if (readonly)
{
if (!is_label && GTK_IS_ENTRY (widget))
{
gtk_entry_set_has_frame (GTK_ENTRY (widget), FALSE);
gtk_entry_set_editable (GTK_ENTRY (widget), FALSE);
}
}
else
{
if (is_label)
gtk_label_set_selectable (GTK_LABEL (widget), TRUE);
}
gtk_table_attach (GTK_TABLE (table), widget, 1, 2,
*rowidx, *rowidx + 1, GTK_FILL, GTK_SHRINK, 0, 0);
if (widget2)
gtk_table_attach (GTK_TABLE (table), widget2, 2, 3,
*rowidx, *rowidx + 1, GTK_FILL, GTK_SHRINK, 5, 0);
++*rowidx;
return GTK_LABEL (label);
}
static gboolean xmonadlog_applet_fill(PanelApplet *applet)
{
GtkWidget *label = gtk_label_new("Waiting for XMonad");
// Set up Gconf
GConfClient* client = gconf_client_get_default();
gconf_client_add_dir(client,
"/apps/xmonad-log-applet",
GCONF_CLIENT_PRELOAD_NONE,
NULL);
gconf_client_notify_add(client,
"/apps/xmonad-log-applet/width-chars",
xmonadlog_applet_size_change,
label,
NULL,
NULL);
GConfValue* gcValue = NULL;
gcValue = gconf_client_get(client,
"/apps/xmonad-log-applet/width-chars",
NULL);
int width = 80;
if (gcValue && gcValue->type == GCONF_VALUE_INT) {
width = gconf_value_get_int(gcValue);
}
gtk_label_set_width_chars(GTK_LABEL(label), width);
gtk_label_set_use_markup(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment((GtkMisc *)label, 0.0, 0.5);
set_up_dbus_transfer(label);
g_signal_connect(applet, "change-background", G_CALLBACK(change_bg), NULL);
gtk_container_add(GTK_CONTAINER(applet), label);
gtk_widget_show_all(GTK_WIDGET(applet));
return TRUE;
}
static void
open_valigned_label_window (void)
{
GtkWidget *window, *box, *label, *frame;
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
g_signal_connect (test_window, "delete-event",
G_CALLBACK (gtk_main_quit), test_window);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (box);
gtk_container_add (GTK_CONTAINER (window), box);
label = gtk_label_new ("Both labels expand");
gtk_widget_show (label);
gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
label = gtk_label_new ("Some wrapping text with width-chars = 15 and max-width-chars = 35");
gtk_label_set_line_wrap (GTK_LABEL (label), TRUE);
gtk_label_set_width_chars (GTK_LABEL (label), 15);
gtk_label_set_max_width_chars (GTK_LABEL (label), 35);
gtk_widget_show (label);
frame = gtk_frame_new (NULL);
gtk_widget_show (frame);
gtk_container_add (GTK_CONTAINER (frame), label);
gtk_widget_set_valign (frame, GTK_ALIGN_CENTER);
gtk_widget_set_halign (frame, GTK_ALIGN_CENTER);
gtk_box_pack_start (GTK_BOX (box), frame, TRUE, TRUE, 0);
gtk_window_present (GTK_WINDOW (window));
}
static void
main_window_prepare (GstUsersTool *tool)
{
GtkWidget *uid_entry;
GtkWidget *passwd_label;
int width;
uid_entry = gst_dialog_get_widget (GST_TOOL (tool)->main_dialog, "user_settings_uid");
gtk_spin_button_set_range (GTK_SPIN_BUTTON (uid_entry), 0, OOBS_MAX_UID);
create_tables (tool);
gtk_window_set_default_size (GTK_WINDOW (GST_TOOL (tool)->main_dialog),
650, 400);
/* Ensure dialog won't change size when selecting another user */
passwd_label = gst_dialog_get_widget (GST_TOOL (tool)->main_dialog,
"user_settings_passwd");
width = MAX (strlen (_("Not asked on login")), strlen (_("Asked on login")));
gtk_label_set_width_chars (GTK_LABEL (passwd_label), width);
/* For random password generation. */
srand (time (NULL));
}
static GtkWidget *
gimp_navigation_editor_new_private (GimpMenuFactory *menu_factory,
GimpDisplayShell *shell)
{
GimpNavigationEditor *editor;
g_return_val_if_fail (menu_factory == NULL ||
GIMP_IS_MENU_FACTORY (menu_factory), NULL);
g_return_val_if_fail (shell == NULL || GIMP_IS_DISPLAY_SHELL (shell), NULL);
g_return_val_if_fail (menu_factory || shell, NULL);
if (shell)
{
Gimp *gimp = shell->display->gimp;
GimpDisplayConfig *config = shell->display->config;
GimpView *view;
editor = g_object_new (GIMP_TYPE_NAVIGATION_EDITOR, NULL);
view = GIMP_VIEW (editor->view);
gimp_view_renderer_set_size (view->renderer,
config->nav_preview_size * 3,
view->renderer->border_width);
gimp_view_renderer_set_context (view->renderer,
gimp_get_user_context (gimp));
gimp_navigation_editor_set_shell (editor, shell);
}
else
{
GtkWidget *hscale;
GtkWidget *hbox;
editor = g_object_new (GIMP_TYPE_NAVIGATION_EDITOR,
"menu-factory", menu_factory,
"menu-identifier", "<NavigationEditor>",
NULL);
gtk_widget_set_size_request (editor->view,
GIMP_VIEW_SIZE_HUGE,
GIMP_VIEW_SIZE_HUGE);
gimp_view_set_expand (GIMP_VIEW (editor->view), TRUE);
/* the editor buttons */
editor->zoom_out_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor), "view",
"view-zoom-out", NULL);
editor->zoom_in_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor), "view",
"view-zoom-in", NULL);
editor->zoom_100_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor), "view",
"view-zoom-1-1", NULL);
editor->zoom_fit_in_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor), "view",
"view-zoom-fit-in", NULL);
editor->zoom_fill_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor), "view",
"view-zoom-fill", NULL);
editor->shrink_wrap_button =
gimp_editor_add_action_button (GIMP_EDITOR (editor), "view",
"view-shrink-wrap", NULL);
/* the zoom scale */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
gtk_box_pack_end (GTK_BOX (editor), hbox, FALSE, FALSE, 0);
gtk_widget_show (hbox);
editor->zoom_adjustment =
GTK_ADJUSTMENT (gtk_adjustment_new (0.0, -8.0, 8.0, 0.5, 1.0, 0.0));
g_signal_connect (editor->zoom_adjustment, "value-changed",
G_CALLBACK (gimp_navigation_editor_zoom_adj_changed),
editor);
hscale = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL,
editor->zoom_adjustment);
gtk_scale_set_draw_value (GTK_SCALE (hscale), FALSE);
gtk_box_pack_start (GTK_BOX (hbox), hscale, TRUE, TRUE, 0);
gtk_widget_show (hscale);
/* the zoom label */
editor->zoom_label = gtk_label_new ("100%");
gtk_label_set_width_chars (GTK_LABEL (editor->zoom_label), 7);
gtk_box_pack_start (GTK_BOX (hbox), editor->zoom_label, FALSE, FALSE, 0);
gtk_widget_show (editor->zoom_label);
}
gimp_view_renderer_set_background (GIMP_VIEW (editor->view)->renderer,
GIMP_STOCK_TEXTURE);
return GTK_WIDGET (editor);
}
int
gtkstatusbar_create( GtkBox *parent )
{
GtkWidget *separator;
status_bar = gtk_box_new( GTK_ORIENTATION_HORIZONTAL, 5 );
gtk_box_pack_start( parent, status_bar, FALSE, FALSE, 3 );
/* FIXME: unref these pixbuf on statusbar destroy */
pixbuf_tape_inactive =
gdk_pixbuf_new_from_xpm_data( gtkpixmap_tape_inactive );
pixbuf_tape_active =
gdk_pixbuf_new_from_xpm_data( gtkpixmap_tape_active );
pixbuf_mdr_inactive =
gdk_pixbuf_new_from_xpm_data( gtkpixmap_mdr_inactive );
pixbuf_mdr_active =
gdk_pixbuf_new_from_xpm_data( gtkpixmap_mdr_active );
pixbuf_disk_inactive =
gdk_pixbuf_new_from_xpm_data( gtkpixmap_disk_inactive );
pixbuf_disk_active =
gdk_pixbuf_new_from_xpm_data( gtkpixmap_disk_active );
pixbuf_pause_inactive =
gdk_pixbuf_new_from_xpm_data( gtkpixmap_pause_inactive );
pixbuf_pause_active =
gdk_pixbuf_new_from_xpm_data( gtkpixmap_pause_active );
pixbuf_mouse_inactive =
gdk_pixbuf_new_from_xpm_data( gtkpixmap_mouse_inactive );
pixbuf_mouse_active =
gdk_pixbuf_new_from_xpm_data( gtkpixmap_mouse_active );
speed_status = gtk_label_new( "100%" );
gtk_label_set_width_chars( GTK_LABEL( speed_status ), 8 );
gtk_box_pack_end( GTK_BOX( status_bar ), speed_status, FALSE, FALSE, 0 );
separator = gtk_separator_new( GTK_ORIENTATION_VERTICAL );
gtk_box_pack_end( GTK_BOX( status_bar ), separator, FALSE, FALSE, 0 );
tape_status = gtk_image_new_from_pixbuf( pixbuf_tape_inactive );
gtk_box_pack_end( GTK_BOX( status_bar ), tape_status, FALSE, FALSE, 0 );
microdrive_status = gtk_image_new_from_pixbuf( pixbuf_mdr_inactive );
gtk_box_pack_end( GTK_BOX( status_bar ), microdrive_status, FALSE, FALSE,
0 );
disk_status = gtk_image_new_from_pixbuf( pixbuf_disk_inactive );
gtk_box_pack_end( GTK_BOX( status_bar ), disk_status, FALSE, FALSE, 0 );
pause_status = gtk_image_new_from_pixbuf( pixbuf_pause_inactive );
gtk_box_pack_end( GTK_BOX( status_bar ), pause_status, FALSE, FALSE, 0 );
mouse_status = gtk_image_new_from_pixbuf( pixbuf_mouse_inactive );
gtk_box_pack_end( GTK_BOX( status_bar ), mouse_status, FALSE, FALSE, 0 );
separator = gtk_separator_new( GTK_ORIENTATION_VERTICAL );
gtk_box_pack_end( GTK_BOX( status_bar ), separator, FALSE, FALSE, 0 );
machine_name = gtk_label_new( NULL );
gtk_box_pack_start( GTK_BOX( status_bar ), machine_name, FALSE, FALSE, 0 );
return 0;
}
static void
gctt_rebuild_menu (GncCombott *combott, GtkTreeModel *model)
{
GncCombottPrivate *priv;
GtkTreeIter iter;
GtkWidget *menu_items;
gboolean valid;
gint num = 1;
gint items = 0;
g_return_if_fail (GNC_IS_COMBOTT (combott));
g_return_if_fail (model == NULL || GTK_IS_TREE_MODEL (model));
priv = GNC_COMBOTT_GET_PRIVATE (combott);
priv->menu = NULL;
priv->menu = gtk_menu_new();
valid = gtk_tree_model_get_iter_first (model, &iter);
while (valid)
{
GtkWidget *label;
/* Walk through the list, reading each row */
gchar *str_data;
gchar *tip_data;
gtk_tree_model_get (model, &iter,
priv->text_col, &str_data,
priv->tip_col, &tip_data,
-1);
/* Create a new menu-item with a name... */
menu_items = gtk_menu_item_new_with_label (str_data);
/* Get widget width to max number of characters in list */
if(strlen(str_data) > num)
num = strlen(str_data);
/* Add the tooltip to the child label */
label = gtk_bin_get_child(GTK_BIN(menu_items));
gtk_widget_set_tooltip_text (label, tip_data);
gtk_misc_set_alignment (GTK_MISC(label), 0, 0.5);
/* ...and add it to the menu. */
gtk_menu_shell_append (GTK_MENU_SHELL (priv->menu), menu_items);
g_signal_connect (menu_items, "activate",
G_CALLBACK (menuitem_response_cb),
combott);
/* Show the widget */
gtk_widget_show (menu_items);
g_free (str_data);
g_free (tip_data);
items++;
valid = gtk_tree_model_iter_next (model, &iter);
}
g_signal_connect(G_OBJECT(priv->menu), "size-allocate", G_CALLBACK(menu_getsize_cb), combott);
/* Set widget width to max number of characters in list */
priv->max_number_char = num;
gtk_label_set_width_chars(GTK_LABEL(priv->label), priv->max_number_char);
priv->num_items = items;
}
/********************************************************
* IccProfileChangerDialogNew関数 *
* ICCプロファイルを選択するダイアログウィジェットを作成 *
* 引数 *
* parent : 親ウインドウ *
* workspace_profile_path : 作業用プロファイルのパス *
* 返り値 *
* ダイアログ生成用のウィジェット *
********************************************************/
GtkWidget* IccProfileChangerDialogNew(GtkWindow *parent, gchar *workspace_profile_path)
{
GtkWidget *dialog, *content_area, *box, *radio1, *radio2 = NULL, *radio3, *button;
dialog = gtk_dialog_new_with_buttons("Change ICC profile", parent, GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_OK, GTK_RESPONSE_OK, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);
gtk_widget_set_size_request(dialog, 400, -1);
g_signal_connect(dialog, "response", G_CALLBACK(IccProfileChangerDialogResponse), dialog);
content_area = gtk_dialog_get_content_area(GTK_DIALOG(dialog));
gtk_container_set_border_width(GTK_CONTAINER(dialog), 4);
radio1 = gtk_radio_button_new_with_label(NULL, "Don't color manage this canvas");
gtk_misc_set_alignment(GTK_MISC(GTK_BIN(radio1)->child), 0, .5);
gtk_label_set_width_chars(GTK_LABEL(GTK_BIN(radio1)->child), 64);
gtk_label_set_ellipsize(GTK_LABEL(GTK_BIN(radio1)->child), PANGO_ELLIPSIZE_END);
gtk_box_pack_start(GTK_BOX(content_area), radio1, FALSE, FALSE, 2);
if(workspace_profile_path)
{
wchar_t *buf;
guint32 buf_size;
gssize count;
gchar *desc = NULL, *label_text;
cmsHPROFILE h_profile = cmsOpenProfileFromFile(workspace_profile_path, "rb");
if(h_profile)
{
buf_size = cmsGetProfileInfo(h_profile, cmsInfoDescription, "ja", "JP", NULL, 0);
buf = (wchar_t *)g_malloc(buf_size);
cmsGetProfileInfo(h_profile, cmsInfoDescription, "ja", "JP", buf, buf_size);
desc = g_convert((gchar *)buf, buf_size, "UTF-8", "UTF-16LE", NULL, &count, NULL);
cmsCloseProfile(h_profile);
}
label_text = g_strdup_printf("Workspace%s%s", desc ? " : " : "", desc ? desc : "");
radio2 = gtk_radio_button_new_with_label_from_widget(radio1, label_text);
gtk_misc_set_alignment(GTK_MISC(GTK_BIN(radio2)->child), 0, .5);
gtk_label_set_width_chars(GTK_LABEL(GTK_BIN(radio2)->child), 64);
gtk_label_set_ellipsize(GTK_LABEL(GTK_BIN(radio2)->child), PANGO_ELLIPSIZE_END);
g_object_set_data(G_OBJECT(radio2), "data", g_strdup(workspace_profile_path));
gtk_box_pack_start(GTK_BOX(content_area), radio2, FALSE, FALSE, 2);
}
radio3 = gtk_radio_button_new_with_label_from_widget(radio1, "Profile : ");
button = icc_button_new();
icc_button_set_enable_empty(ICC_BUTTON(button), FALSE);
icc_button_set_mask (ICC_BUTTON(button),
ICC_BUTTON_CLASS_INPUT | ICC_BUTTON_CLASS_OUTPUT | ICC_BUTTON_CLASS_DISPLAY,
ICC_BUTTON_COLORSPACE_XYZ | ICC_BUTTON_COLORSPACE_LAB,
ICC_BUTTON_COLORSPACE_RGB);
g_object_set_data(G_OBJECT(radio3), "data", icc_button_get_filename(ICC_BUTTON(button)));
g_signal_connect(button, "changed", G_CALLBACK(IccProfileChangerDialogProfileChanged), radio3);
box = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(box), radio3, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(box), button, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(content_area), box, FALSE, FALSE, 2);
g_signal_connect(radio1, "toggled", G_CALLBACK(IccProfileChangerDialogSelectionChanged), dialog);
g_signal_connect(radio2, "toggled", G_CALLBACK(IccProfileChangerDialogSelectionChanged), dialog);
g_signal_connect(radio3, "toggled", G_CALLBACK(IccProfileChangerDialogSelectionChanged), dialog);
g_object_set_data(dialog, "radio1", radio1);
g_object_set_data(dialog, "radio2", radio2);
g_object_set_data(dialog, "radio3", radio3);
gtk_widget_show_all(dialog);
return dialog;
}
MidiogreApp *midiogre_app_init(void)
{
MidiogreApp *app;
GtkWidget *header;
GtkWidget *separator;
GtkWidget *scrolled;
GtkWidget *label,*frame;
GtkWidget *button;
GtkBox *box;
gint i;
GError *err;
/* Allocate app */
app = calloc(1, sizeof(MidiogreApp));
/* Setup window */
app->window = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
gtk_window_set_default_size(GTK_WINDOW(app->window), 600, 400);
g_signal_connect(app->window, "destroy", G_CALLBACK(gtk_widget_destroyed), NULL);
g_signal_connect(app->window, "key-release-event", G_CALLBACK(key_event), NULL);
gtk_window_set_icon(app->window,gdk_pixbuf_new_from_resource("/org/prozum/midiogre/midiogre_logo.png",&err));
/* Setup header bar */
header = gtk_header_bar_new();
gtk_header_bar_set_title (GTK_HEADER_BAR(header), "Midiogre");
gtk_window_set_titlebar(app->window, header);
/* Setup close button */
button = gtk_button_new();
gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/window-close-symbolic.symbolic.png"));
gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(gtk_main_quit), app->window);
/* Add seperator */
separator = gtk_separator_new(GTK_ORIENTATION_VERTICAL);
gtk_header_bar_pack_end(GTK_HEADER_BAR(header), separator);
/* Setup folder button */
button = gtk_button_new();
gtk_container_add (GTK_CONTAINER(button), gtk_image_new_from_resource("/org/prozum/midiogre/icons/document-open-symbolic.symbolic.png"));
gtk_header_bar_pack_end(GTK_HEADER_BAR(header), button);
g_signal_connect_swapped(button, "clicked", G_CALLBACK(folder_chooser), app->window);
/* Global horizontal box */
app->win_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(app->window), GTK_WIDGET(app->win_box));
/* Scroll container for sidepanel */
scrolled = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW (scrolled), GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_box_pack_start(app->win_box, scrolled, FALSE, FALSE, 0);
/* Sidepanel box */
app->panel_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0));
gtk_container_add(GTK_CONTAINER (scrolled), GTK_WIDGET(app->panel_box));
gtk_container_set_border_width(GTK_CONTAINER(app->panel_box), 10);
/* Frame with favorit info */
frame = gtk_frame_new("Favorite");
gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0);
app->fav_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->fav_box));
/* Current favorite */
app->fav_title_label = GTK_LABEL(gtk_label_new(""));
gtk_label_set_max_width_chars(app->fav_title_label, 20);
gtk_label_set_width_chars(app->fav_title_label, 20);
gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_title_label), FALSE, FALSE, 0);
app->fav_artist_label = GTK_LABEL(gtk_label_new("No favorite selected!"));
gtk_label_set_max_width_chars(app->fav_artist_label, 20);
gtk_label_set_width_chars(app->fav_artist_label, 20);
gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_artist_label), FALSE, FALSE, 0);
app->fav_album_label = GTK_LABEL(gtk_label_new(""));
gtk_label_set_max_width_chars(app->fav_album_label, 20);
gtk_label_set_width_chars(app->fav_album_label, 20);
gtk_box_pack_start(app->fav_box, GTK_WIDGET(app->fav_album_label), FALSE, FALSE, 0);
/* Frame with search criteria widgets */
frame = gtk_frame_new("Search");
gtk_box_pack_start(app->panel_box, frame, FALSE, FALSE, 0);
app->search_box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_VERTICAL, 10));
gtk_container_set_border_width(GTK_CONTAINER(app->search_box), 10);
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->search_box));
/* Title entry */
frame = gtk_frame_new("Title");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->title_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(app->title_entry), TRUE, FALSE, 0);
/* Artist entry */
frame = gtk_frame_new("Artist");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->artist_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(app->artist_entry), TRUE, FALSE, 0);
/* Album entry */
frame = gtk_frame_new("Album");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->album_entry = GTK_ENTRY(gtk_entry_new());
gtk_box_pack_start(box, GTK_WIDGET(app->album_entry), TRUE, FALSE, 0);
/* Instrument class buttons */
frame = gtk_frame_new("Instrument Classes");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
app->instr_grid = GTK_GRID(gtk_grid_new());
#if GTK_MINOR_VERSION >= 12
gtk_widget_set_margin_start(GTK_WIDGET(app->instr_grid), 10);
gtk_widget_set_margin_end(GTK_WIDGET(app->instr_grid), 10);
#else
gtk_widget_set_margin_left(GTK_WIDGET(app->instr_grid), 10);
gtk_widget_set_margin_right(GTK_WIDGET(app->instr_grid), 10);
#endif
gtk_widget_set_margin_bottom(GTK_WIDGET(app->instr_grid), 10);
gtk_widget_set_margin_top(GTK_WIDGET(app->instr_grid), 10);
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(app->instr_grid));
for (i = 0; i < INSTR_CLASSES; i++) {
label = gtk_label_new(instrument_classes[i]);
gtk_widget_set_halign(GTK_WIDGET(label), GTK_ALIGN_START);
gtk_grid_attach(app->instr_grid, label, 1, i + 1, 1, 1);
app->instr_buttons[i] = GTK_CHECK_BUTTON(gtk_check_button_new());
gtk_widget_set_halign(GTK_WIDGET(app->instr_buttons[i]), GTK_ALIGN_END);
gtk_grid_attach(app->instr_grid, GTK_WIDGET(app->instr_buttons[i]), 2, i + 1, 1, 1);
}
/* Result spinbutton */
frame = gtk_frame_new("Max result");
gtk_box_pack_start(app->search_box, frame, FALSE, FALSE, 0);
box = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));
gtk_container_add(GTK_CONTAINER(frame), GTK_WIDGET(box));
gtk_container_set_border_width(GTK_CONTAINER(box), 10);
app->result_spinbutton = GTK_SPIN_BUTTON(gtk_spin_button_new_with_range(1, 100, 1));
gtk_spin_button_set_value(app->result_spinbutton, 25);
gtk_box_pack_start(box, GTK_WIDGET(app->result_spinbutton), TRUE, TRUE, 0);
/* Search button */
app->search_button = GTK_BUTTON(gtk_button_new_with_label("Search"));
gtk_box_pack_start(app->search_box, GTK_WIDGET(app->search_button), FALSE, FALSE, 0);
g_signal_connect_swapped(app->search_button, "clicked", G_CALLBACK(search_event), app);
/* Songboxes notebook (Tabsview) */
app->song_notebook = GTK_NOTEBOOK(gtk_notebook_new());
gtk_widget_set_hexpand(GTK_WIDGET(app->song_notebook), TRUE);
gtk_box_pack_start(app->win_box, GTK_WIDGET(app->song_notebook), TRUE, TRUE, 0);
/* Add song boxes */
app->songboxes[SONGBOX_ALPHA] = songbox_new(app->song_notebook, "Alphabetical");
app->songboxes[SONGBOX_FPRNT] = songbox_new(app->song_notebook, "Fingerprint");
app->songboxes[SONGBOX_BEST] = songbox_new(app->song_notebook, "Best Match");
app->songboxes[SONGBOX_POP] = songbox_new(app->song_notebook, "Popularity");
app->songboxes[SONGBOX_NEW] = songbox_new(app->song_notebook, "Newest");
/* Show all widgets */
gtk_widget_show_all(GTK_WIDGET(app->window));
/* Allocate song queue */
app->songs[SONGBOX_ALPHA] = g_queue_new();
app->songs[SONGBOX_FPRNT] = g_queue_new();
app->songs[SONGBOX_BEST] = g_queue_new();
app->songs[SONGBOX_POP] = g_queue_new();
app->songs[SONGBOX_NEW] = g_queue_new();
return app;
}
static int _copy(Prefs * prefs, unsigned int filec, char * filev[])
{
static Copy copy;
GtkWidget * vbox;
GtkWidget * hbox;
GtkSizeGroup * left;
GtkSizeGroup * right;
GtkWidget * widget;
PangoFontDescription * bold;
if(filec < 2 || filev == NULL)
return 1; /* FIXME report error */
copy.prefs = prefs;
copy.filec = filec;
copy.filev = filev;
copy.cur = 0;
/* graphical interface */
copy.window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_icon_name(GTK_WINDOW(copy.window), "stock_copy");
gtk_window_set_resizable(GTK_WINDOW(copy.window), FALSE);
gtk_window_set_title(GTK_WINDOW(copy.window), _("Copy file(s)"));
g_signal_connect(G_OBJECT(copy.window), "delete-event", G_CALLBACK(
_copy_on_closex), NULL);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 4);
left = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
right = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
/* current argument */
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
widget = gtk_label_new(_("Copying: "));
bold = pango_font_description_new();
pango_font_description_set_weight(bold, PANGO_WEIGHT_BOLD);
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
copy.filename = gtk_entry_new();
gtk_editable_set_editable(GTK_EDITABLE(copy.filename), FALSE);
gtk_size_group_add_widget(right, copy.filename);
gtk_box_pack_start(GTK_BOX(hbox), copy.filename, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
/* progress bar */
copy.progress = gtk_progress_bar_new();
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(copy.progress), TRUE);
#endif
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(copy.progress), "");
gtk_box_pack_start(GTK_BOX(vbox), copy.progress, TRUE, TRUE, 0);
/* file copy */
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
widget = gtk_label_new(_("Filename: "));
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
copy.flabel = gtk_label_new("");
gtk_label_set_ellipsize(GTK_LABEL(copy.flabel), PANGO_ELLIPSIZE_START);
gtk_label_set_width_chars(GTK_LABEL(copy.flabel), 25);
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(copy.flabel, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(copy.flabel), 0.0, 0.5);
#endif
gtk_size_group_add_widget(right, copy.flabel);
gtk_box_pack_start(GTK_BOX(hbox), copy.flabel, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
/* file copy speed */
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
widget = gtk_label_new(_("Copied: "));
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
copy.fspeed = gtk_label_new("");
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(copy.fspeed, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(copy.fspeed), 0.0, 0.5);
#endif
gtk_size_group_add_widget(right, copy.fspeed);
gtk_box_pack_start(GTK_BOX(hbox), copy.fspeed, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
/* file copy remaining */
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
widget = gtk_label_new(_("Remaining: "));
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_widget_override_font(widget, bold);
g_object_set(widget, "halign", GTK_ALIGN_START, NULL);
#else
gtk_widget_modify_font(widget, bold);
gtk_misc_set_alignment(GTK_MISC(widget), 0.0, 0.5);
#endif
gtk_size_group_add_widget(left, widget);
gtk_box_pack_start(GTK_BOX(hbox), widget, FALSE, TRUE, 0);
copy.fremaining = gtk_label_new("");
#if GTK_CHECK_VERSION(3, 0, 0)
g_object_set(copy.fremaining, "halign", GTK_ALIGN_START, NULL);
#else
gtk_misc_set_alignment(GTK_MISC(copy.fremaining), 0.0, 0.5);
#endif
gtk_size_group_add_widget(right, copy.fremaining);
gtk_box_pack_start(GTK_BOX(hbox), copy.fremaining, TRUE, TRUE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
/* file progress bar */
copy.fprogress = gtk_progress_bar_new();
#if GTK_CHECK_VERSION(3, 0, 0)
gtk_progress_bar_set_show_text(GTK_PROGRESS_BAR(copy.fprogress), TRUE);
#endif
gtk_progress_bar_set_text(GTK_PROGRESS_BAR(copy.fprogress), "");
gtk_box_pack_start(GTK_BOX(vbox), copy.fprogress, TRUE, TRUE, 0);
hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 4);
widget = gtk_button_new_from_stock(GTK_STOCK_CANCEL);
g_signal_connect_swapped(G_OBJECT(widget), "clicked", G_CALLBACK(
_copy_on_cancel), NULL);
gtk_box_pack_end(GTK_BOX(hbox), widget, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(copy.window), 4);
gtk_container_add(GTK_CONTAINER(copy.window), vbox);
g_idle_add(_copy_idle_first, ©);
_copy_refresh(©);
gtk_widget_show_all(copy.window);
pango_font_description_free(bold);
return 0;
}
gint
main (gint argc, gchar *argv[])
{
gtk_init (&argc, &argv);
g_object_set (gtk_settings_get_default (), "gtk-application-prefer-dark-theme", TRUE, NULL);
gsize size = DEFAULT_SIZE;
guint32 target = DEFAULT_TARGET;
const gchar *theme = DEFAULT_THEME;
GOptionEntry options[] = {
{ "size", 's', 0, G_OPTION_ARG_INT, &size, "The size of the grid", "4" },
{ "target", '\0', 0, G_OPTION_ARG_INT, &target, "The tile to reach", "2048" },
{ "theme", 't', 0, G_OPTION_ARG_STRING, &theme, "The theme to use", DEFAULT_THEME },
{ NULL, '\0', 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
};
G_2048_CLEANUP_OPTIONS_FREE GOptionContext *ctx = g_option_context_new ("foobar");
g_option_context_add_main_entries (ctx, options, NULL);
g_option_context_add_group (ctx, gtk_get_option_group (TRUE));
g_option_context_parse (ctx, &argc, &argv, NULL);
GtkApplication *app = gtk_application_new ("org.gnome.g2048", G_APPLICATION_FLAGS_NONE);
GApplication *gapp = G_APPLICATION (app);
G_2048_CLEANUP_ERROR_FREE GError *error = NULL;
G_APPLICATION_GET_CLASS (gapp)->activate = show_win;
g_application_register (gapp, NULL, &error);
if (error)
{
fprintf (stderr, "Failed to register the gtk application: %s\n", error->message);
return EXIT_FAILURE;
}
if (g_application_get_is_remote (gapp))
{
g_application_activate (gapp);
return EXIT_SUCCESS;
}
G_2048_CLEANUP_FREE gchar *theme_path = get_theme_path (theme);
if (!theme_path)
theme_path = get_theme_path (DEFAULT_THEME);
if (!theme_path)
{
g_critical ("No theme found");
exit (EXIT_FAILURE);
}
GtkWidget *score_box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 10);
GtkBox *hbox = GTK_BOX (score_box);
gtk_box_pack_start (hbox, gtk_label_new ("Score:"), TRUE, TRUE, 0);
GtkWidget *score_label = gtk_label_new ("0");
GtkLabel *label = GTK_LABEL (score_label);
GdkRGBA color;
gdk_rgba_parse (&color, "white");
gtk_widget_override_background_color (score_label, GTK_STATE_FLAG_NORMAL, &color);
gdk_rgba_parse (&color, "black");
gtk_widget_override_color (score_label, GTK_STATE_FLAG_NORMAL, &color);
gtk_label_set_width_chars (GTK_LABEL (score_label), 8);
gtk_box_pack_end (hbox, score_label, TRUE, FALSE, 0);
GtkWidget *box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
GtkBox *vbox = GTK_BOX (box);
gtk_box_pack_start (vbox, g_2048_grid_new (size, target, theme_path, label), TRUE, TRUE, 0);
gtk_box_pack_end (vbox, score_box, TRUE, TRUE, 20);
GtkWidget *win = gtk_widget_new (GTK_TYPE_APPLICATION_WINDOW,
"application", app,
"type", GTK_WINDOW_TOPLEVEL,
"window-position", GTK_WIN_POS_CENTER,
"resizable", FALSE,
NULL);
gtk_container_add (GTK_CONTAINER (win), box);
gtk_widget_show_all (win);
gtk_widget_override_font (win, pango_font_description_from_string("Monospace 18"));
GTK_WIDGET_GET_CLASS (win)->key_press_event = on_key;
return g_application_run (gapp, argc, argv);
}
/* Called when status icon is control-clicked */
static gboolean show_actions_menu(gpointer data) {
/* Declare some variables */
GtkWidget *menu, *menu_item,
*menu_image, *item_label;
/* Create menu */
menu = gtk_menu_new();
g_signal_connect((GObject*)menu, "selection-done", (GCallback)gtk_widget_destroy, NULL);
/* Actions using: */
menu_item = gtk_image_menu_item_new_with_label(_("Actions using:"));
menu_image = gtk_image_new_from_stock(GTK_STOCK_EXECUTE, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image((GtkImageMenuItem*)menu_item, menu_image);
g_signal_connect((GObject*)menu_item, "select", (GCallback)gtk_menu_item_deselect, NULL);
gtk_menu_shell_append((GtkMenuShell*)menu, menu_item);
/* Clipboard contents */
gchar* text = gtk_clipboard_wait_for_text(clipboard);
if (text != NULL)
{
menu_item = gtk_menu_item_new_with_label(_("None"));
/* Modify menu item label properties */
item_label = gtk_bin_get_child((GtkBin*)menu_item);
gtk_label_set_single_line_mode((GtkLabel*)item_label, TRUE);
gtk_label_set_ellipsize((GtkLabel*)item_label, prefs.ellipsize);
gtk_label_set_width_chars((GtkLabel*)item_label, 30);
/* Making bold... */
gchar* bold_text = g_markup_printf_escaped("<b>%s</b>", text);
gtk_label_set_markup((GtkLabel*)item_label, bold_text);
g_free(bold_text);
/* Append menu item */
g_signal_connect((GObject*)menu_item, "select", (GCallback)gtk_menu_item_deselect, NULL);
gtk_menu_shell_append((GtkMenuShell*)menu, menu_item);
}
else
{
/* Create menu item for empty clipboard contents */
menu_item = gtk_menu_item_new_with_label(_("None"));
/* Modify menu item label properties */
item_label = gtk_bin_get_child((GtkBin*)menu_item);
gtk_label_set_markup((GtkLabel*)item_label, _("<b>None</b>"));
/* Append menu item */
g_signal_connect((GObject*)menu_item, "select", (GCallback)gtk_menu_item_deselect, NULL);
gtk_menu_shell_append((GtkMenuShell*)menu, menu_item);
}
/* -------------------- */
gtk_menu_shell_append((GtkMenuShell*)menu, gtk_separator_menu_item_new());
/* Actions */
gchar* path = g_build_filename(g_get_user_data_dir(), ACTIONS_FILE, NULL);
FILE* actions_file = fopen(path, "rb");
g_free(path);
/* Check that it opened and begin read */
if (actions_file)
{
gint size;
size_t fread_return;
fread_return = fread(&size, 4, 1, actions_file);
/* Check if actions file is empty */
if (!size)
{
/* File contained no actions so adding empty */
menu_item = gtk_menu_item_new_with_label(_("Empty"));
gtk_widget_set_sensitive(menu_item, FALSE);
gtk_menu_shell_append((GtkMenuShell*)menu, menu_item);
}
/* Continue reading items until size is 0 */
while (size)
{
/* Read name */
gchar* name = (gchar*)g_malloc(size + 1);
fread_return = fread(name, size, 1, actions_file);
name[size] = '\0';
menu_item = gtk_menu_item_new_with_label(name);
g_free(name);
fread_return = fread(&size, 4, 1, actions_file);
/* Read command */
gchar* command = (gchar*)g_malloc(size + 1);
fread_return = fread(command, size, 1, actions_file);
command[size] = '\0';
fread_return = fread(&size, 4, 1, actions_file);
/* Append the action */
gtk_menu_shell_append((GtkMenuShell*)menu, menu_item);
g_signal_connect((GObject*)menu_item, "activate",
(GCallback)action_selected, (gpointer)command);
}
fclose(actions_file);
}
else
{
/* File did not open so adding empty */
menu_item = gtk_menu_item_new_with_label(_("Empty"));
gtk_widget_set_sensitive(menu_item, FALSE);
gtk_menu_shell_append((GtkMenuShell*)menu, menu_item);
}
/* -------------------- */
gtk_menu_shell_append((GtkMenuShell*)menu, gtk_separator_menu_item_new());
/* Edit actions */
menu_item = gtk_image_menu_item_new_with_mnemonic(_("_Edit actions"));
menu_image = gtk_image_new_from_stock(GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
gtk_image_menu_item_set_image((GtkImageMenuItem*)menu_item, menu_image);
g_signal_connect((GObject*)menu_item, "activate", (GCallback)edit_actions_selected, NULL);
gtk_menu_shell_append((GtkMenuShell*)menu, menu_item);
/* Popup the menu... */
gtk_widget_show_all(menu);
gtk_menu_popup((GtkMenu*)menu, NULL, NULL, NULL, NULL, 1, gtk_get_current_event_time());
/* Return false so the g_timeout_add() function is called only once */
return FALSE;
}
static void
inf_gtk_certificate_manager_certificate_func(InfXmppConnection* connection,
gnutls_session_t session,
InfCertificateChain* chain,
gpointer user_data)
{
InfGtkCertificateManager* manager;
InfGtkCertificateManagerPrivate* priv;
InfGtkCertificateDialogFlags flags;
gnutls_x509_crt_t presented_cert;
gnutls_x509_crt_t known_cert;
gchar* hostname;
gboolean match_hostname;
gboolean issuer_known;
gnutls_x509_crt_t root_cert;
int ret;
unsigned int verify;
GHashTable* table;
gboolean cert_equal;
time_t expiration_time;
InfGtkCertificateManagerQuery* query;
gchar* text;
GtkWidget* vbox;
GtkWidget* button;
GtkWidget* image;
GtkWidget* label;
GError* error;
manager = INF_GTK_CERTIFICATE_MANAGER(user_data);
priv = INF_GTK_CERTIFICATE_MANAGER_PRIVATE(manager);
g_object_get(G_OBJECT(connection), "remote-hostname", &hostname, NULL);
presented_cert = inf_certificate_chain_get_own_certificate(chain);
match_hostname = gnutls_x509_crt_check_hostname(presented_cert, hostname);
/* First, validate the certificate */
ret = gnutls_certificate_verify_peers2(session, &verify);
error = NULL;
if(ret != GNUTLS_E_SUCCESS)
inf_gnutls_set_error(&error, ret);
/* Remove the GNUTLS_CERT_ISSUER_NOT_KNOWN flag from the verification
* result, and if the certificate is still invalid, then set an error. */
if(error == NULL)
{
issuer_known = TRUE;
if(verify & GNUTLS_CERT_SIGNER_NOT_FOUND)
{
issuer_known = FALSE;
/* Re-validate the certificate for other failure reasons --
* unfortunately the gnutls_certificate_verify_peers2() call
* does not tell us whether the certificate is otherwise invalid
* if a signer is not found already. */
/* TODO: Here it would be good to use the verify flags from the
* certificate credentials, but GnuTLS does not have API to
* retrieve them. */
root_cert = inf_certificate_chain_get_root_certificate(chain);
ret = gnutls_x509_crt_list_verify(
inf_certificate_chain_get_raw(chain),
inf_certificate_chain_get_n_certificates(chain),
&root_cert,
1,
NULL,
0,
GNUTLS_VERIFY_ALLOW_X509_V1_CA_CRT,
&verify
);
if(ret != GNUTLS_E_SUCCESS)
inf_gnutls_set_error(&error, ret);
else if(verify & GNUTLS_CERT_INVALID)
inf_gnutls_certificate_verification_set_error(&error, verify);
}
}
/* Look up the host in our database of pinned certificates if we could not
* fully verify the certificate, i.e. if either the issuer is not known or
* the hostname of the connection does not match the certificate. */
table = NULL;
if(error == NULL)
{
known_cert = NULL;
if(!match_hostname || !issuer_known)
{
/* If we cannot load the known host file, then cancel the connection.
* Otherwise it might happen that someone shows us a certificate that we
* tell the user we don't know, if though actually for that host we expect
* a different certificate. */
table = inf_gtk_certificate_manager_ref_known_hosts(manager, &error);
if(table != NULL)
known_cert = g_hash_table_lookup(table, hostname);
}
}
/* Next, configure the flags for the dialog to be shown based on the
* verification result, and on whether the pinned certificate matches
* the one presented by the host or not. */
flags = 0;
if(error == NULL)
{
if(known_cert != NULL)
{
cert_equal = inf_gtk_certificate_manager_compare_fingerprint(
known_cert,
presented_cert,
&error
);
if(error == NULL && cert_equal == FALSE)
{
if(!match_hostname)
flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_HOSTNAME_MISMATCH;
if(!issuer_known)
flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_ISSUER_NOT_KNOWN;
flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_UNEXPECTED;
expiration_time = gnutls_x509_crt_get_expiration_time(known_cert);
if(expiration_time != (time_t)(-1))
{
expiration_time -= INF_GTK_CERTIFICATE_MANAGER_EXPIRATION_TOLERANCE;
if(time(NULL) > expiration_time)
{
flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_OLD_EXPIRED;
}
}
}
}
else
{
if(!match_hostname)
flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_HOSTNAME_MISMATCH;
if(!issuer_known)
flags |= INF_GTK_CERTIFICATE_DIALOG_CERT_ISSUER_NOT_KNOWN;
}
}
/* Now proceed either by accepting the connection, rejecting it, or
* bothering the user with an annoying dialog. */
if(error == NULL)
{
if(flags == 0)
{
if(match_hostname && issuer_known)
{
/* Remove the pinned entry if we now have a valid certificate for
* this host. */
if(table != NULL && g_hash_table_remove(table, hostname) == TRUE)
{
inf_gtk_certificate_manager_write_known_hosts_with_warning(
manager,
table
);
}
}
inf_xmpp_connection_certificate_verify_continue(connection);
}
else
{
query = g_slice_new(InfGtkCertificateManagerQuery);
query->manager = manager;
query->known_hosts = table;
query->connection = connection;
query->dialog = inf_gtk_certificate_dialog_new(
priv->parent_window,
0,
flags,
hostname,
chain
);
query->certificate_chain = chain;
table = NULL;
g_object_ref(query->connection);
inf_certificate_chain_ref(chain);
g_signal_connect(
G_OBJECT(connection),
"notify::status",
G_CALLBACK(inf_gtk_certificate_manager_notify_status_cb),
query
);
g_signal_connect(
G_OBJECT(query->dialog),
"response",
G_CALLBACK(inf_gtk_certificate_manager_response_cb),
query
);
image = gtk_image_new_from_stock(GTK_STOCK_CANCEL, GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image);
button = gtk_dialog_add_button(
GTK_DIALOG(query->dialog),
_("_Cancel connection"),
GTK_RESPONSE_REJECT
);
gtk_button_set_image(GTK_BUTTON(button), image);
image = gtk_image_new_from_stock(GTK_STOCK_CONNECT, GTK_ICON_SIZE_BUTTON);
gtk_widget_show(image);
button = gtk_dialog_add_button(
GTK_DIALOG(query->dialog),
_("C_ontinue connection"),
GTK_RESPONSE_ACCEPT
);
gtk_button_set_image(GTK_BUTTON(button), image);
text = g_strdup_printf(
_("Do you want to continue the connection to host \"%s\"? If you "
"choose to continue, this certificate will be trusted in the "
"future when connecting to this host."),
hostname
);
label = gtk_label_new(text);
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_label_set_line_wrap_mode(GTK_LABEL(label), PANGO_WRAP_WORD_CHAR);
gtk_label_set_width_chars(GTK_LABEL(label), 60);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.0);
gtk_widget_show(label);
g_free(text);
vbox = gtk_dialog_get_content_area(GTK_DIALOG(query->dialog));
gtk_box_pack_start(GTK_BOX(vbox), label, FALSE, FALSE, 0);
priv->queries = g_slist_prepend(priv->queries, query);
gtk_window_present(GTK_WINDOW(query->dialog));
}
}
else
{
inf_xmpp_connection_certificate_verify_cancel(connection, error);
g_error_free(error);
}
if(table != NULL) g_hash_table_unref(table);
g_free(hostname);
}
