void
gedit_recent_add_document (GeditDocument *document)
{
GtkRecentManager *recent_manager;
GtkRecentData *recent_data;
GtkSourceFile *file;
GFile *location;
gchar *uri;
g_return_if_fail (GEDIT_IS_DOCUMENT (document));
static gchar *groups[2] = {
"gedit",
NULL
};
file = gedit_document_get_file (document);
location = gtk_source_file_get_location (file);
if (location != NULL)
{
recent_manager = gtk_recent_manager_get_default ();
recent_data = g_slice_new (GtkRecentData);
recent_data->display_name = NULL;
recent_data->description = NULL;
recent_data->mime_type = gedit_document_get_mime_type (document);
recent_data->app_name = (gchar *) g_get_application_name ();
recent_data->app_exec = g_strjoin (" ", g_get_prgname (), "%u", NULL);
recent_data->groups = groups;
recent_data->is_private = FALSE;
uri = g_file_get_uri (location);
if (!gtk_recent_manager_add_full (recent_manager, uri, recent_data))
{
g_warning ("Failed to add uri '%s' to the recent manager.", uri);
}
g_free (uri);
g_free (recent_data->app_exec);
g_free (recent_data->mime_type);
g_slice_free (GtkRecentData, recent_data);
}
}
void wxFileHistory::AddFileToHistory(const wxString& file)
{
wxFileHistoryBase::AddFileToHistory(file);
#ifdef __WXGTK210__
const wxString fullPath = wxFileName(file).GetFullPath();
#ifndef __WXGTK3__
if ( !gtk_check_version(2,10,0) )
#endif
{
wxGtkString uri(g_filename_to_uri(wxGTK_CONV_FN(fullPath), NULL, NULL));
if ( uri )
gtk_recent_manager_add_item(gtk_recent_manager_get_default(), uri);
}
#endif
}
void RecentManager::updateMenu() {
XOJ_CHECK_TYPE(RecentManager);
GtkRecentManager * recentManager = gtk_recent_manager_get_default();
GList * items = gtk_recent_manager_get_items(recentManager);
GList * filteredItemsXoj = filterRecent(items, true);
GList * filteredItemsPdf = filterRecent(items, false);
freeOldMenus();
int i = 0;
for (GList * l = filteredItemsXoj; l != NULL; l = l->next) {
GtkRecentInfo * info = (GtkRecentInfo *) l->data;
if (i >= maxRecent) {
break;
}
i++;
addRecentMenu(info, i);
}
GtkWidget * separator = gtk_separator_menu_item_new();
gtk_menu_shell_append(GTK_MENU_SHELL(menu), separator);
gtk_widget_set_visible(GTK_WIDGET(separator), true);
this->menuItemList = g_list_append(this->menuItemList, separator);
i = 0;
for (GList * l = filteredItemsPdf; l != NULL; l = l->next) {
GtkRecentInfo * info = (GtkRecentInfo *) l->data;
if (i >= maxRecent) {
break;
}
i++;
addRecentMenu(info, i + maxRecent);
}
g_list_free(filteredItemsXoj);
g_list_free(filteredItemsPdf);
g_list_foreach(items, (GFunc) gtk_recent_info_unref, NULL);
g_list_free(items);
}
static gboolean
recent_backend_mount (GVfsBackend *vfs_backend,
GVfsJobMount *job,
GMountSpec *mount_spec,
GMountSource *mount_source,
gboolean is_automount)
{
GVfsBackendRecent *backend = G_VFS_BACKEND_RECENT (vfs_backend);
backend->recent_manager = gtk_recent_manager_get_default ();
g_signal_connect (backend->recent_manager,
"changed",
G_CALLBACK (on_recent_manager_changed),
backend);
reload_recent_items (backend);
g_vfs_job_succeeded (G_VFS_JOB (job));
return TRUE;
}
QStringList On::recentFiles() {
QStringList recent;
GtkRecentManager *manager = gtk_recent_manager_get_default();
GList *list = gtk_recent_manager_get_items(manager);
GtkRecentInfo *item;
int i = 0;
GFOREACH(item, list) {
recent.append(QUrl::fromEncoded(gtk_recent_info_get_uri(item)).toString());
recent.append(QUrl::fromEncoded(gtk_recent_info_get_display_name(item)).toString());
recent.append(gdkPixbufToBase64(gtk_recent_info_get_icon(item, iconSize)));
if (i == 50) {
gtk_recent_info_unref(item);
g_list_free(list);
return recent;
}
i++;
}
static GtkListStore *
get_list_store(const gchar *recent_group)
{
GtkRecentManager *manager = gtk_recent_manager_get_default();
GtkListStore *store = gtk_list_store_new(2, G_TYPE_STRING, G_TYPE_STRING);
GList *ptr;
int count = 0;
GtkTreeIter iter;
GList *list = gtk_recent_manager_get_items(manager);
for (ptr = list; (ptr != NULL) && (count < 10); ptr = ptr->next)
{
GtkRecentInfo *info = ptr->data;
if (!gtk_recent_info_has_application(info, "KCemu"))
continue;
if ((recent_group != NULL) && !gtk_recent_info_has_group(info, recent_group))
continue;
GFile *file = g_file_new_for_uri(gtk_recent_info_get_uri(info));
if (g_file_is_native(file) /* && g_file_query_exists(file, NULL) */)
{
gchar *path = g_file_get_path(file);
gchar *basename = g_file_get_basename(file);
if ((path != NULL) && (basename != NULL))
{
gtk_list_store_append(store, &iter);
gtk_list_store_set(store, &iter, 0, basename, 1, path, -1);
count++;
}
g_free(path);
g_free(basename);
}
g_object_unref(file);
}
return store;
}
void
gedit_recent_remove_if_local (GFile *location)
{
g_return_if_fail (G_IS_FILE (location));
/* If a file is local chances are that if load/save fails the file has
* beed removed and the failure is permanent so we remove it from the
* list of recent files. For remote files the failure may be just
* transitory and we keep the file in the list.
*/
if (g_file_has_uri_scheme (location, "file"))
{
GtkRecentManager *recent_manager;
gchar *uri;
recent_manager = gtk_recent_manager_get_default ();
uri = g_file_get_uri (location);
gtk_recent_manager_remove_item (recent_manager, uri, NULL);
g_free (uri);
}
}
/* Clean up when the pipeline is finished
*/
static void
recorder_pipeline_closed (RecorderPipeline *pipeline)
{
g_signal_handlers_disconnect_by_func (pipeline->src,
(gpointer) recorder_pipeline_on_memory_used_changed,
pipeline);
recorder_disconnect_stage_callbacks (pipeline->recorder);
gst_element_set_state (pipeline->pipeline, GST_STATE_NULL);
if (pipeline->recorder)
{
GtkRecentManager *recent_manager;
GFile *file;
char *uri;
ShellRecorder *recorder = pipeline->recorder;
if (pipeline == recorder->current_pipeline)
{
/* Error case; force a close */
recorder->current_pipeline = NULL;
shell_recorder_close (recorder);
}
recent_manager = gtk_recent_manager_get_default ();
file = g_file_new_for_path (pipeline->filename);
uri = g_file_get_uri (file);
gtk_recent_manager_add_item (recent_manager,
uri);
g_free (uri);
g_object_unref (file);
recorder->pipelines = g_slist_remove (recorder->pipelines, pipeline);
}
recorder_pipeline_free (pipeline);
}
static void
build_recent_projects (GtkWidget *box, Starter *wcm)
{
GtkRecentManager *manager;
GList *list;
gint limit = 1000;
gint i = 0;
manager = gtk_recent_manager_get_default ();
list = gtk_recent_manager_get_items (manager);
while (i < limit && list != NULL)
{
if (strcmp (gtk_recent_info_get_mime_type (list->data), "application/x-anjuta") == 0)
{
GtkWidget *button;
GFile *file;
button = anjuta_starter_button_new (gtk_recent_info_get_display_name (list->data));
gtk_widget_show (button);
gtk_box_pack_start (GTK_BOX (box), button, TRUE, TRUE, 0);
file = g_file_new_for_uri (gtk_recent_info_get_uri (list->data));
g_object_set_data_full (G_OBJECT (button), "file", file,
(GDestroyNotify)destroy_notify);
g_signal_connect (button, "clicked",
G_CALLBACK (recent_project_clicked_cb),
wcm);
}
i++;
list = g_list_next (list);
}
g_list_foreach (list, (GFunc)gtk_recent_info_unref, NULL);
g_list_free (list);
}
void
empathy_send_file (EmpathyContact *contact,
GFile *file)
{
EmpathyFTFactory *factory;
GtkRecentManager *manager;
gchar *uri;
g_return_if_fail (EMPATHY_IS_CONTACT (contact));
g_return_if_fail (G_IS_FILE (file));
factory = empathy_ft_factory_dup_singleton ();
empathy_ft_factory_new_transfer_outgoing (factory, contact, file,
empathy_get_current_action_time ());
uri = g_file_get_uri (file);
manager = gtk_recent_manager_get_default ();
gtk_recent_manager_add_item (manager, uri);
g_free (uri);
g_object_unref (factory);
}
static void
add_recent_item(GitgWindow *window)
{
GtkRecentManager *manager = gtk_recent_manager_get_default();
GtkRecentData data = { 0 };
gchar *groups[] = {"gitg", NULL};
gchar const *path = gitg_repository_get_path(window->priv->repository);
gchar *basename = g_path_get_basename(path);
data.display_name = basename;
data.app_name = "gitg";
data.mime_type = "inode/directory";
data.app_exec = "gitg %f";
data.groups = groups;
GFile *file = g_file_new_for_path(gitg_repository_get_path(window->priv->repository));
gchar *uri = g_file_get_uri(file);
gtk_recent_manager_add_full(manager, uri, &data);
g_free(basename);
g_free(uri);
g_object_unref(file);
}
static void
set_recent_entry (ScreenshotDialog *dialog)
{
char *uri, *app_exec = NULL;
GtkRecentManager *recent;
GtkRecentData recent_data;
GAppInfo *app;
const char *exec_name = NULL;
static char * groups[2] = { "Graphics", NULL };
app = g_app_info_get_default_for_type ("image/png", TRUE);
if (!app) {
/* return early, as this would be an useless recent entry anyway. */
return;
}
uri = screenshot_dialog_get_uri (dialog);
recent = gtk_recent_manager_get_default ();
exec_name = g_app_info_get_executable (app);
app_exec = g_strjoin (" ", exec_name, "%u", NULL);
recent_data.display_name = NULL;
recent_data.description = NULL;
recent_data.mime_type = "image/png";
recent_data.app_name = "MATE Screenshot";
recent_data.app_exec = app_exec;
recent_data.groups = groups;
recent_data.is_private = FALSE;
gtk_recent_manager_add_full (recent, uri, &recent_data);
g_object_unref (app);
g_free (app_exec);
g_free (uri);
}
static void
populate_recent_model (GtkBuilder *gui)
{
GtkListStore *list = GTK_LIST_STORE (gtk_builder_get_object (gui, "recent_model"));
gboolean existing_only = gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (gtk_builder_get_object (gui, "existing_only_button")));
gboolean gnumeric_only = gtk_toggle_button_get_active
(GTK_TOGGLE_BUTTON (gtk_builder_get_object (gui, "gnumeric_only_button")));
GtkRecentManager *manager = gtk_recent_manager_get_default ();
GList *docs, *l;
gtk_list_store_clear (list);
docs = gtk_recent_manager_get_items (manager);
docs = g_list_sort (docs, by_age_uri);
for (l = docs; l; l = l->next) {
GtkRecentInfo *ri = l->data;
GtkTreeIter iter;
if (existing_only) {
gboolean exists = gtk_recent_info_is_local (ri)
? gtk_recent_info_exists (ri)
: TRUE; /* Just assume so */
if (!exists)
continue;
}
if (gnumeric_only) {
if (!gtk_recent_info_has_application (ri, g_get_application_name ()))
continue;
}
gtk_list_store_append (list, &iter);
gtk_list_store_set (list, &iter, RECENT_COL_INFO, ri, -1);
}
g_list_free_full (docs, (GDestroyNotify)gtk_recent_info_unref);
}
static gboolean
photos_item_manager_set_active_object (PhotosBaseManager *manager, GObject *object)
{
PhotosItemManager *self = PHOTOS_ITEM_MANAGER (manager);
PhotosItemManagerPrivate *priv = self->priv;
GtkRecentManager *recent;
gboolean ret_val;
const gchar *uri;
g_return_val_if_fail (PHOTOS_IS_BASE_ITEM (object) || object == NULL, FALSE);
ret_val = PHOTOS_BASE_MANAGER_CLASS (photos_item_manager_parent_class)->set_active_object (manager, object);
if (!ret_val)
goto out;
if (object == NULL)
goto out;
if (photos_base_item_is_collection (PHOTOS_BASE_ITEM (object)))
{
GObject *collection;
collection = photos_base_manager_get_active_object (priv->col_mngr);
g_queue_push_head (priv->collection_path, (collection != NULL) ? g_object_ref (collection) : NULL);
photos_base_manager_set_active_object (priv->col_mngr, object);
goto out;
}
recent = gtk_recent_manager_get_default ();
uri = photos_base_item_get_uri (PHOTOS_BASE_ITEM (object));
gtk_recent_manager_add_item (recent, uri);
out:
return ret_val;
}
static VALUE
rg_s_default(G_GNUC_UNUSED VALUE self)
{
return GOBJ2RVAL(gtk_recent_manager_get_default());
}
static void
panel_place_menu_item_init (PanelPlaceMenuItem *menuitem)
{
GFile *bookmark;
char *bookmarks_filename;
GError *error;
menuitem->priv = PANEL_PLACE_MENU_ITEM_GET_PRIVATE (menuitem);
gconf_client_add_dir (panel_gconf_get_client (),
DESKTOP_IS_HOME_DIR_DIR,
GCONF_CLIENT_PRELOAD_NONE,
NULL);
gconf_client_add_dir (panel_gconf_get_client (),
NAMES_DIR,
GCONF_CLIENT_PRELOAD_NONE,
NULL);
panel_gconf_notify_add_while_alive (HOME_NAME_KEY,
(GConfClientNotifyFunc) panel_place_menu_item_key_changed,
G_OBJECT (menuitem));
panel_gconf_notify_add_while_alive (DESKTOP_IS_HOME_DIR_KEY,
(GConfClientNotifyFunc) panel_place_menu_item_key_changed,
G_OBJECT (menuitem));
panel_gconf_notify_add_while_alive (COMPUTER_NAME_KEY,
(GConfClientNotifyFunc) panel_place_menu_item_key_changed,
G_OBJECT (menuitem));
menuitem->priv->recent_manager = gtk_recent_manager_get_default ();
bookmarks_filename = g_build_filename (g_get_home_dir (),
BOOKMARKS_FILENAME, NULL);
bookmark = g_file_new_for_path (bookmarks_filename);
error = NULL;
menuitem->priv->bookmarks_monitor = g_file_monitor_file
(bookmark,
G_FILE_MONITOR_NONE,
NULL,
&error);
if (error) {
g_warning ("Failed to add file monitor for %s: %s\n",
bookmarks_filename, error->message);
g_error_free (error);
} else {
g_signal_connect (G_OBJECT (menuitem->priv->bookmarks_monitor),
"changed",
(GCallback) panel_place_menu_item_gtk_bookmarks_changed,
menuitem);
}
g_object_unref (bookmark);
g_free (bookmarks_filename);
menuitem->priv->volume_monitor = g_volume_monitor_get ();
menuitem->priv->drive_changed_id = g_signal_connect (menuitem->priv->volume_monitor,
"drive-changed",
G_CALLBACK (panel_place_menu_item_drives_changed),
menuitem);
menuitem->priv->drive_connected_id = g_signal_connect (menuitem->priv->volume_monitor,
"drive-connected",
G_CALLBACK (panel_place_menu_item_drives_changed),
menuitem);
menuitem->priv->drive_disconnected_id = g_signal_connect (menuitem->priv->volume_monitor,
"drive-disconnected",
G_CALLBACK (panel_place_menu_item_drives_changed),
menuitem);
menuitem->priv->volume_added_id = g_signal_connect (menuitem->priv->volume_monitor,
"volume-added",
G_CALLBACK (panel_place_menu_item_volumes_changed),
menuitem);
menuitem->priv->volume_changed_id = g_signal_connect (menuitem->priv->volume_monitor,
"volume-changed",
G_CALLBACK (panel_place_menu_item_volumes_changed),
menuitem);
menuitem->priv->volume_removed_id = g_signal_connect (menuitem->priv->volume_monitor,
"volume-removed",
G_CALLBACK (panel_place_menu_item_volumes_changed),
menuitem);
menuitem->priv->mount_added_id = g_signal_connect (menuitem->priv->volume_monitor,
"mount-added",
G_CALLBACK (panel_place_menu_item_mounts_changed),
menuitem);
menuitem->priv->mount_changed_id = g_signal_connect (menuitem->priv->volume_monitor,
"mount-changed",
G_CALLBACK (panel_place_menu_item_mounts_changed),
menuitem);
menuitem->priv->mount_removed_id = g_signal_connect (menuitem->priv->volume_monitor,
"mount-removed",
G_CALLBACK (panel_place_menu_item_mounts_changed),
menuitem);
}
int main (int argc,
char *argv[])
{
gchar *defaultfile = NULL;
GOptionContext *ctx;
GError *err = NULL;
GOptionEntry entries[] = {
{ NULL }
};
GtkWidget * recent_menu = NULL;
gchar * size_str = NULL;
#ifdef ENABLE_NLS
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALE_DIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
#endif
g_set_application_name (PACKAGE);
g_set_prgname (PACKAGE);
tls_init ();
g_thread_init (NULL);
gtk_init (&argc, &argv);
preferences_gui_set_csr_visible_callback (ca_update_csr_view);
preferences_gui_set_revoked_visible_callback (ca_update_revoked_view);
preferences_init (argc, argv);
ctx = g_option_context_new (_("- A graphical Certification Authority manager"));
g_option_context_add_main_entries (ctx, entries, GETTEXT_PACKAGE);
if (!g_option_context_parse (ctx, &argc, &argv, &err)) {
g_print (_("Failed to initialize: %s\n"), err->message);
g_error_free (err);
return 1;
}
main_window_gtkb = gtk_builder_new();
gtk_builder_add_from_file (main_window_gtkb,
g_build_filename (PACKAGE_DATA_DIR, "gnomint", "main_window.ui", NULL),
NULL);
csr_popup_menu_gtkb = gtk_builder_new();
gtk_builder_add_from_file (csr_popup_menu_gtkb,
g_build_filename (PACKAGE_DATA_DIR, "gnomint", "csr_popup_menu.ui", NULL),
NULL);
cert_popup_menu_gtkb = gtk_builder_new();
gtk_builder_add_from_file (cert_popup_menu_gtkb,
g_build_filename (PACKAGE_DATA_DIR, "gnomint", "certificate_popup_menu.ui", NULL),
NULL);
size_str = preferences_get_size ();
if (size_str) {
gchar ** result = NULL;
guint width, height;
result = g_strsplit_set (size_str, "(,)", -1);
if (result[0] && result[1]) {
width = atoi (result[1]);
if (result[2]) {
height = atoi (result[2]);
gtk_window_resize (GTK_WINDOW(gtk_builder_get_object(main_window_gtkb, "main_window1")), width, height);
}
}
g_free (size_str);
g_strfreev (result);
}
ca_update_revoked_view (preferences_get_revoked_visible(), FALSE);
ca_update_csr_view (preferences_get_crq_visible(), FALSE);
gtk_builder_connect_signals (main_window_gtkb, NULL);
gtk_builder_connect_signals (cert_popup_menu_gtkb, NULL);
gtk_builder_connect_signals (csr_popup_menu_gtkb, NULL);
recent_manager = gtk_recent_manager_get_default ();
recent_menu = __recent_create_menu();
g_signal_connect (G_OBJECT (recent_menu), "item-activated",
G_CALLBACK (on_open_recent_activate), NULL);
gtk_menu_item_set_submenu (GTK_MENU_ITEM (gtk_builder_get_object (main_window_gtkb, "openrecentsmenuitem")), recent_menu);
__disable_widget ("new_certificate1");
__disable_widget ("save_as1");
__disable_widget ("properties1");
__disable_widget ("preferences1");
dialog_establish_refresh_function (ca_refresh_model_callback);
if (argc >= 2 && ca_open (g_strdup(argv[1]), TRUE)) {
/* The file has opened OK */
__recent_add_utf8_filename (argv[1]);
} else {
/* No arguments, or failure when opening file */
defaultfile = g_build_filename (g_get_home_dir(), ".gnomint", "default.gnomint", NULL);
__recent_add_utf8_filename (defaultfile);
ca_open (defaultfile, TRUE);
}
gtk_main ();
return 0;
}
gboolean main_include_task(gpointer _options)
{
GtkRecentManager *grm = gtk_recent_manager_get_default();
GtkRecentData *data;
GSList* iterator = NULL;
recent_file_options_t* options = _options;
unsigned added = 0; /* Total files added */
static gchar* groups[] = {
NULL
};
for (iterator = options->fileNames; iterator; iterator = iterator->next)
{
char* _fileName = (char*)iterator->data;
if (!file_exists(_fileName))
{
if (!options->quiet)
fprintf (stderr, "Error '%s' does not exist!\n", _fileName);
continue;
}
char* fileName = realpath(_fileName, NULL);
if (fileName==NULL)
{
if (!options->quiet)
fprintf (stderr, "Error getting '%s' path!\n", _fileName);
continue;
}
data = g_slice_new(GtkRecentData);
data->display_name=g_strdup(fileName);
data->description = NULL;
data->mime_type=get_mime(fileName);
data->app_name = (gchar*) g_get_application_name();
data->app_exec = g_strdup("recents");
data->groups = groups;
data->is_private = FALSE;
gchar *uri = g_filename_to_uri(fileName, NULL, NULL);
if (gtk_recent_manager_add_full(grm, uri, data))
{
if (!options->quiet)
printf("File '%s' added successfully\n", fileName);
++added;
}
if (options->touchFile)
{
struct utimbuf utb;
time_t now = time(NULL);
utb.actime = now;
utb.modtime = now;
if ( (utime (fileName, &utb)<0) && (!options->quiet) )
{
fprintf (stderr, "Could not touch '%s' (errno: %d, %s)\n", fileName, errno, strerror(errno));
}
}
free(fileName);
}
options->result = (added == g_slist_length(options->fileNames))?0:100;
gtk_main_quit();
}
static void
recent_add(gchar *uri, const gchar *mime_type)
{
GtkRecentManager *recent;
GtkRecentData meta = {
.app_name = (char*)"remote-viewer",
.app_exec = (char*)"remote-viewer %u",
.mime_type = (char*)mime_type,
};
if (uri == NULL)
return;
recent = gtk_recent_manager_get_default();
meta.display_name = uri;
if (!gtk_recent_manager_add_full(recent, uri, &meta))
g_warning("Recent item couldn't be added");
}
static void connected(VirtViewerSession *session,
VirtViewerApp *self G_GNUC_UNUSED)
{
gchar *uri = virt_viewer_session_get_uri(session);
const gchar *mime = virt_viewer_session_mime_type(session);
recent_add(uri, mime);
g_free(uri);
}
int
main(int argc, char **argv)
{
GOptionContext *context;
GError *error = NULL;
int ret = 1;
gchar **args = NULL;
gchar *uri = NULL;
char *title = NULL;
RemoteViewer *viewer = NULL;
#ifdef HAVE_SPICE_GTK
gboolean controller = FALSE;
#endif
VirtViewerApp *app;
const GOptionEntry options [] = {
{ "version", 'V', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
remote_viewer_version, N_("Display version information"), NULL
},
{ "title", 't', 0, G_OPTION_ARG_STRING, &title,
N_("Set window title"), NULL
},
#ifdef HAVE_SPICE_GTK
{ "spice-controller", '\0', 0, G_OPTION_ARG_NONE, &controller,
N_("Open connection using Spice controller communication"), NULL
},
#endif
{ G_OPTION_REMAINING, '\0', 0, G_OPTION_ARG_STRING_ARRAY, &args,
NULL, "-- URI"
},
{ NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
};
virt_viewer_util_init(_("Remote Viewer"));
/* Setup command line options */
context = g_option_context_new (_("- Remote viewer client"));
g_option_context_add_main_entries (context, virt_viewer_app_get_options(), NULL);
g_option_context_add_main_entries (context, options, NULL);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
#ifdef HAVE_GTK_VNC
g_option_context_add_group (context, vnc_display_get_option_group ());
#endif
#ifdef HAVE_SPICE_GTK
g_option_context_add_group (context, spice_get_option_group ());
#endif
#ifdef HAVE_OVIRT
g_option_context_add_group (context, ovirt_get_option_group ());
#endif
g_option_context_parse (context, &argc, &argv, &error);
if (error) {
char *base_name;
base_name = g_path_get_basename(argv[0]);
g_printerr(_("%s\nRun '%s --help' to see a full list of available command line options\n"),
error->message, base_name);
g_free(base_name);
g_error_free(error);
goto cleanup;
}
g_option_context_free(context);
#ifdef HAVE_SPICE_GTK
if (controller) {
if (args) {
g_printerr(_("Error: extra arguments given while using Spice controller\n"));
goto cleanup;
}
} else
#endif
if (args) {
if (g_strv_length(args) > 1) {
g_printerr(_("Error: can't handle multiple URIs\n"));
goto cleanup;
} else if (g_strv_length(args) == 1) {
uri = g_strdup(args[0]);
}
}
#ifdef HAVE_SPICE_GTK
if (controller) {
viewer = remote_viewer_new_with_controller();
g_object_set(viewer, "guest-name", "defined by Spice controller", NULL);
} else {
#endif
viewer = remote_viewer_new(uri);
if (title)
g_object_set(viewer, "title", title, NULL);
#ifdef HAVE_SPICE_GTK
}
#endif
if (viewer == NULL)
goto cleanup;
app = VIRT_VIEWER_APP(viewer);
if (!virt_viewer_app_start(app))
goto cleanup;
g_signal_connect(virt_viewer_app_get_session(app), "session-connected",
G_CALLBACK(connected), app);
gtk_main();
ret = 0;
cleanup:
g_free(uri);
if (viewer)
g_object_unref(viewer);
g_strfreev(args);
return ret;
}
void
documents_clear_cmd_callback (GtkAction *action,
gpointer data)
{
GimpContainerEditor *editor = GIMP_CONTAINER_EDITOR (data);
GimpContext *context = gimp_container_view_get_context (editor->view);
Gimp *gimp = context->gimp;
GtkWidget *dialog;
dialog = gimp_message_dialog_new (_("Clear Document History"),
GIMP_STOCK_SHRED,
GTK_WIDGET (editor),
GTK_DIALOG_MODAL |
GTK_DIALOG_DESTROY_WITH_PARENT,
gimp_standard_help_func, NULL,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_CLEAR, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_alternative_button_order (GTK_DIALOG (dialog),
GTK_RESPONSE_OK,
GTK_RESPONSE_CANCEL,
-1);
g_signal_connect_object (gtk_widget_get_toplevel (GTK_WIDGET (editor)),
"unmap",
G_CALLBACK (gtk_widget_destroy),
dialog, G_CONNECT_SWAPPED);
gimp_message_box_set_primary_text (GIMP_MESSAGE_DIALOG (dialog)->box,
_("Clear the Recent Documents list?"));
gimp_message_box_set_text (GIMP_MESSAGE_DIALOG (dialog)->box,
_("Clearing the document history will "
"permanently remove all images from "
"the recent documents list."));
if (gimp_dialog_run (GIMP_DIALOG (dialog)) == GTK_RESPONSE_OK)
{
GtkRecentManager *manager = gtk_recent_manager_get_default ();
GList *items;
GList *list;
items = gtk_recent_manager_get_items (manager);
for (list = items; list; list = list->next)
{
GtkRecentInfo *info = list->data;
if (gtk_recent_info_has_application (info,
"GNU Image Manipulation Program"))
{
gtk_recent_manager_remove_item (manager,
gtk_recent_info_get_uri (info),
NULL);
}
gtk_recent_info_unref (info);
}
g_list_free (items);
gimp_container_clear (gimp->documents);
}
gtk_widget_destroy (dialog);
}
static void
recent_add(gchar *uri, const gchar *mime_type)
{
GtkRecentManager *recent;
GtkRecentData meta = {
.app_name = (char*)"remote-viewer",
.app_exec = (char*)"remote-viewer %u",
.mime_type = (char*)mime_type,
};
if (uri == NULL)
return;
recent = gtk_recent_manager_get_default();
meta.display_name = uri;
if (!gtk_recent_manager_add_full(recent, uri, &meta))
g_warning("Recent item couldn't be added");
}
static void connected(VirtViewerSession *session,
VirtViewerApp *self G_GNUC_UNUSED)
{
gchar *uri = virt_viewer_session_get_uri(session);
const gchar *mime = virt_viewer_session_mime_type(session);
recent_add(uri, mime);
g_free(uri);
}
//char buffer[1024]={0};
struct remote_viewer_data rvdata;
int connectflag;
/////////////////////
//socket here declare
int cfd; /*connecting socket*/
int recbytes;
int isn_size;
struct sockaddr_in s_add, c_add;
unsigned short portnum = 6666;
///////////////////////
int
main(int argc, char **argv)
{
/*
int cfd;
int recbytes;
int sin_size;
struct sockaddr_in s_add,c_add;
unsigned short portnum=6666;
*/
//print***
printf("Hello,welcome to client !\r\n");
memset(&rvdata, 0 , sizeof(rvdata));
cfd = socket(AF_INET, SOCK_STREAM, 0);
if(-1 == cfd)
{
//print***
printf("socket fail ! \r\n");
return -1;
}
//print***
printf("socket ok !\r\n");
bzero(&s_add,sizeof(struct sockaddr_in));
s_add.sin_family=AF_INET;
//获取本机IP
//
char localeIp[32];
struct ifaddrs * ifAddrStruct=NULL;
void * tmpAddrPtr=NULL;
getifaddrs(&ifAddrStruct);
while (ifAddrStruct!=NULL)
{
if (ifAddrStruct->ifa_addr->sa_family==AF_INET)
{ // check it is IP4
// is a valid IP4 Address
tmpAddrPtr=&((struct sockaddr_in *)ifAddrStruct->ifa_addr)->sin_addr;
char addressBuffer[INET_ADDRSTRLEN];
inet_ntop(AF_INET, tmpAddrPtr, addressBuffer, INET_ADDRSTRLEN);
printf("\n%s\n",ifAddrStruct->ifa_name);
if(strcmp(ifAddrStruct->ifa_name,"eth0") == 0)
{
printf("i need IP:%s\n",addressBuffer);
strcpy(localeIp, addressBuffer);
localeIp[strlen(addressBuffer)] = '\0';
}
printf("%s IP Address %s\n", ifAddrStruct->ifa_name, addressBuffer);
}
else if (ifAddrStruct->ifa_addr->sa_family==AF_INET6)
{ // check it is IP6
// is a valid IP6 Address
tmpAddrPtr=&((struct sockaddr_in *)ifAddrStruct->ifa_addr)->sin_addr;
char addressBuffer[INET6_ADDRSTRLEN];
inet_ntop(AF_INET6, tmpAddrPtr, addressBuffer, INET6_ADDRSTRLEN);
printf("%s IP Address %s\n", ifAddrStruct->ifa_name, addressBuffer);
}
ifAddrStruct=ifAddrStruct->ifa_next;
}
////////////////////////////////////
s_add.sin_addr.s_addr= inet_addr(localeIp);//应该改为获取本机IP获取作为参数传递
s_add.sin_port=htons(portnum);
//print***
printf("s_addr = %#x ,port : %#x\r\n",s_add.sin_addr.s_addr,s_add.sin_port);
//发送连接请求知道服务器响应连接
while (1)
{
if(0 == connect(cfd,(struct sockaddr *)(&s_add), sizeof(struct sockaddr)))
{
break;
}
}
//print***
printf("connect ok !\r\n");
//接收服务器发送的需连接的虚拟机IP地址
if(-1 == (recbytes = read(cfd,&rvdata,sizeof(rvdata)))) /*@modify by yl*/
{
//print***
printf("read data fail !\r\n");
return -1;
}
//print***
printf("read ok\r\nREC:\r\n");
//buffer[recbytes]='\0';
//print***
//printf("Buffer:%s\r\n",buffer);
printf("ip_str:%s\n", rvdata.ip_str);
///////////////////////////////////////////////////
GOptionContext *context;
GError *error = NULL;
int ret = 1;
gchar **args = NULL;
gchar *uri = NULL;
char *title = NULL;
RemoteViewer *viewer = NULL;
#ifdef HAVE_SPICE_GTK
gboolean controller = FALSE;
#endif
VirtViewerApp *app;
const GOptionEntry options [] = {
{ "version", 'V', G_OPTION_FLAG_NO_ARG, G_OPTION_ARG_CALLBACK,
remote_viewer_version, N_("Display version information"), NULL },
{ "title", 't', 0, G_OPTION_ARG_STRING, &title,
N_("Set window title"), NULL },
#ifdef HAVE_SPICE_GTK
{ "spice-controller", '\0', 0, G_OPTION_ARG_NONE, &controller,
N_("Open connection using Spice controller communication"), NULL },
#endif
{ G_OPTION_REMAINING, '\0', 0, G_OPTION_ARG_STRING_ARRAY, &args,
NULL, "-- URI" },
{ NULL, 0, 0, G_OPTION_ARG_NONE, NULL, NULL, NULL }
};
virt_viewer_util_init(_("Remote Viewer"));
/* Setup command line options */
context = g_option_context_new (_("- Remote viewer client"));
g_option_context_add_main_entries (context, virt_viewer_app_get_options(), NULL);
g_option_context_add_main_entries (context, options, NULL);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
#ifdef HAVE_GTK_VNC
g_option_context_add_group (context, vnc_display_get_option_group ());
#endif
#ifdef HAVE_SPICE_GTK
g_option_context_add_group (context, spice_get_option_group ());
#endif
#ifdef HAVE_OVIRT
g_option_context_add_group (context, ovirt_get_option_group ());
#endif
g_option_context_parse (context, &argc, &argv, &error);
if (error) {
char *base_name;
base_name = g_path_get_basename(argv[0]);
g_printerr(_("%s\nRun '%s --help' to see a full list of available command line options\n"),
error->message, base_name);
g_free(base_name);
g_error_free(error);
goto cleanup;
}
g_option_context_free(context);
#ifdef HAVE_SPICE_GTK
if (controller) {
if (args) {
g_printerr(_("Error: extra arguments given while using Spice controller\n"));
goto cleanup;
}
} else
#endif
if (args) {
if (g_strv_length(args) > 1) {
g_printerr(_("Error: can't handle multiple URIs\n"));
goto cleanup;
} else if (g_strv_length(args) == 1) {
uri = g_strdup(args[0]);
}
}
#ifdef HAVE_SPICE_GTK
if (controller) {
viewer = remote_viewer_new_with_controller();
g_object_set(viewer, "guest-name", "defined by Spice controller", NULL);
} else {
#endif
viewer = remote_viewer_new(uri, title);
g_object_set(viewer, "guest-name", uri, NULL);
#ifdef HAVE_SPICE_GTK
}
#endif
if (viewer == NULL)
goto cleanup;
app = VIRT_VIEWER_APP(viewer);
if (!virt_viewer_app_start(app))
goto cleanup;
g_signal_connect(virt_viewer_app_get_session(app), "session-connected",
G_CALLBACK(connected), app);
gtk_main();
ret = 0;
cleanup:
g_free(uri);
if (viewer)
g_object_unref(viewer);
g_strfreev(args);
///////////////////////////////////////
//连接虚出move to Error widget showing
/*
if (1 == connectflag)
write(cfd, "false", 6);
else
write(cfd, "true", 5);
close(cfd);
*/
///////////////////////////////////////
return ret;
}
static gboolean
photos_item_manager_set_active_object (PhotosBaseManager *manager, GObject *object)
{
PhotosItemManager *self = PHOTOS_ITEM_MANAGER (manager);
GObject *active_item;
PhotosWindowMode old_mode;
gboolean active_collection_changed = FALSE;
gboolean ret_val = FALSE;
gboolean start_loading = FALSE;
gboolean window_mode_changed = FALSE;
g_return_val_if_fail (object != NULL, FALSE);
g_return_val_if_fail (PHOTOS_IS_BASE_ITEM (object), FALSE);
active_item = photos_base_manager_get_active_object (manager);
if (object == active_item)
goto out;
photos_item_manager_clear_active_item_load (self);
if (photos_base_item_is_collection (PHOTOS_BASE_ITEM (object)))
{
g_queue_push_head (self->collection_path,
(self->active_collection != NULL) ? g_object_ref (self->active_collection) : NULL);
g_clear_object (&self->active_collection);
self->active_collection = g_object_ref (object);
self->load_state = PHOTOS_LOAD_STATE_NONE;
active_collection_changed = TRUE;
}
else
{
window_mode_changed = photos_item_manager_set_window_mode_internal (self,
PHOTOS_WINDOW_MODE_PREVIEW,
&old_mode);
photos_item_manager_update_fullscreen (self);
self->load_state = PHOTOS_LOAD_STATE_STARTED;
start_loading = TRUE;
}
ret_val = PHOTOS_BASE_MANAGER_CLASS (photos_item_manager_parent_class)->set_active_object (manager, object);
/* We have already eliminated the possibility of failure. */
g_assert (ret_val == TRUE);
active_item = photos_base_manager_get_active_object (manager);
g_assert (active_item == object);
if (active_collection_changed)
{
g_signal_emit (self, signals[ACTIVE_COLLECTION_CHANGED], 0, self->active_collection);
g_assert (active_item == (GObject *) self->active_collection);
}
if (start_loading)
{
GtkRecentManager *recent;
const gchar *uri;
recent = gtk_recent_manager_get_default ();
uri = photos_base_item_get_uri (PHOTOS_BASE_ITEM (object));
gtk_recent_manager_add_item (recent, uri);
self->loader_cancellable = g_cancellable_new ();
photos_base_item_load_async (PHOTOS_BASE_ITEM (object),
self->loader_cancellable,
photos_item_manager_item_load,
g_object_ref (self));
g_signal_emit (self, signals[LOAD_STARTED], 0, PHOTOS_BASE_ITEM (object));
if (window_mode_changed)
g_signal_emit (self, signals[WINDOW_MODE_CHANGED], 0, PHOTOS_WINDOW_MODE_PREVIEW, old_mode);
g_assert (active_item != (GObject *) self->active_collection);
}
out:
return ret_val;
}
static void
panel_place_menu_item_init (PanelPlaceMenuItem *menuitem)
{
GFile *bookmark;
char *bookmarks_filename;
GError *error;
menuitem->priv = PANEL_PLACE_MENU_ITEM_GET_PRIVATE (menuitem);
menuitem->priv->caja_desktop_settings = g_settings_new (CAJA_DESKTOP_SCHEMA);
menuitem->priv->caja_prefs_settings = g_settings_new (CAJA_PREFS_SCHEMA);
g_signal_connect (menuitem->priv->caja_desktop_settings,
"changed::" CAJA_DESKTOP_HOME_ICON_NAME_KEY,
G_CALLBACK (panel_place_menu_item_key_changed),
G_OBJECT (menuitem));
g_signal_connect (menuitem->priv->caja_desktop_settings,
"changed::" CAJA_DESKTOP_COMPUTER_ICON_NAME_KEY,
G_CALLBACK (panel_place_menu_item_key_changed),
G_OBJECT (menuitem));
g_signal_connect (menuitem->priv->caja_prefs_settings,
"changed::" CAJA_PREFS_DESKTOP_IS_HOME_DIR_KEY,
G_CALLBACK (panel_place_menu_item_key_changed),
G_OBJECT (menuitem));
menuitem->priv->recent_manager = gtk_recent_manager_get_default ();
bookmarks_filename = g_build_filename (g_get_home_dir (),
BOOKMARKS_FILENAME, NULL);
bookmark = g_file_new_for_path (bookmarks_filename);
error = NULL;
menuitem->priv->bookmarks_monitor = g_file_monitor_file
(bookmark,
G_FILE_MONITOR_NONE,
NULL,
&error);
if (error) {
g_warning ("Failed to add file monitor for %s: %s\n",
bookmarks_filename, error->message);
g_error_free (error);
} else {
g_signal_connect (G_OBJECT (menuitem->priv->bookmarks_monitor),
"changed",
(GCallback) panel_place_menu_item_gtk_bookmarks_changed,
menuitem);
}
g_object_unref (bookmark);
g_free (bookmarks_filename);
menuitem->priv->volume_monitor = g_volume_monitor_get ();
menuitem->priv->drive_changed_id = g_signal_connect (menuitem->priv->volume_monitor,
"drive-changed",
G_CALLBACK (panel_place_menu_item_drives_changed),
menuitem);
menuitem->priv->drive_connected_id = g_signal_connect (menuitem->priv->volume_monitor,
"drive-connected",
G_CALLBACK (panel_place_menu_item_drives_changed),
menuitem);
menuitem->priv->drive_disconnected_id = g_signal_connect (menuitem->priv->volume_monitor,
"drive-disconnected",
G_CALLBACK (panel_place_menu_item_drives_changed),
menuitem);
menuitem->priv->volume_added_id = g_signal_connect (menuitem->priv->volume_monitor,
"volume-added",
G_CALLBACK (panel_place_menu_item_volumes_changed),
menuitem);
menuitem->priv->volume_changed_id = g_signal_connect (menuitem->priv->volume_monitor,
"volume-changed",
G_CALLBACK (panel_place_menu_item_volumes_changed),
menuitem);
menuitem->priv->volume_removed_id = g_signal_connect (menuitem->priv->volume_monitor,
"volume-removed",
G_CALLBACK (panel_place_menu_item_volumes_changed),
menuitem);
menuitem->priv->mount_added_id = g_signal_connect (menuitem->priv->volume_monitor,
"mount-added",
G_CALLBACK (panel_place_menu_item_mounts_changed),
menuitem);
menuitem->priv->mount_changed_id = g_signal_connect (menuitem->priv->volume_monitor,
"mount-changed",
G_CALLBACK (panel_place_menu_item_mounts_changed),
menuitem);
menuitem->priv->mount_removed_id = g_signal_connect (menuitem->priv->volume_monitor,
"mount-removed",
G_CALLBACK (panel_place_menu_item_mounts_changed),
menuitem);
}
void RecentManager::removeRecentFileUri(const char * uri) {
XOJ_CHECK_TYPE(RecentManager);
GtkRecentManager * recentManager = gtk_recent_manager_get_default();
gtk_recent_manager_remove_item(recentManager, uri, NULL);
}
GtkWidget *
totem_open_location_new (void)
{
TotemOpenLocation *open_location;
char *clipboard_location;
GtkEntryCompletion *completion;
GtkTreeModel *model;
GList *recent_items, *streams_recent_items = NULL;
open_location = TOTEM_OPEN_LOCATION (g_object_new (TOTEM_TYPE_OPEN_LOCATION, NULL));
if (open_location->priv->uri_container == NULL) {
g_object_unref (open_location);
return NULL;
}
gtk_window_set_title (GTK_WINDOW (open_location), _("Open Location..."));
gtk_dialog_add_buttons (GTK_DIALOG (open_location),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_response_sensitive (GTK_DIALOG (open_location), GTK_RESPONSE_OK, FALSE);
gtk_container_set_border_width (GTK_CONTAINER (open_location), 5);
gtk_dialog_set_default_response (GTK_DIALOG (open_location), GTK_RESPONSE_OK);
/* Get item from clipboard to fill GtkEntry */
clipboard_location = totem_open_location_set_from_clipboard (open_location);
if (clipboard_location != NULL && strcmp (clipboard_location, "") != 0)
gtk_entry_set_text (open_location->priv->uri_entry, clipboard_location);
g_free (clipboard_location);
/* Add items in Totem's GtkRecentManager to the URI GtkEntry's GtkEntryCompletion */
completion = gtk_entry_completion_new();
model = GTK_TREE_MODEL (gtk_list_store_new (1, G_TYPE_STRING));
gtk_entry_set_completion (open_location->priv->uri_entry, completion);
recent_items = gtk_recent_manager_get_items (gtk_recent_manager_get_default ());
if (recent_items != NULL)
{
GList *p;
GtkTreeIter iter;
/* Filter out non-Totem items */
for (p = recent_items; p != NULL; p = p->next)
{
GtkRecentInfo *info = (GtkRecentInfo *) p->data;
if (!gtk_recent_info_has_group (info, "TotemStreams")) {
gtk_recent_info_unref (info);
continue;
}
streams_recent_items = g_list_prepend (streams_recent_items, info);
}
streams_recent_items = g_list_sort (streams_recent_items, (GCompareFunc) totem_compare_recent_stream_items);
/* Populate the list store for the combobox */
for (p = streams_recent_items; p != NULL; p = p->next)
{
GtkRecentInfo *info = (GtkRecentInfo *) p->data;
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
gtk_list_store_set (GTK_LIST_STORE (model), &iter, 0, gtk_recent_info_get_uri (info), -1);
gtk_recent_info_unref (info);
}
g_list_free (streams_recent_items);
}
g_list_free (recent_items);
gtk_entry_completion_set_model (completion, model);
gtk_entry_completion_set_text_column (completion, 0);
gtk_entry_completion_set_match_func (completion, (GtkEntryCompletionMatchFunc) totem_open_location_match, model, NULL);
gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (open_location))),
open_location->priv->uri_container,
TRUE, /* expand */
TRUE, /* fill */
0); /* padding */
gtk_widget_show_all (gtk_dialog_get_content_area (GTK_DIALOG (open_location)));
return GTK_WIDGET (open_location);
}
static void
brasero_project_type_chooser_init (BraseroProjectTypeChooser *obj)
{
GtkRecentManager *recent;
GtkWidget *project_box;
GtkWidget *recent_box;
GtkWidget *separator;
GtkWidget *widget;
GtkWidget *table;
GtkWidget *label;
GtkWidget *vbox;
int nb_rows = 1;
gchar *string;
int nb_items;
int rows;
int i;
obj->priv = g_new0 (BraseroProjectTypeChooserPrivate, 1);
/* Project box */
project_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 6);
gtk_widget_show (project_box);
gtk_box_pack_start (GTK_BOX (obj), project_box, FALSE, TRUE, 0);
string = g_strdup_printf ("<span size='x-large'><b>%s</b></span>", _("Create a new project:"));
label = gtk_label_new (string);
g_free (string);
gtk_widget_show (label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
gtk_misc_set_padding (GTK_MISC (label), 6.0, 0.0);
gtk_box_pack_start (GTK_BOX (project_box), label, FALSE, TRUE, 0);
/* get the number of rows */
nb_items = sizeof (items) / sizeof (ItemDescription);
rows = nb_items / nb_rows;
if (nb_items % nb_rows)
rows ++;
table = gtk_table_new (rows, nb_rows, TRUE);
gtk_container_set_border_width (GTK_CONTAINER (table), 6);
gtk_box_pack_start (GTK_BOX (project_box), table, FALSE, TRUE, 0);
gtk_table_set_col_spacings (GTK_TABLE (table), 4);
gtk_table_set_row_spacings (GTK_TABLE (table), 4);
for (i = 0; i < nb_items; i ++) {
widget = brasero_project_type_chooser_new_item (obj, items + i);
gtk_table_attach (GTK_TABLE (table),
widget,
i % nb_rows,
i % nb_rows + 1,
i / nb_rows,
i / nb_rows + 1,
GTK_EXPAND|GTK_FILL,
GTK_FILL,
0,
0);
}
gtk_widget_show_all (table);
separator = gtk_separator_new (GTK_ORIENTATION_VERTICAL);
gtk_widget_show (separator);
gtk_box_pack_start (GTK_BOX (obj), separator, FALSE, TRUE, 2);
/* The recent files part */
recent_box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (recent_box);
gtk_box_pack_start (GTK_BOX (obj), recent_box, TRUE, TRUE, 0);
string = g_strdup_printf ("<span size='x-large'><b>%s</b></span>", _("Recent projects:"));
label = gtk_label_new (string);
g_free (string);
gtk_widget_show (label);
gtk_label_set_use_markup (GTK_LABEL (label), TRUE);
gtk_misc_set_alignment (GTK_MISC (label), 0.0, 0.0);
gtk_misc_set_padding (GTK_MISC (label), 6.0, 0.0);
gtk_box_pack_start (GTK_BOX (recent_box), label, FALSE, TRUE, 0);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_widget_show (vbox);
gtk_box_pack_start (GTK_BOX (recent_box), vbox, FALSE, TRUE, 0);
gtk_container_set_border_width (GTK_CONTAINER (vbox), 6);
obj->priv->recent_box = vbox;
recent = gtk_recent_manager_get_default ();
brasero_project_type_chooser_build_recent (obj, recent);
g_signal_connect (recent,
"changed",
G_CALLBACK (brasero_project_type_chooser_recent_changed_cb),
obj);
}
int
main (int argc, char *argv[])
{
GtkWidget *box;
GtkWidget *menubar;
GtkWidget *menuitem;
GtkWidget *menu;
GtkWidget *button;
GtkAccelGroup *accel_group;
gtk_init (&argc, &argv);
manager = gtk_recent_manager_get_default ();
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
gtk_window_set_default_size (GTK_WINDOW (window), -1, -1);
gtk_window_set_title (GTK_WINDOW (window), "Recent Chooser Menu Test");
g_signal_connect (window, "destroy", G_CALLBACK (gtk_main_quit), NULL);
accel_group = gtk_accel_group_new ();
gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), box);
gtk_widget_show (box);
menubar = gtk_menu_bar_new ();
gtk_box_pack_start (GTK_BOX (box), menubar, FALSE, TRUE, 0);
gtk_widget_show (menubar);
menu = create_file_menu (accel_group);
menuitem = gtk_menu_item_new_with_mnemonic ("_File");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
menu = create_recent_chooser_menu (4);
menuitem = gtk_menu_item_new_with_mnemonic ("_Recently Used");
gtk_menu_item_set_submenu (GTK_MENU_ITEM (menuitem), menu);
gtk_menu_shell_append (GTK_MENU_SHELL (menubar), menuitem);
gtk_widget_show (menuitem);
label = gtk_label_new ("No recent item selected");
gtk_box_pack_start (GTK_BOX (box), label, TRUE, TRUE, 0);
gtk_widget_show (label);
button = gtk_button_new_with_label ("Close");
g_signal_connect_swapped (button, "clicked",
G_CALLBACK (gtk_widget_destroy),
window);
gtk_box_pack_end (GTK_BOX (box), button, TRUE, TRUE, 0);
gtk_widget_set_can_default (button, TRUE);
gtk_widget_grab_default (button);
gtk_widget_show (button);
gtk_widget_show (window);
gtk_main ();
return 0;
}
static VALUE
rm_s_get_default(VALUE self)
{
return GOBJ2RVAL(gtk_recent_manager_get_default());
}
