static void
places_button_resize_label(PlacesButton *self,
gboolean show)
{
gboolean vertical = FALSE;
gboolean deskbar = FALSE;
#ifdef HAS_PANEL_49
if (xfce_panel_plugin_get_mode(self->plugin) == XFCE_PANEL_PLUGIN_MODE_DESKBAR)
deskbar = TRUE;
else if (xfce_panel_plugin_get_mode(self->plugin) == XFCE_PANEL_PLUGIN_MODE_VERTICAL)
vertical = TRUE;
#else
if (xfce_panel_plugin_get_orientation(self->plugin) == GTK_ORIENTATION_VERTICAL)
vertical = TRUE;
#endif
if (self->label_text == NULL) {
places_button_destroy_label(self);
return;
}
if (self->label == NULL) {
self->label = g_object_ref(gtk_label_new(self->label_text));
gtk_box_pack_end(GTK_BOX(self->box), self->label, TRUE, TRUE, 0);
}
else
gtk_label_set_text(GTK_LABEL(self->label), self->label_text);
if (deskbar || self->ellipsize)
gtk_label_set_ellipsize (GTK_LABEL (self->label), PANGO_ELLIPSIZE_END);
else
gtk_label_set_ellipsize (GTK_LABEL (self->label), PANGO_ELLIPSIZE_NONE);
if (vertical)
{
gtk_label_set_angle (GTK_LABEL (self->label), -90);
gtk_misc_set_alignment (GTK_MISC (self->label), 0.5, 0.0);
}
else
{
gtk_label_set_angle (GTK_LABEL (self->label), 0);
gtk_misc_set_alignment (GTK_MISC (self->label), 0.0, 0.5);
}
if(self->ellipsize)
gtk_label_set_max_width_chars (GTK_LABEL (self->label), 25);
else
gtk_label_set_max_width_chars (GTK_LABEL (self->label), 255);
gtk_widget_show(self->label);
}
static void create_entry(PROC_T *p){
p->hbox=gtk_hbox_new(FALSE,0);
char lb[12];
snprintf(lb,12," %5d",p->pid);
struct tm *tim=localtime(&(p->status.timstart));
char stime[80];
strftime(stime,80,"[%a %k:%M:%S]",tim);
p->entry_start=new_label(stime,WIDTH_START,0.5);
p->entry_pid=new_label(lb,WIDTH_PID,1);
p->entry_path=new_label(p->path,WIDTH_PATH,1);
gtk_label_set_selectable(GTK_LABEL(p->entry_path), TRUE);
gtk_label_set_ellipsize(GTK_LABEL(p->entry_path),PANGO_ELLIPSIZE_START);
#if GTK_MAJOR_VERSION>=3 || GTK_MINOR_VERSION >= 12
gtk_widget_set_tooltip_text(p->entry_path, p->path);
#endif
p->entry_errlo=new_label("Lo (nm)",WIDTH_ERRLO,1);
p->entry_errhi=new_label("Hi (nm)",WIDTH_ERRHI,1);
gtk_label_set_max_width_chars(GTK_LABEL(p->entry_errlo),WIDTH_ERRLO);
gtk_label_set_max_width_chars(GTK_LABEL(p->entry_errhi),WIDTH_ERRHI);
p->entry_iseed=new_entry("seed",WIDTH_ISEED,0.5);
p->entry_timing=new_entry("Timing",WIDTH_TIMING,1);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_start,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_pid,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_path,TRUE,TRUE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_errlo,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_errhi,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_iseed,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),p->entry_timing,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->hbox),gtk_vseparator_new(),FALSE,FALSE,0);
change_button(p, GTK_STOCK_PREFERENCES, (void*)kill_job_event);
gtk_box_pack_start(GTK_BOX(p->hbox),p->btn,FALSE,FALSE,0);
p->vbox=gtk_vbox_new(FALSE,0);
if(nproc[p->hid]==1){
gtk_box_pack_start(GTK_BOX(p->vbox),gtk_hseparator_new(),FALSE,FALSE,0);
}
gtk_box_pack_start(GTK_BOX(p->vbox),p->hbox,FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(p->vbox),gtk_hseparator_new(),FALSE,FALSE,0);
gtk_box_pack_start(GTK_BOX(pages[p->hid]),p->vbox,FALSE,FALSE,0);
/*gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook),p->hid); */
gtk_widget_show_all(p->vbox);
}
static void
ido_source_menu_item_constructed (GObject *object)
{
IdoSourceMenuItem *item = IDO_SOURCE_MENU_ITEM (object);
GtkWidget *grid;
gint icon_width;
gtk_icon_size_lookup (GTK_ICON_SIZE_MENU, &icon_width, NULL);
item->icon = g_object_ref (gtk_image_new ());
gtk_widget_set_margin_left (item->icon, icon_width);
gtk_widget_set_margin_right (item->icon, 6);
item->label = g_object_ref (gtk_label_new (""));
gtk_label_set_max_width_chars (GTK_LABEL (item->label), 40);
gtk_label_set_ellipsize (GTK_LABEL (item->label), PANGO_ELLIPSIZE_END);
gtk_misc_set_alignment (GTK_MISC (item->label), 0.0, 0.5);
item->detail = g_object_ref (ido_detail_label_new (""));
gtk_widget_set_halign (item->detail, GTK_ALIGN_END);
gtk_widget_set_hexpand (item->detail, TRUE);
gtk_style_context_add_class (gtk_widget_get_style_context (item->detail), "accelerator");
grid = gtk_grid_new ();
gtk_grid_attach (GTK_GRID (grid), item->icon, 0, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), item->label, 1, 0, 1, 1);
gtk_grid_attach (GTK_GRID (grid), item->detail, 2, 0, 1, 1);
gtk_container_add (GTK_CONTAINER (object), grid);
gtk_widget_show_all (grid);
G_OBJECT_CLASS (ido_source_menu_item_parent_class)->constructed (object);
}
/* PUBLIC FUNCS */
static void
ensure_tooltip (AwnTooltip *tooltip)
{
AwnTooltipPrivate *priv = tooltip->priv;
gchar *normal = NULL;
GdkColor clr;
gchar *color = NULL;
gchar *markup = NULL;
if (priv->text == NULL || priv->font_color == NULL)
{
return;
}
normal = g_markup_escape_text (priv->text, -1);
desktop_agnostic_color_get_color (priv->font_color, &clr);
color = gdk_color_to_string (&clr);
markup = g_strdup_printf ("<span foreground='%s' font_desc='%s'>%s</span>",
color, priv->font_name, normal);
gtk_label_set_max_width_chars (GTK_LABEL (priv->label), 120);
gtk_label_set_ellipsize (GTK_LABEL (priv->label), PANGO_ELLIPSIZE_END);
gtk_label_set_markup (GTK_LABEL (priv->label), markup);
g_free (normal);
g_free (color);
g_free (markup);
if (gtk_widget_get_mapped (GTK_WIDGET (tooltip)) && GTK_IS_WIDGET (priv->focus))
{
awn_tooltip_update_position (tooltip);
}
}
void GtkLabel_::set_max_width_chars(Php::Parameters ¶meters)
{
gint n_chars = (gint)parameters[0];
gtk_label_set_max_width_chars (GTK_LABEL(instance), n_chars);
}
static void
photos_empty_results_box_add_system_settings_label (PhotosEmptyResultsBox *self)
{
GtkWidget *details;
gchar *details_str;
gchar *system_settings_href;
/* Translators: this should be translated in the context of the "You
* can add your online accounts in Settings" sentence below
*/
system_settings_href = g_strconcat ("<a href=\"system-settings\">", _("Settings"), "</a>", NULL);
/* Translators: %s here is "Settings", which is in a separate string
* due to markup, and should be translated only in the context of
* this sentence.
*/
details_str = g_strdup_printf (_("You can add your online accounts in %s"), system_settings_href);
details = gtk_label_new (details_str);
gtk_widget_set_halign (details, GTK_ALIGN_START);
gtk_misc_set_alignment (GTK_MISC (details), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (details), TRUE);
gtk_label_set_max_width_chars (GTK_LABEL (details), 24);
gtk_label_set_use_markup (GTK_LABEL (details), TRUE);
gtk_container_add (GTK_CONTAINER (self->priv->labels_grid), details);
g_signal_connect_swapped (details, "activate-link", G_CALLBACK (photos_empty_results_box_activate_link), self);
g_free (details_str);
g_free (system_settings_href);
}
static void
connect_proxy_cb (GtkActionGroup *action_group,
GtkAction *action,
GtkWidget *proxy,
gpointer dummy)
{
GtkLabel *label;
GIcon *icon;
if (!GTK_IS_MENU_ITEM (proxy))
return;
label = GTK_LABEL (gtk_bin_get_child (GTK_BIN (proxy)));
gtk_label_set_use_underline (label, FALSE);
gtk_label_set_ellipsize (label, PANGO_ELLIPSIZE_END);
gtk_label_set_max_width_chars (label, MENU_ITEM_MAX_WIDTH_CHARS);
icon = g_object_get_data (G_OBJECT (action), "menu-icon");
if (icon != NULL) {
gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (proxy),
gtk_image_new_from_gicon (icon, GTK_ICON_SIZE_MENU));
}
}
static int
genmon2_constructor(plugin_instance *p)
{
genmon2_priv *gm;
ENTER;
gm = (genmon2_priv *) p;
gm->command = "date +%R";
gm->time = 1;
gm->max_text_len = 99;
XCG(p->xc, "Command", &gm->command, str);
XCG(p->xc, "TextSize", &gm->textsize, str);
XCG(p->xc, "TextColor", &gm->textcolor, str);
XCG(p->xc, "PollingTime", &gm->time, int);
XCG(p->xc, "MaxTextLength", &gm->max_text_len, int);
gm->main = gtk_label_new(NULL);
gtk_label_set_max_width_chars(GTK_LABEL(gm->main), gm->max_text_len);
text_update(gm);
gtk_container_set_border_width (GTK_CONTAINER (p->pwid), 1);
gtk_container_add(GTK_CONTAINER(p->pwid), gm->main);
gtk_widget_show_all(p->pwid);
gm->timer = g_timeout_add((guint) gm->time * 1000,
(GSourceFunc) text_update, (gpointer) gm);
RET(1);
}
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;
}
static void fm_tab_page_init(FmTabPage *page)
{
GtkPaned* paned = GTK_PANED(page);
FmTabLabel* tab_label;
FmFolderView* folder_view;
GList* focus_chain = NULL;
FmSidePaneMode mode = app_config->side_pane_mode;
page->side_pane = fm_side_pane_new();
fm_side_pane_set_mode(page->side_pane, (mode & FM_SP_MODE_MASK));
/* TODO: add a close button to side pane */
gtk_paned_add1(paned, GTK_WIDGET(page->side_pane));
focus_chain = g_list_prepend(focus_chain, page->side_pane);
/* handlers below will be used when FmMainWin detects new page added */
folder_view = (FmFolderView*)fm_standard_view_new(app_config->view_mode,
update_files_popup,
open_folder_func);
page->folder_view = folder_view;
fm_folder_view_set_selection_mode(folder_view, GTK_SELECTION_MULTIPLE);
page->nav_history = fm_nav_history_new();
gtk_paned_add2(paned, GTK_WIDGET(page->folder_view));
focus_chain = g_list_prepend(focus_chain, page->folder_view);
/* We need this to change tab order to focus folder view before left pane. */
gtk_container_set_focus_chain(GTK_CONTAINER(page), focus_chain);
g_list_free(focus_chain);
gtk_widget_show_all(GTK_WIDGET(page));
if(mode & FM_SP_HIDE)
gtk_widget_hide(GTK_WIDGET(page->side_pane));
/* create tab label */
tab_label = (FmTabLabel*)fm_tab_label_new("");
gtk_label_set_max_width_chars(tab_label->label, app_config->max_tab_chars);
#if ! GTK_CHECK_VERSION(3, 0, 0)
gtk_label_set_ellipsize(tab_label->label, PANGO_ELLIPSIZE_END);
#endif
page->tab_label = tab_label;
g_signal_connect(page->folder_view, "sel-changed",
G_CALLBACK(on_folder_view_sel_changed), page);
/*
g_signal_connect(page->folder_view, "chdir",
G_CALLBACK(on_folder_view_chdir), page);
g_signal_connect(page->folder_view, "loaded",
G_CALLBACK(on_folder_view_loaded), page);
g_signal_connect(page->folder_view, "error",
G_CALLBACK(on_folder_view_error), page);
*/
/* the folder view is already loded, call the "loaded" callback ourself. */
//if(fm_folder_view_is_loaded(folder_view))
// on_folder_view_loaded(folder_view, fm_folder_view_get_cwd(folder_view), page);
}
static void
photos_empty_results_box_add_collections_label (PhotosEmptyResultsBox *self)
{
GtkWidget *details;
details = gtk_label_new (_("Name your first album"));
gtk_widget_set_halign (details, GTK_ALIGN_START);
gtk_misc_set_alignment (GTK_MISC (details), 0.0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (details), TRUE);
gtk_label_set_max_width_chars (GTK_LABEL (details), 24);
gtk_label_set_use_markup (GTK_LABEL (details), TRUE);
gtk_container_add (GTK_CONTAINER (self->priv->labels_grid), details);
}
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 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;
}
static void desktop_active_window_changed(WnckScreen* screen, WnckWindow *previous_window, MacMenu* mmb)
{
WnckWindow* awin = wnck_screen_get_active_window(screen);
GtkWidget* sck = NULL;
if (awin != NULL && wnck_window_get_window_type(awin) != WNCK_WINDOW_DESKTOP)
{
long inout[2] = {0, 0};
inout[0] = wnck_window_get_xid(awin);
if (inout[0])
{
g_hash_table_foreach(mmb->mbars_scks, find_mbar_by_mwin, inout);
if (inout[1])
sck = g_hash_table_lookup(mmb->mbars_scks, (gpointer) inout[1]);
}
if (sck == NULL)
{
sck = mmb->dummysck;
gtk_label_set_max_width_chars(mmb->label, MAX_LABEL_WIDTH_N_CHARS * 10);
}
else
{
gtk_label_set_max_width_chars(mmb->label, MAX_LABEL_WIDTH_N_CHARS);
}
gtk_label_set_text(mmb->label, get_application_name(awin, mmb));
}
else
{
sck = mmb->mainsck;
gtk_label_set_max_width_chars(mmb->label, MAX_LABEL_WIDTH_N_CHARS * 10);
gtk_label_set_text(mmb->label, MAIN_LABEL_TEXT);
}
gtk_notebook_set_current_page(
mmb->notebook,
gtk_notebook_page_num(mmb->notebook, sck)
);
}
int
clip_GTK_LABELSETMAXWIDTHCHARS(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_max_width_chars(GTK_LABEL(clbl->widget), width);
return 0;
err:
return 1;
}
GtkWidget *total_stats_widget(void)
{
GtkWidget *vbox, *hbox, *statsframe, *framebox;
vbox = gtk_vbox_new(FALSE, 3);
statsframe = gtk_frame_new(_("Statistics"));
stats_w.framelabel = gtk_frame_get_label_widget(GTK_FRAME(statsframe));
gtk_label_set_max_width_chars(GTK_LABEL(stats_w.framelabel), 60);
gtk_box_pack_start(GTK_BOX(vbox), statsframe, FALSE, FALSE, 3);
framebox = gtk_vbox_new(FALSE, 3);
gtk_container_add(GTK_CONTAINER(statsframe), framebox);
/* first row */
hbox = gtk_hbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(framebox), hbox, TRUE, FALSE, 3);
stats_w.selection_size = new_info_label_in_frame(hbox, _("Dives"));
stats_w.max_temp = new_info_label_in_frame(hbox, _("Max Temp"));
stats_w.min_temp = new_info_label_in_frame(hbox, _("Min Temp"));
stats_w.avg_temp = new_info_label_in_frame(hbox, _("Avg Temp"));
/* second row */
hbox = gtk_hbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(framebox), hbox, TRUE, FALSE, 3);
stats_w.total_time = new_info_label_in_frame(hbox, _("Total Time"));
stats_w.avg_time = new_info_label_in_frame(hbox, _("Avg Time"));
stats_w.longest_time = new_info_label_in_frame(hbox, _("Longest Dive"));
stats_w.shortest_time = new_info_label_in_frame(hbox, _("Shortest Dive"));
/* third row */
hbox = gtk_hbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(framebox), hbox, TRUE, FALSE, 3);
stats_w.max_overall_depth = new_info_label_in_frame(hbox, _("Max Depth"));
stats_w.min_overall_depth = new_info_label_in_frame(hbox, _("Min Depth"));
stats_w.avg_overall_depth = new_info_label_in_frame(hbox, _("Avg Depth"));
/* fourth row */
hbox = gtk_hbox_new(FALSE, 3);
gtk_box_pack_start(GTK_BOX(framebox), hbox, TRUE, FALSE, 3);
stats_w.max_sac = new_info_label_in_frame(hbox, _("Max SAC"));
stats_w.min_sac = new_info_label_in_frame(hbox, _("Min SAC"));
stats_w.avg_sac = new_info_label_in_frame(hbox, _("Avg SAC"));
return vbox;
}
static void
connect_proxy_cb (GtkActionGroup *action_group,
GtkAction *action,
GtkWidget *proxy,
NautilusWindow *window)
{
GtkLabel *label;
if (!GTK_IS_MENU_ITEM (proxy))
return;
label = GTK_LABEL (gtk_bin_get_child (GTK_BIN (proxy)));
gtk_label_set_ellipsize (label, PANGO_ELLIPSIZE_END);
gtk_label_set_max_width_chars (label, MENU_ITEM_MAX_WIDTH_CHARS);
}
static void
connect_proxy_cb (GtkActionGroup *action_group,
GtkAction *action,
GtkWidget *proxy,
gpointer dummy)
{
GtkLabel *label;
if (!GTK_IS_MENU_ITEM (proxy))
return;
label = GTK_LABEL (GTK_BIN (proxy)->child);
gtk_label_set_use_underline (label, FALSE);
gtk_label_set_ellipsize (label, PANGO_ELLIPSIZE_END);
gtk_label_set_max_width_chars (label, MENU_ITEM_MAX_WIDTH_CHARS);
}
void CInfoDlg::AddField(int field, int col, int row, const char *caption, int ellipsize)
{
tFieldRec *rec = (tFieldRec*)g_malloc0(sizeof(tFieldRec));
rec->id = field;
rec->label = gtk_label_new(caption);
gtk_misc_set_alignment(GTK_MISC(rec->label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(m_Tab), rec->label, 2*col, 2*col+1, row, row+1,
GTK_FILL, (GtkAttachOptions)0, 4, 0);
rec->value = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(rec->value), 0.0, 0.5);
gtk_label_set_max_width_chars(GTK_LABEL(rec->value), 60);
gtk_table_attach(GTK_TABLE(m_Tab), rec->value, 2*col+1, 2*col+2, row, row+1,
(GtkAttachOptions)(GTK_FILL | GTK_EXPAND), (GtkAttachOptions)0, 4, 0);
m_Labels = g_list_append(m_Labels, rec);
if (ellipsize)
gtk_label_set_ellipsize(GTK_LABEL(rec->value), (PangoEllipsizeMode)ellipsize);
}
static void collecturiCallback(BrowserWindow *window, GtkEntryIconPosition iconPosition, GdkEvent *event)
{
if (iconPosition == GTK_ENTRY_ICON_SECONDARY) {
g_print("add bookmarkbutton\n");
/*
GtkWidget *bookmarkbtn = gtk_button_new();
GtkBox *hBox = GTK_BOX(gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0));`
GtkWidget *image = gtk_image_new_from_pixbuf(window->favicon);
GtkWidget *lab = gtk_label_new(webkit_web_view_get_title(window->webView));
gtk_box_pack_start(hBox, image, FALSE, FALSE, 0);
gtk_box_pack_start(hBox, lab, FALSE, FALSE, 0);
gtk_container_add(GTK_CONTAINER(bookmarkbtn), hBox);
gtk_box_pack_start(window->bookmarkbox, bookmarkbtn, FALSE, FALSE, 0);
gtk_widget_show_all(bookmarkbtn);
*/
GtkToolItem *item = gtk_tool_button_new(NULL, "");
GtkWidget *image = gtk_image_new_from_pixbuf(window->favicon);
cairo_surface_t* fivacon = webkit_web_view_get_favicon(window->webView);
gtk_tool_button_set_icon_widget (GTK_TOOL_BUTTON (item), fivacon);
GtkWidget* label = gtk_label_new (webkit_web_view_get_title(window->webView));
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.5);
gtk_label_set_max_width_chars (GTK_LABEL (label), 25);
gtk_label_set_ellipsize (GTK_LABEL (label), PANGO_ELLIPSIZE_MIDDLE);
gtk_widget_show (label);
gtk_tool_button_set_label_widget (GTK_TOOL_BUTTON (item), label);
// g_signal_connect_swapped(item, "clicked", G_CALLBACK(goBackCallback), (gpointer)window);
gtk_toolbar_insert(GTK_TOOLBAR(window->bookmarkbar), item, -1);
gtk_widget_show_all(GTK_WIDGET(item));
/*
GtkToolItem *item = gtk_tool_button_new_from_stock(GTK_STOCK_HOME);
// g_signal_connect_swapped(item, "clicked", G_CALLBACK(goBackCallback), (gpointer)window);
gtk_toolbar_insert(GTK_TOOLBAR(window->bookmarkbar), item, -1);
gtk_widget_show(GTK_WIDGET(item));
*/
// GdkEventButton *eventButton = (GdkEventButton *)event;
//todo 弹出对话框
}
}
static void fm_tab_page_init(FmTabPage *page)
{
GtkPaned* paned = GTK_PANED(page);
FmTabLabel* tab_label;
FmFolderView* folder_view;
GList* focus_chain = NULL;
page->side_pane = fm_side_pane_new();
fm_side_pane_set_mode(FM_SIDE_PANE(page->side_pane), app_config->side_pane_mode);
/* TODO: add a close button to side pane */
gtk_paned_add1(paned, page->side_pane);
focus_chain = g_list_prepend(focus_chain, page->side_pane);
page->folder_view = fm_folder_view_new(app_config->view_mode);
folder_view = FM_FOLDER_VIEW(page->folder_view);
fm_folder_view_set_hint_type(folder_view, app_config->hint_type);
fm_folder_view_sort(folder_view, app_config->sort_type, app_config->sort_by);
fm_folder_view_set_selection_mode(folder_view, GTK_SELECTION_MULTIPLE);
page->nav_history = fm_nav_history_new();
gtk_paned_add2(paned, page->folder_view);
focus_chain = g_list_prepend(focus_chain, page->folder_view);
/* We need this to change tab order to focus folder view before left pane. */
gtk_container_set_focus_chain(page, focus_chain);
g_list_free(focus_chain);
gtk_widget_show_all(GTK_WIDGET(page));
/* create tab label */
tab_label = (FmTabLabel*)fm_tab_label_new("");
gtk_label_set_max_width_chars(tab_label->label, app_config->max_tab_chars);
gtk_label_set_ellipsize(tab_label->label, PANGO_ELLIPSIZE_END);
page->tab_label = GTK_WIDGET(tab_label);
g_signal_connect(page->folder_view, "sel-changed",
G_CALLBACK(on_folder_view_sel_changed), page);
g_signal_connect(page->folder_view, "loaded",
G_CALLBACK(on_folder_view_loaded), page);
/* the folder view is already loded, call the "loaded" callback ourself. */
if(fm_folder_view_get_is_loaded(folder_view))
on_folder_view_loaded(folder_view, fm_folder_view_get_cwd(folder_view), page);
}
static void
connect_proxy_cb (GtkActionGroup *action_group,
GtkAction *action,
GtkWidget *proxy,
NemoWindow *window)
{
GtkLabel *label;
if (!GTK_IS_MENU_ITEM (proxy))
return;
label = GTK_LABEL (gtk_bin_get_child (GTK_BIN (proxy)));
gtk_label_set_ellipsize (label, PANGO_ELLIPSIZE_END);
gtk_label_set_max_width_chars (label, MENU_ITEM_MAX_WIDTH_CHARS);
g_signal_connect (proxy, "select",
G_CALLBACK (menu_item_select_cb), window);
g_signal_connect (proxy, "deselect",
G_CALLBACK (menu_item_deselect_cb), window);
}
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));
}
LifereaHtmlView *
browser_tabs_add_new (const gchar *url, const gchar *title, gboolean activate)
{
GtkWidget *widget, *label, *toolbar, *htmlframe, *image;
tabInfo *tab;
int i;
tab = g_new0 (tabInfo, 1);
tab->widget = gtk_vbox_new (FALSE, 0);
tab->htmlview = liferea_htmlview_new (TRUE);
tab->history = browser_tab_history_new ();
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, "location-changed", G_CALLBACK (on_htmlview_location_changed), tab);
g_signal_connect (tab->htmlview, "statusbar-changed", G_CALLBACK (on_htmlview_status_message), NULL);
/* create tab widgets */
label = gtk_label_new (create_label_text (title));
gtk_label_set_ellipsize (GTK_LABEL(label), PANGO_ELLIPSIZE_END);
gtk_label_set_max_width_chars (GTK_LABEL(label), 17);
gtk_widget_show (label);
toolbar = gtk_hbox_new (FALSE, 6);
widget = gtk_button_new ();
gtk_button_set_relief (GTK_BUTTON (widget), GTK_RELIEF_NONE);
image = gtk_image_new_from_stock ("gtk-go-back", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (widget), image);
gtk_box_pack_start (GTK_BOX (toolbar), widget, FALSE, FALSE, 0);
g_signal_connect ((gpointer)widget, "clicked", G_CALLBACK (on_tab_history_back), (gpointer)tab);
gtk_widget_set_sensitive(widget, FALSE);
tab->back = widget;
widget = gtk_button_new ();
gtk_button_set_relief (GTK_BUTTON(widget), GTK_RELIEF_NONE);
image = gtk_image_new_from_stock ("gtk-go-forward", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (widget), image);
gtk_box_pack_start (GTK_BOX (toolbar), widget, FALSE, FALSE, 0);
g_signal_connect ((gpointer)widget, "clicked", G_CALLBACK (on_tab_history_forward), (gpointer)tab);
gtk_widget_set_sensitive (widget, FALSE);
tab->forward = widget;
widget = gtk_entry_new ();
gtk_entry_set_text (GTK_ENTRY (widget), url?url:"");
g_object_set_data (G_OBJECT (tab->widget), "url_entry", widget);
gtk_box_pack_start (GTK_BOX (toolbar), widget, TRUE, TRUE, 0);
g_signal_connect ((gpointer)widget, "activate", G_CALLBACK (on_tab_url_entry_activate), (gpointer)tab);
tab->urlentry = widget;
widget = gtk_button_new ();
gtk_button_set_relief (GTK_BUTTON(widget), GTK_RELIEF_NONE);
image = gtk_image_new_from_stock ("gtk-close", GTK_ICON_SIZE_BUTTON);
gtk_widget_show (image);
gtk_container_add (GTK_CONTAINER (widget), image);
gtk_box_pack_end (GTK_BOX (toolbar), widget, FALSE, FALSE, 0);
g_signal_connect ((gpointer)widget, "clicked", G_CALLBACK (on_htmlview_close_tab), (gpointer)tab);
htmlframe = gtk_frame_new (NULL);
gtk_frame_set_shadow_type (GTK_FRAME (htmlframe), GTK_SHADOW_IN);
gtk_container_add (GTK_CONTAINER (htmlframe), liferea_htmlview_get_widget (tab->htmlview));
gtk_box_pack_start (GTK_BOX (tab->widget), toolbar, FALSE, FALSE, 0);
gtk_box_pack_end (GTK_BOX (tab->widget), htmlframe, TRUE, TRUE, 0);
gtk_widget_show_all (tab->widget);
i = gtk_notebook_append_page (tabs->priv->notebook, tab->widget, label);
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) {
browser_tab_history_add_location (tab, (gchar *)url);
liferea_htmlview_launch_URL_internal (tab->htmlview, (gchar *)url);
}
return tab->htmlview;
}
GtkWindow* create_notification(UrlClickedCb url_clicked)
{
GtkWidget* win;
GtkWidget* main_vbox;
GtkWidget* vbox;
GtkWidget* close_button;
GtkWidget* image;
GtkWidget* alignment;
AtkObject* atkobj;
WindowData* windata;
GdkVisual *visual;
GdkScreen* screen;
windata = g_new0(WindowData, 1);
windata->urgency = URGENCY_NORMAL;
windata->url_clicked = url_clicked;
win = gtk_window_new(GTK_WINDOW_POPUP);
gtk_window_set_resizable(GTK_WINDOW(win), FALSE);
gtk_widget_set_app_paintable(win, TRUE);
g_signal_connect(G_OBJECT(win), "style-updated", G_CALLBACK(on_style_updated), windata);
g_signal_connect(G_OBJECT(win), "map-event", G_CALLBACK(on_window_map), windata);
g_signal_connect(G_OBJECT(win), "draw", G_CALLBACK(on_draw), windata);
g_signal_connect(G_OBJECT(win), "realize", G_CALLBACK(on_window_realize), windata);
windata->win = win;
windata->composited = FALSE;
screen = gtk_window_get_screen(GTK_WINDOW(win));
visual = gdk_screen_get_rgba_visual(screen);
if (visual != NULL)
{
gtk_widget_set_visual(win, visual);
if (gdk_screen_is_composited(screen))
{
windata->composited = TRUE;
}
}
g_signal_connect(win, "composited-changed", G_CALLBACK(on_composited_changed), windata);
gtk_window_set_title(GTK_WINDOW(win), "Notification");
gtk_window_set_type_hint(GTK_WINDOW(win), GDK_WINDOW_TYPE_HINT_NOTIFICATION);
gtk_widget_add_events(win, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK);
g_object_set_data_full(G_OBJECT(win), "windata", windata, (GDestroyNotify) destroy_windata);
atk_object_set_role(gtk_widget_get_accessible(win), ATK_ROLE_ALERT);
g_signal_connect(G_OBJECT(win), "configure-event", G_CALLBACK(on_configure_event), windata);
main_vbox = gtk_vbox_new(FALSE, 0);
#if GTK_CHECK_VERSION (3, 0, 0)
g_signal_connect(G_OBJECT(main_vbox), "style-updated", G_CALLBACK(on_style_updated), windata);
#else
g_signal_connect(G_OBJECT(main_vbox), "style-set", G_CALLBACK(on_style_set), windata);
#endif
gtk_widget_show(main_vbox);
gtk_container_add(GTK_CONTAINER(win), main_vbox);
gtk_container_set_border_width(GTK_CONTAINER(main_vbox), 12);
windata->main_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0);
gtk_widget_show(windata->main_hbox);
gtk_box_pack_start(GTK_BOX(main_vbox), windata->main_hbox, FALSE, FALSE, 0);
/* First row (icon, vbox, close) */
windata->iconbox = gtk_alignment_new(0.5, 0, 0, 0);
gtk_widget_show(windata->iconbox);
gtk_alignment_set_padding(GTK_ALIGNMENT(windata->iconbox), 5, 0, 0, 0);
gtk_box_pack_start(GTK_BOX(windata->main_hbox), windata->iconbox, FALSE, FALSE, 0);
gtk_widget_set_size_request(windata->iconbox, BODY_X_OFFSET, -1);
windata->icon = gtk_image_new();
gtk_widget_show(windata->icon);
gtk_container_add(GTK_CONTAINER(windata->iconbox), windata->icon);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(windata->main_hbox), vbox, TRUE, TRUE, 0);
gtk_container_set_border_width(GTK_CONTAINER(vbox), 10);
/* Add the close button */
alignment = gtk_alignment_new(0.5, 0, 0, 0);
gtk_widget_show(alignment);
gtk_box_pack_start(GTK_BOX(windata->main_hbox), alignment, FALSE, FALSE, 0);
close_button = gtk_button_new();
gtk_widget_show(close_button);
windata->close_button = close_button;
gtk_container_add(GTK_CONTAINER(alignment), close_button);
gtk_button_set_relief(GTK_BUTTON(close_button), GTK_RELIEF_NONE);
gtk_container_set_border_width(GTK_CONTAINER(close_button), 0);
g_signal_connect_swapped(G_OBJECT(close_button), "clicked", G_CALLBACK(gtk_widget_destroy), win);
atkobj = gtk_widget_get_accessible(close_button);
atk_action_set_description(ATK_ACTION(atkobj), 0, "Closes the notification.");
atk_object_set_name(atkobj, "");
atk_object_set_description(atkobj, "Closes the notification.");
image = gtk_image_new_from_icon_name ("window-close", GTK_ICON_SIZE_MENU);
gtk_widget_show(image);
gtk_container_add(GTK_CONTAINER(close_button), image);
/* center vbox */
windata->summary_label = gtk_label_new(NULL);
gtk_widget_show(windata->summary_label);
gtk_box_pack_start(GTK_BOX(vbox), windata->summary_label, TRUE, TRUE, 0);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (windata->summary_label), 0.0);
gtk_label_set_yalign (GTK_LABEL (windata->summary_label), 0.0);
#else
gtk_misc_set_alignment(GTK_MISC(windata->summary_label), 0.0, 0.0);
#endif
gtk_label_set_line_wrap(GTK_LABEL(windata->summary_label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (windata->summary_label), PANGO_WRAP_WORD_CHAR);
atkobj = gtk_widget_get_accessible(windata->summary_label);
atk_object_set_description(atkobj, "Notification summary text.");
windata->content_hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_widget_show(windata->content_hbox);
gtk_box_pack_start(GTK_BOX(vbox), windata->content_hbox, FALSE, FALSE, 0);
vbox = gtk_box_new(GTK_ORIENTATION_VERTICAL, 6);
gtk_widget_show(vbox);
gtk_box_pack_start(GTK_BOX(windata->content_hbox), vbox, TRUE, TRUE, 0);
windata->body_label = gtk_label_new(NULL);
gtk_widget_show(windata->body_label);
gtk_box_pack_start(GTK_BOX(vbox), windata->body_label, TRUE, TRUE, 0);
#if GTK_CHECK_VERSION (3, 16, 0)
gtk_label_set_xalign (GTK_LABEL (windata->body_label), 0.0);
gtk_label_set_yalign (GTK_LABEL (windata->body_label), 0.0);
#else
gtk_misc_set_alignment(GTK_MISC(windata->body_label), 0.0, 0.0);
#endif
gtk_label_set_line_wrap(GTK_LABEL(windata->body_label), TRUE);
gtk_label_set_line_wrap_mode (GTK_LABEL (windata->body_label), PANGO_WRAP_WORD_CHAR);
gtk_label_set_max_width_chars (GTK_LABEL (windata->body_label), 50);
g_signal_connect_swapped(G_OBJECT(windata->body_label), "activate-link", G_CALLBACK(windata->url_clicked), win);
atkobj = gtk_widget_get_accessible(windata->body_label);
atk_object_set_description(atkobj, "Notification body text.");
alignment = gtk_alignment_new(1, 0.5, 0, 0);
gtk_widget_show(alignment);
gtk_box_pack_start(GTK_BOX(vbox), alignment, FALSE, TRUE, 0);
windata->actions_box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
gtk_widget_show(windata->actions_box);
gtk_container_add(GTK_CONTAINER(alignment), windata->actions_box);
return GTK_WINDOW(win);
}
static void
photos_properties_dialog_constructed (GObject *object)
{
PhotosPropertiesDialog *self = PHOTOS_PROPERTIES_DIALOG (object);
GApplication *app;
g_autoptr (GDateTime) date_modified = NULL;
GtkStyleContext *context;
GtkWidget *author_w = NULL;
GtkWidget *content_area;
GtkWidget *date_created_w = NULL;
GtkWidget *date_modified_data;
GtkWidget *date_modified_w;
GtkWidget *dimensions_w = NULL;
GtkWidget *exposure_time_w = NULL;
GtkWidget *flash_w = NULL;
GtkWidget *fnumber_w = NULL;
GtkWidget *focal_length_w = NULL;
GtkWidget *iso_speed_w = NULL;
GtkWidget *item_type;
GtkWidget *item_type_data;
GtkWidget *modified_w = NULL;
GtkWidget *source;
GtkWidget *source_data;
GtkWidget *title;
GQuark equipment;
GQuark flash;
PhotosBaseItem *item;
PhotosSearchContextState *state;
const gchar *author;
const gchar *location;
const gchar *name;
const gchar *type_description;
g_autofree gchar *date_created_str = NULL;
g_autofree gchar *date_modified_str = NULL;
gdouble exposure_time;
gdouble fnumber;
gdouble focal_length;
gdouble iso_speed;
gint64 ctime;
gint64 mtime;
glong height;
glong width;
G_OBJECT_CLASS (photos_properties_dialog_parent_class)->constructed (object);
app = g_application_get_default ();
state = photos_search_context_get_state (PHOTOS_SEARCH_CONTEXT (app));
self->item_mngr = g_object_ref (state->item_mngr);
{
g_autoptr (GError) error = NULL;
self->queue = photos_tracker_queue_dup_singleton (NULL, &error);
if (G_UNLIKELY (error != NULL))
g_warning ("Unable to create PhotosTrackerQueue: %s", error->message);
}
item = PHOTOS_BASE_ITEM (photos_base_manager_get_object_by_id (self->item_mngr, self->urn));
mtime = photos_base_item_get_mtime (item);
date_modified = g_date_time_new_from_unix_local (mtime);
date_modified_str = g_date_time_format (date_modified, "%c");
ctime = photos_base_item_get_date_created (item);
if (ctime >= 0)
{
g_autoptr (GDateTime) date_created = NULL;
date_created = g_date_time_new_from_unix_local (ctime);
date_created_str = g_date_time_format (date_created, "%c");
}
self->grid = gtk_grid_new ();
gtk_widget_set_halign (self->grid, GTK_ALIGN_CENTER);
gtk_widget_set_margin_start (self->grid, 24);
gtk_widget_set_margin_end (self->grid, 24);
gtk_widget_set_margin_bottom (self->grid, 12);
gtk_widget_set_margin_top (self->grid, 12);
gtk_orientable_set_orientation (GTK_ORIENTABLE (self->grid), GTK_ORIENTATION_VERTICAL);
gtk_grid_set_column_homogeneous (GTK_GRID (self->grid), TRUE);
gtk_grid_set_column_spacing (GTK_GRID (self->grid), 24);
gtk_grid_set_row_homogeneous (GTK_GRID (self->grid), TRUE);
gtk_grid_set_row_spacing (GTK_GRID (self->grid), 6);
content_area = gtk_dialog_get_content_area (GTK_DIALOG (self));
gtk_box_pack_start (GTK_BOX (content_area), self->grid, TRUE, TRUE, 2);
/* Translators: this is the label next to the photo title in the
* properties dialog
*/
title = gtk_label_new (C_("Document Title", "Title"));
gtk_widget_set_halign (title, GTK_ALIGN_END);
context = gtk_widget_get_style_context (title);
gtk_style_context_add_class (context, "dim-label");
gtk_container_add (GTK_CONTAINER (self->grid), title);
author = photos_base_item_get_author (item);
if (author != NULL && author[0] != '\0')
{
/* Translators: this is the label next to the photo author in
* the properties dialog
*/
author_w = gtk_label_new (C_("Document Author", "Author"));
gtk_widget_set_halign (author_w, GTK_ALIGN_END);
context = gtk_widget_get_style_context (author_w);
gtk_style_context_add_class (context, "dim-label");
gtk_container_add (GTK_CONTAINER (self->grid), author_w);
}
source = gtk_label_new (_("Source"));
gtk_widget_set_halign (source, GTK_ALIGN_END);
context = gtk_widget_get_style_context (source);
gtk_style_context_add_class (context, "dim-label");
gtk_container_add (GTK_CONTAINER (self->grid), source);
date_modified_w = gtk_label_new (_("Date Modified"));
gtk_widget_set_halign (date_modified_w, GTK_ALIGN_END);
context = gtk_widget_get_style_context (date_modified_w);
gtk_style_context_add_class (context, "dim-label");
gtk_container_add (GTK_CONTAINER (self->grid), date_modified_w);
if (date_created_str != NULL)
{
date_created_w = gtk_label_new (_("Date Created"));
gtk_widget_set_halign (date_created_w, GTK_ALIGN_END);
context = gtk_widget_get_style_context (date_created_w);
gtk_style_context_add_class (context, "dim-label");
gtk_container_add (GTK_CONTAINER (self->grid), date_created_w);
}
/* Translators: this is the label next to the photo type in the
* properties dialog
*/
item_type = gtk_label_new (C_("Document Type", "Type"));
gtk_widget_set_halign (item_type, GTK_ALIGN_END);
context = gtk_widget_get_style_context (item_type);
gtk_style_context_add_class (context, "dim-label");
gtk_container_add (GTK_CONTAINER (self->grid), item_type);
height = (glong) photos_base_item_get_height (item);
width = (glong) photos_base_item_get_width (item);
if (height > 0 && width > 0)
{
dimensions_w = gtk_label_new (_("Dimensions"));
gtk_widget_set_halign (dimensions_w, GTK_ALIGN_END);
context = gtk_widget_get_style_context (dimensions_w);
gtk_style_context_add_class (context, "dim-label");
gtk_container_add (GTK_CONTAINER (self->grid), dimensions_w);
}
location = photos_base_item_get_location (item);
if (location != NULL && location[0] != '\0' && G_LIKELY (self->queue != NULL))
{
g_autoptr (PhotosQuery) query = NULL;
self->location_w = gtk_label_new (_("Location"));
gtk_widget_set_halign (self->location_w, GTK_ALIGN_END);
context = gtk_widget_get_style_context (self->location_w);
gtk_style_context_add_class (context, "dim-label");
gtk_container_add (GTK_CONTAINER (self->grid), self->location_w);
query = photos_query_builder_location_query (state, location);
photos_tracker_queue_select (self->queue,
query,
NULL,
photos_properties_dialog_location_query_executed,
g_object_ref (self),
g_object_unref);
}
equipment = photos_base_item_get_equipment (item);
if (equipment != 0)
{
self->camera_w = gtk_label_new (_("Camera"));
gtk_widget_set_halign (self->camera_w, GTK_ALIGN_END);
context = gtk_widget_get_style_context (self->camera_w);
gtk_style_context_add_class (context, "dim-label");
gtk_container_add (GTK_CONTAINER (self->grid), self->camera_w);
}
exposure_time = photos_base_item_get_exposure_time (item);
if (exposure_time > 0.0)
{
exposure_time_w = gtk_label_new (_("Exposure"));
gtk_widget_set_halign (exposure_time_w, GTK_ALIGN_END);
context = gtk_widget_get_style_context (exposure_time_w);
gtk_style_context_add_class (context, "dim-label");
gtk_container_add (GTK_CONTAINER (self->grid), exposure_time_w);
}
fnumber = photos_base_item_get_fnumber (item);
if (fnumber > 0.0)
{
fnumber_w = gtk_label_new (_("Aperture"));
gtk_widget_set_halign (fnumber_w, GTK_ALIGN_END);
context = gtk_widget_get_style_context (fnumber_w);
gtk_style_context_add_class (context, "dim-label");
gtk_container_add (GTK_CONTAINER (self->grid), fnumber_w);
}
focal_length = photos_base_item_get_focal_length (item);
if (focal_length > 0.0)
{
focal_length_w = gtk_label_new (_("Focal Length"));
gtk_widget_set_halign (focal_length_w, GTK_ALIGN_END);
context = gtk_widget_get_style_context (focal_length_w);
gtk_style_context_add_class (context, "dim-label");
gtk_container_add (GTK_CONTAINER (self->grid), focal_length_w);
}
iso_speed = photos_base_item_get_iso_speed (item);
if (iso_speed > 0.0)
{
iso_speed_w = gtk_label_new (_("ISO Speed"));
gtk_widget_set_halign (iso_speed_w, GTK_ALIGN_END);
context = gtk_widget_get_style_context (iso_speed_w);
gtk_style_context_add_class (context, "dim-label");
gtk_container_add (GTK_CONTAINER (self->grid), iso_speed_w);
}
flash = photos_base_item_get_flash (item);
if (flash != 0)
{
flash_w = gtk_label_new (_("Flash"));
gtk_widget_set_halign (flash_w, GTK_ALIGN_END);
context = gtk_widget_get_style_context (flash_w);
gtk_style_context_add_class (context, "dim-label");
gtk_container_add (GTK_CONTAINER (self->grid), flash_w);
}
if (!photos_base_item_is_collection (item))
{
modified_w = gtk_label_new (_("Modifications"));
gtk_widget_set_halign (modified_w, GTK_ALIGN_END);
gtk_widget_set_valign (modified_w, GTK_ALIGN_BASELINE);
gtk_widget_set_vexpand (modified_w, TRUE);
context = gtk_widget_get_style_context (modified_w);
gtk_style_context_add_class (context, "dim-label");
gtk_container_add (GTK_CONTAINER (self->grid), modified_w);
}
name = photos_base_item_get_name (item);
if (PHOTOS_IS_LOCAL_ITEM (item))
{
self->title_entry = gtk_entry_new ();
gtk_widget_set_halign (self->title_entry, GTK_ALIGN_START);
gtk_widget_set_hexpand (self->title_entry, TRUE);
gtk_entry_set_activates_default (GTK_ENTRY (self->title_entry), TRUE);
gtk_entry_set_text (GTK_ENTRY (self->title_entry), name);
gtk_entry_set_width_chars (GTK_ENTRY (self->title_entry), 40);
gtk_editable_set_editable (GTK_EDITABLE (self->title_entry), TRUE);
g_signal_connect (self->title_entry,
"changed",
G_CALLBACK (photos_properties_dialog_title_entry_changed),
self);
}
else
{
self->title_entry = gtk_label_new (name);
gtk_widget_set_halign (self->title_entry, GTK_ALIGN_START);
gtk_label_set_ellipsize (GTK_LABEL (self->title_entry), PANGO_ELLIPSIZE_END);
gtk_label_set_max_width_chars (GTK_LABEL (self->title_entry), 40);
}
gtk_grid_attach_next_to (GTK_GRID (self->grid), self->title_entry, title, GTK_POS_RIGHT, 2, 1);
if (author_w != NULL)
{
GtkWidget *author_data;
author_data = gtk_label_new (author);
gtk_widget_set_halign (author_data, GTK_ALIGN_START);
gtk_grid_attach_next_to (GTK_GRID (self->grid), author_data, author_w, GTK_POS_RIGHT, 2, 1);
}
source_data = photos_base_item_get_source_widget (item);
gtk_grid_attach_next_to (GTK_GRID (self->grid), source_data, source, GTK_POS_RIGHT, 2, 1);
date_modified_data = gtk_label_new (date_modified_str);
gtk_widget_set_halign (date_modified_data, GTK_ALIGN_START);
gtk_grid_attach_next_to (GTK_GRID (self->grid), date_modified_data, date_modified_w, GTK_POS_RIGHT, 2, 1);
if (date_created_w != NULL)
{
GtkWidget *date_created_data;
date_created_data = gtk_label_new (date_created_str);
gtk_widget_set_halign (date_created_data, GTK_ALIGN_START);
gtk_grid_attach_next_to (GTK_GRID (self->grid), date_created_data, date_created_w, GTK_POS_RIGHT, 2, 1);
}
type_description = photos_base_item_get_type_description (item);
item_type_data = gtk_label_new (type_description);
gtk_widget_set_halign (item_type_data, GTK_ALIGN_START);
gtk_grid_attach_next_to (GTK_GRID (self->grid), item_type_data, item_type, GTK_POS_RIGHT, 2, 1);
if (dimensions_w != NULL)
{
GtkWidget *dims_data;
g_autofree gchar *dims_str = NULL;
gulong n = (gulong) height;
dims_str = g_strdup_printf (ngettext ("%ld × %ld pixel", "%ld × %ld pixels", n), width, height);
dims_data = gtk_label_new (dims_str);
gtk_widget_set_halign (dims_data, GTK_ALIGN_START);
gtk_grid_attach_next_to (GTK_GRID (self->grid), dims_data, dimensions_w, GTK_POS_RIGHT, 2, 1);
}
if (self->camera_w != NULL)
{
photos_camera_cache_get_camera_async (self->camera_cache,
equipment,
self->cancellable,
photos_properties_dialog_get_camera,
self);
}
if (exposure_time_w != NULL)
{
GtkWidget *exposure_time_data;
g_autofree gchar *exposure_time_str = NULL;
exposure_time_str = g_strdup_printf ("%.3lf sec", exposure_time);
exposure_time_data = gtk_label_new (exposure_time_str);
gtk_widget_set_halign (exposure_time_data, GTK_ALIGN_START);
gtk_grid_attach_next_to (GTK_GRID (self->grid), exposure_time_data, exposure_time_w, GTK_POS_RIGHT, 2, 1);
}
if (fnumber_w != NULL)
{
GtkWidget *fnumber_data;
g_autofree gchar *fnumber_str = NULL;
fnumber_str = g_strdup_printf ("f/%.1lf", fnumber);
fnumber_data = gtk_label_new (fnumber_str);
gtk_widget_set_halign (fnumber_data, GTK_ALIGN_START);
gtk_grid_attach_next_to (GTK_GRID (self->grid), fnumber_data, fnumber_w, GTK_POS_RIGHT, 2, 1);
}
if (focal_length_w != NULL)
{
GtkWidget *focal_length_data;
g_autofree gchar *focal_length_str = NULL;
focal_length_str = g_strdup_printf ("%.0lf mm", focal_length);
focal_length_data = gtk_label_new (focal_length_str);
gtk_widget_set_halign (focal_length_data, GTK_ALIGN_START);
gtk_grid_attach_next_to (GTK_GRID (self->grid), focal_length_data, focal_length_w, GTK_POS_RIGHT, 2, 1);
}
if (iso_speed_w != NULL)
{
GtkWidget *iso_speed_data;
g_autofree gchar *iso_speed_str = NULL;
iso_speed_str = g_strdup_printf ("%.0lf", iso_speed);
iso_speed_data = gtk_label_new (iso_speed_str);
gtk_widget_set_halign (iso_speed_data, GTK_ALIGN_START);
gtk_grid_attach_next_to (GTK_GRID (self->grid), iso_speed_data, iso_speed_w, GTK_POS_RIGHT, 2, 1);
}
if (flash_w != NULL)
{
GtkWidget *flash_data;
g_autofree gchar *flash_str = NULL;
if (flash == PHOTOS_FLASH_OFF)
flash_str = g_strdup (_("Off, did not fire"));
else if (flash == PHOTOS_FLASH_ON)
flash_str = g_strdup (_("On, fired"));
else
{
const gchar *str;
str = g_quark_to_string (flash);
g_warning ("Unknown value for nmm:flash: %s", str);
}
flash_data = gtk_label_new (flash_str);
gtk_widget_set_halign (flash_data, GTK_ALIGN_START);
gtk_grid_attach_next_to (GTK_GRID (self->grid), flash_data, flash_w, GTK_POS_RIGHT, 2, 1);
}
if (modified_w != NULL)
{
GtkWidget *modified_grid;
photos_base_item_pipeline_is_edited_async (item,
self->cancellable,
photos_properties_dialog_pipeline_is_edited,
self);
modified_grid = gtk_grid_new ();
gtk_widget_set_hexpand (modified_grid, TRUE);
gtk_orientable_set_orientation (GTK_ORIENTABLE (modified_grid), GTK_ORIENTATION_HORIZONTAL);
self->modified_data = gtk_label_new (NULL);
gtk_widget_set_halign (self->modified_data, GTK_ALIGN_START);
gtk_widget_set_hexpand (self->modified_data, TRUE);
gtk_widget_set_no_show_all (self->modified_data, TRUE);
gtk_widget_set_valign (self->modified_data, GTK_ALIGN_BASELINE);
gtk_widget_set_vexpand (self->modified_data, TRUE);
context = gtk_widget_get_style_context (self->modified_data);
gtk_style_context_add_class (context, "photos-fade-out");
gtk_container_add (GTK_CONTAINER (modified_grid), self->modified_data);
self->revert_button = gtk_button_new_with_label (_("Discard all Edits"));
gtk_widget_set_halign (self->revert_button, GTK_ALIGN_END);
gtk_widget_set_hexpand (self->revert_button, TRUE);
gtk_widget_set_no_show_all (self->revert_button, TRUE);
context = gtk_widget_get_style_context (self->revert_button);
gtk_style_context_add_class (context, "destructive-action");
gtk_style_context_add_class (context, "photos-fade-out");
gtk_container_add (GTK_CONTAINER (modified_grid), self->revert_button);
g_signal_connect_swapped (self->revert_button,
"clicked",
G_CALLBACK (photos_properties_dialog_revert_clicked),
self);
gtk_grid_attach_next_to (GTK_GRID (self->grid), modified_grid, modified_w, GTK_POS_RIGHT, 2, 1);
}
}
static void
empathy_local_xmpp_assistant_widget_constructed (GObject *object)
{
EmpathyLocalXmppAssistantWidget *self = (EmpathyLocalXmppAssistantWidget *)
object;
GtkWidget *w;
GdkPixbuf *pix;
TpawAccountWidget *account_widget;
gchar *markup;
G_OBJECT_CLASS (empathy_local_xmpp_assistant_widget_parent_class)->
constructed (object);
gtk_container_set_border_width (GTK_CONTAINER (self), 12);
w = gtk_label_new (
_("Empathy can automatically discover and chat with the people "
"connected on the same network as you. "
"If you want to use this feature, please check that the "
"details below are correct."));
gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
gtk_label_set_max_width_chars (GTK_LABEL (w), 60);
gtk_grid_attach (GTK_GRID (self), w, 0, 0, 1, 1);
gtk_widget_show (w);
pix = tpaw_pixbuf_from_icon_name_sized ("im-local-xmpp", 48);
if (pix != NULL)
{
w = gtk_image_new_from_pixbuf (pix);
gtk_grid_attach (GTK_GRID (self), w, 1, 0, 1, 1);
gtk_widget_show (w);
g_object_unref (pix);
}
self->priv->settings = tpaw_account_settings_new ("salut", "local-xmpp",
NULL, _("People nearby"));
account_widget = tpaw_account_widget_new_for_protocol (
self->priv->settings, NULL, TRUE);
tpaw_account_widget_hide_buttons (account_widget);
g_signal_connect (account_widget, "handle-apply",
G_CALLBACK (handle_apply_cb), self);
gtk_grid_attach (GTK_GRID (self), GTK_WIDGET (account_widget), 0, 1, 2, 1);
gtk_widget_show (GTK_WIDGET (account_widget));
w = gtk_label_new (NULL);
markup = g_strdup_printf (
"<span size=\"small\">%s</span>",
_("You can change these details later or disable this feature "
"by choosing <span style=\"italic\">Edit → Accounts</span> "
"in the Contact List."));
gtk_label_set_markup (GTK_LABEL (w), markup);
g_free (markup);
gtk_misc_set_alignment (GTK_MISC (w), 0, 0.5);
gtk_label_set_line_wrap (GTK_LABEL (w), TRUE);
gtk_grid_attach (GTK_GRID (self), w, 0, 2, 2, 1);
gtk_widget_show (w);
}
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;
}
/* Public VpnPasswordDialog methods */
GtkWidget *
vpn_password_dialog_new (const char *title,
const char *message,
const char *password)
{
GtkWidget *dialog;
VpnPasswordDialogPrivate *priv;
GtkLabel *message_label;
GtkWidget *hbox;
GtkWidget *vbox;
GtkWidget *main_vbox;
GtkWidget *dialog_icon;
GtkBox *content, *action_area;
dialog = gtk_widget_new (VPN_TYPE_PASSWORD_DIALOG, NULL);
if (!dialog)
return NULL;
priv = VPN_PASSWORD_DIALOG_GET_PRIVATE (dialog);
gtk_window_set_title (GTK_WINDOW (dialog), title);
gtk_window_set_resizable (GTK_WINDOW (dialog), FALSE);
#if !GTK_CHECK_VERSION(3,10,0)
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
#else
gtk_dialog_add_buttons (GTK_DIALOG (dialog),
_Cancel, GTK_RESPONSE_CANCEL,
_OK, GTK_RESPONSE_OK,
NULL);
#endif
gtk_dialog_set_default_response (GTK_DIALOG (dialog), GTK_RESPONSE_OK);
content = GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog)));
action_area = GTK_BOX (gtk_dialog_get_action_area (GTK_DIALOG (dialog)));
/* Set up the dialog */
gtk_container_set_border_width (GTK_CONTAINER (dialog), 5);
gtk_box_set_spacing (content, 2); /* 2 * 5 + 2 = 12 */
gtk_container_set_border_width (GTK_CONTAINER (action_area), 5);
gtk_box_set_spacing (action_area, 6);
gtk_window_set_position (GTK_WINDOW (dialog), GTK_WIN_POS_CENTER);
gtk_window_set_modal (GTK_WINDOW (dialog), TRUE);
g_signal_connect (dialog, "show",
G_CALLBACK (dialog_show_callback),
dialog);
g_signal_connect (dialog, "close",
G_CALLBACK (dialog_close_callback),
dialog);
/* The grid that holds the captions */
priv->grid_alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.0);
priv->group = gtk_size_group_new (GTK_SIZE_GROUP_HORIZONTAL);
priv->grid = gtk_grid_new ();
gtk_grid_set_column_spacing (GTK_GRID (priv->grid), 12);
gtk_grid_set_row_spacing (GTK_GRID (priv->grid), 6);
gtk_container_add (GTK_CONTAINER (priv->grid_alignment), priv->grid);
priv->password_entry = gtk_entry_new ();
priv->password_entry_secondary = gtk_entry_new ();
priv->show_passwords_checkbox = gtk_check_button_new_with_mnemonic (_("Sh_ow passwords"));
/* We want to hold on to these during the grid rearrangement */
g_object_ref_sink (priv->password_entry);
g_object_ref_sink (priv->password_entry_secondary);
g_object_ref_sink (priv->show_passwords_checkbox);
gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry), FALSE);
gtk_entry_set_visibility (GTK_ENTRY (priv->password_entry_secondary), FALSE);
g_signal_connect_swapped (priv->password_entry, "activate",
G_CALLBACK (gtk_window_activate_default),
dialog);
g_signal_connect_swapped (priv->password_entry_secondary, "activate",
G_CALLBACK (gtk_window_activate_default),
dialog);
g_signal_connect (priv->show_passwords_checkbox, "toggled",
G_CALLBACK (show_passwords_toggled_cb),
dialog);
add_grid_rows (VPN_PASSWORD_DIALOG (dialog));
/* Adds some eye-candy to the dialog */
hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 12);
gtk_container_set_border_width (GTK_CONTAINER (hbox), 5);
#if !GTK_CHECK_VERSION(3,10,0)
dialog_icon = gtk_image_new_from_stock(GTK_STOCK_DIALOG_AUTHENTICATION, GTK_ICON_SIZE_DIALOG);
#else
dialog_icon = gtk_image_new_from_icon_name("dialog-password", GTK_ICON_SIZE_DIALOG);
#endif
gtk_misc_set_alignment (GTK_MISC (dialog_icon), 0.5, 0.0);
gtk_box_pack_start (GTK_BOX (hbox), dialog_icon, FALSE, FALSE, 0);
/* Fills the vbox */
main_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 18);
if (message) {
message_label = GTK_LABEL (gtk_label_new (message));
gtk_label_set_justify (message_label, GTK_JUSTIFY_LEFT);
gtk_label_set_line_wrap (message_label, TRUE);
gtk_label_set_max_width_chars (message_label, 35);
gtk_size_group_add_widget (priv->group, GTK_WIDGET (message_label));
gtk_box_pack_start (GTK_BOX (main_vbox), GTK_WIDGET (message_label), FALSE, FALSE, 0);
gtk_size_group_add_widget (priv->group, priv->grid_alignment);
}
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_box_pack_start (GTK_BOX (main_vbox), vbox, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (vbox), priv->grid_alignment, FALSE, FALSE, 0);
gtk_box_pack_start (GTK_BOX (hbox), main_vbox, FALSE, FALSE, 0);
gtk_box_pack_start (content, hbox, FALSE, FALSE, 0);
gtk_widget_show_all (GTK_WIDGET (content));
vpn_password_dialog_set_password (VPN_PASSWORD_DIALOG (dialog), password);
return GTK_WIDGET (dialog);
}
static void macmenu_construct(AppletType* applet)
{
MacMenu *mmb = g_slice_new0(MacMenu);
mmb->applet = applet;
mmb->screen = wnck_screen_get(gdk_screen_get_number(
gtk_widget_get_screen(GTK_WIDGET(applet))
));
mmb->mbars_scks = g_hash_table_new(NULL, NULL);
mmb->title_subs = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
mmb->ts_mtime = 0;
mmb->basebox = GTK_BOX(gtk_hbox_new(FALSE, 0));
gtk_container_set_border_width(GTK_CONTAINER(mmb->basebox), 0);
gtk_container_add(GTK_CONTAINER(applet), GTK_WIDGET(mmb->basebox));
mmb->label = GTK_LABEL(gtk_label_new(MAIN_LABEL_TEXT));
PangoAttrList *pattr = pango_attr_list_new();
PangoAttribute *pa = pango_attr_weight_new(PANGO_WEIGHT_BOLD);
pa->start_index = 0; pa->end_index = 1024;
pango_attr_list_insert(pattr, pa);
gtk_label_set_attributes(mmb->label, pattr);
pango_attr_list_unref(pattr);
gtk_label_set_ellipsize(mmb->label, PANGO_ELLIPSIZE_END);
gtk_label_set_max_width_chars(mmb->label, MAX_LABEL_WIDTH_N_CHARS * 10);
gtk_label_set_single_line_mode(mmb->label, TRUE);
gtk_box_pack_start(mmb->basebox, GTK_WIDGET(mmb->label), FALSE, FALSE, 0);
mmb->label_space = gtk_event_box_new();
gtk_widget_set_size_request(mmb->label_space, 8, 1);
gtk_box_pack_start(mmb->basebox, mmb->label_space, FALSE, FALSE, 0);
mmb->notebook = GTK_NOTEBOOK(gtk_notebook_new());
gtk_notebook_set_show_tabs(mmb->notebook, FALSE);
gtk_notebook_set_show_border(mmb->notebook, FALSE);
gtk_box_pack_start(mmb->basebox, GTK_WIDGET(mmb->notebook), TRUE, TRUE, 0);
mmb->dummysck = gtk_hbox_new(FALSE, 0);
gtk_notebook_append_page(mmb->notebook, mmb->dummysck, NULL);
mmb->mainsck = gtk_hbox_new(FALSE, SHORTCUT_SPACING);
gtk_notebook_append_page(mmb->notebook, mmb->mainsck, NULL);
//initialize_mainsck(mmb);
mmb->button = GTK_BUTTON(gtk_button_new());
gtk_button_set_relief(mmb->button, GTK_RELIEF_NONE);
gtk_button_set_focus_on_click(GTK_BUTTON(mmb->button), FALSE);
gtk_box_pack_start(mmb->basebox, GTK_WIDGET(mmb->button),
FALSE, FALSE, 0);
g_signal_connect(mmb->screen, "active-window-changed",
G_CALLBACK(desktop_active_window_changed), mmb);
g_signal_connect(mmb->screen, "window-opened",
G_CALLBACK(desktop_window_opened), mmb);
#ifdef FOR_XFCE
g_signal_connect(applet, "free-data",
G_CALLBACK(macmenu_free_data), mmb);
g_signal_connect(applet, "size-changed",
G_CALLBACK(macmenu_set_size), mmb);
// setup panel applet
gtk_widget_show_all(GTK_WIDGET(mmb->basebox));
xfce_panel_plugin_add_action_widget (applet, GTK_WIDGET(mmb->button));
xfce_panel_plugin_set_expand(applet, TRUE);
macmenu_set_size(applet, xfce_panel_plugin_get_size(applet), mmb);
// load config, set popup
macmenu_load_from_rc(mmb);
GtkWidget* label_toggle = gtk_check_menu_item_new_with_label("Hide Label");
g_signal_connect(label_toggle, "toggled", G_CALLBACK(on_label_toggled), mmb);
gtk_widget_show(label_toggle);
gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(label_toggle), mmb->hide_label);
gtk_check_menu_item_toggled(GTK_CHECK_MENU_ITEM(label_toggle));
xfce_panel_plugin_menu_insert_item(mmb->applet, GTK_MENU_ITEM(label_toggle));
#elif FOR_GNOME
g_signal_connect(applet, "destroy", G_CALLBACK(macmenu_free_data), mmb);
// setup panel applet
gtk_widget_show_all(GTK_WIDGET(applet));
g_signal_connect(GTK_WIDGET(mmb->button), "pressed",
G_CALLBACK(on_button_pressed), mmb);
panel_applet_set_flags (applet, PANEL_APPLET_EXPAND_MAJOR);
macmenu_set_size(applet, panel_applet_get_size(applet), mmb);
// load config, set popup
mmb->gconf = gconf_client_get_default();
macmenu_load_from_gconf(mmb);
macmenu_write_gconf(mmb);
static const char toggle_menu_xml [] =
"<popup name=\"button3\">\n"
" <menuitem name=\"hide_label\" "
" verb=\"hide_label\" "
" _label=\"_Hide Label\"\n"
" type=\"toggle\"/>\n"
"</popup>\n";
static const BonoboUIVerb toggle_menu_verbs[] =
{
BONOBO_UI_VERB_END
};
panel_applet_setup_menu(mmb->applet, toggle_menu_xml, toggle_menu_verbs, mmb);
BonoboUIComponent* popup_component = panel_applet_get_popup_component(mmb->applet);
bonobo_ui_component_set_prop(popup_component, "/commands/hide_label",
"state", mmb->hide_label ? "1": "0", NULL);
bonobo_ui_component_add_listener(panel_applet_get_popup_component(mmb->applet),
"hide_label",
(BonoboUIListenerFn) on_label_toggled,
mmb);
on_label_toggled(NULL, NULL, 0, NULL, mmb);
#endif // FOR_XFCE/FOR_GNOME
add_all(mmb);
XSetErrorHandler(handle_x_error);
}
