void
nemo_application_open_location (NemoApplication *application,
GFile *location,
GFile *selection,
const char *startup_id)
{
NemoWindow *window;
GList *sel_list = NULL;
window = nemo_application_create_window (application, gdk_screen_get_default ());
gtk_window_set_startup_id (GTK_WINDOW (window), startup_id);
if (selection != NULL) {
sel_list = g_list_prepend (sel_list, nemo_file_get (selection));
}
nemo_window_slot_open_location (nemo_window_get_active_slot (window),
location,
0,
sel_list);
if (sel_list != NULL) {
nemo_file_list_free (sel_list);
}
}
static void
fill_menu (NemoWindow *window,
GtkWidget *menu,
gboolean back)
{
NemoWindowSlot *slot;
GtkWidget *menu_item;
int index;
GList *list;
slot = nemo_window_get_active_slot (window);
list = back ? slot->back_list : slot->forward_list;
index = 0;
while (list != NULL) {
menu_item = nemo_bookmark_menu_item_new (NEMO_BOOKMARK (list->data));
g_object_set_data (G_OBJECT (menu_item), "user_data", GINT_TO_POINTER (index));
gtk_widget_show (GTK_WIDGET (menu_item));
g_signal_connect_object (menu_item, "activate",
back
? G_CALLBACK (activate_back_menu_item_callback)
: G_CALLBACK (activate_forward_menu_item_callback),
window, 0);
gtk_menu_shell_append (GTK_MENU_SHELL (menu), menu_item);
list = g_list_next (list);
++index;
}
}
static gboolean
button_pressed_callback (GtkWidget *widget,
GdkEventButton *event)
{
NemoWindow *window;
NemoWindowSlot *slot;
NemoView *view;
NemoLocationEntry *entry;
if (event->button != 3) {
return FALSE;
}
window = nemo_location_bar_get_window (gtk_widget_get_parent (widget));
slot = nemo_window_get_active_slot (window);
view = slot->content_view;
entry = NEMO_LOCATION_ENTRY (gtk_bin_get_child (GTK_BIN (widget)));
if (view == NULL ||
nemo_location_entry_get_secondary_action (entry) == NEMO_LOCATION_ENTRY_ACTION_GOTO) {
return FALSE;
}
nemo_view_pop_up_location_context_menu (view, event, NULL);
return FALSE;
}
static GList *
get_extension_menus (NemoWindow *window)
{
NemoWindowSlot *slot;
GList *providers;
GList *items;
GList *l;
providers = nemo_module_get_extensions_for_type (NEMO_TYPE_MENU_PROVIDER);
items = NULL;
slot = nemo_window_get_active_slot (window);
for (l = providers; l != NULL; l = l->next) {
NemoMenuProvider *provider;
GList *file_items;
provider = NEMO_MENU_PROVIDER (l->data);
file_items = nemo_menu_provider_get_background_items (provider,
GTK_WIDGET (window),
slot->viewed_file);
items = g_list_concat (items, file_items);
}
nemo_module_extension_list_free (providers);
return items;
}
static gboolean
label_button_pressed_callback (GtkWidget *widget,
GdkEventButton *event)
{
NemoWindow *window;
NemoWindowSlot *slot;
NemoView *view;
GtkWidget *label;
if (event->button != 3) {
return FALSE;
}
window = nemo_location_bar_get_window (gtk_widget_get_parent (widget));
slot = nemo_window_get_active_slot (window);
view = slot->content_view;
label = gtk_bin_get_child (GTK_BIN (widget));
/* only pop-up if the URI in the entry matches the displayed location */
if (view == NULL ||
strcmp (gtk_label_get_text (GTK_LABEL (label)), LOCATION_LABEL)) {
return FALSE;
}
nemo_view_pop_up_location_context_menu (view, event, NULL);
return FALSE;
}
static void
action_split_view_callback (GtkAction *action,
gpointer user_data)
{
NemoWindow *window;
gboolean is_active;
window = NEMO_WINDOW (user_data);
is_active = gtk_toggle_action_get_active (GTK_TOGGLE_ACTION (action));
if (is_active != nemo_window_split_view_showing (window)) {
NemoWindowSlot *slot;
if (is_active) {
nemo_window_split_view_on (window);
} else {
nemo_window_split_view_off (window);
}
slot = nemo_window_get_active_slot (window);
if (slot != NULL) {
nemo_view_update_menus (slot->content_view);
}
}
}
static gboolean
path_bar_button_pressed_callback (GtkWidget *widget,
GdkEventButton *event,
NemoWindowPane *pane)
{
NemoWindowSlot *slot;
NemoView *view;
GFile *location;
char *uri;
g_object_set_data (G_OBJECT (widget), "handle-button-release",
GINT_TO_POINTER (TRUE));
if (event->button == 3) {
slot = nemo_window_get_active_slot (pane->window);
view = slot->content_view;
if (view != NULL) {
location = nemo_path_bar_get_path_for_button (
NEMO_PATH_BAR (pane->path_bar), widget);
if (location != NULL) {
uri = g_file_get_uri (location);
nemo_view_pop_up_location_context_menu (
view, event, uri);
g_object_unref (location);
g_free (uri);
return TRUE;
}
}
}
return FALSE;
}
static void
real_inactive (NemoWindowSlot *slot)
{
NemoWindow *window;
window = nemo_window_slot_get_window (slot);
g_assert (slot == nemo_window_get_active_slot (window));
}
static void
action_reload_callback (GtkAction *action,
gpointer user_data)
{
NemoWindowSlot *slot;
slot = nemo_window_get_active_slot (NEMO_WINDOW (user_data));
nemo_window_slot_reload (slot);
}
static void
action_up_callback (GtkAction *action,
gpointer user_data)
{
NemoWindow *window = user_data;
NemoWindowSlot *slot;
slot = nemo_window_get_active_slot (window);
nemo_window_slot_go_up (slot, FALSE, nemo_event_should_open_in_new_tab ());
}
static NemoView *
get_current_view (NemoWindow *window)
{
NemoWindowSlot *slot;
NemoView *view;
slot = nemo_window_get_active_slot (window);
view = nemo_window_slot_get_current_view (slot);
return view;
}
static void
action_stop_callback (GtkAction *action,
gpointer user_data)
{
NemoWindow *window;
NemoWindowSlot *slot;
window = NEMO_WINDOW (user_data);
slot = nemo_window_get_active_slot (window);
nemo_window_slot_stop_loading (slot);
}
static void
action_close_window_slot_callback (GtkAction *action,
gpointer user_data)
{
NemoWindow *window;
NemoWindowSlot *slot;
window = NEMO_WINDOW (user_data);
slot = nemo_window_get_active_slot (window);
nemo_window_pane_slot_close (slot->pane, slot);
}
static void
action_home_callback (GtkAction *action,
gpointer user_data)
{
NemoWindow *window;
NemoWindowSlot *slot;
window = NEMO_WINDOW (user_data);
slot = nemo_window_get_active_slot (window);
nemo_window_slot_go_home (slot,
nemo_event_should_open_in_new_tab ());
}
static void
activate_bookmark_in_menu_item (GtkAction *action, gpointer user_data)
{
NemoWindowSlot *slot;
BookmarkHolder *holder;
GFile *location;
holder = (BookmarkHolder *)user_data;
location = nemo_bookmark_get_location (holder->bookmark);
slot = nemo_window_get_active_slot (holder->window);
nemo_window_slot_open_location (slot, location, nemo_event_get_window_open_flags ());
g_object_unref (location);
}
static void
action_new_window_callback (GtkAction *action,
gpointer user_data)
{
NemoApplication *application;
NemoWindow *current_window, *new_window;
current_window = NEMO_WINDOW (user_data);
application = nemo_application_get_singleton ();
new_window = nemo_application_create_window (
application,
gtk_window_get_screen (GTK_WINDOW (current_window)));
nemo_window_slot_go_home (nemo_window_get_active_slot (new_window), FALSE);
}
/**
* add_bookmark_for_current_location
*
* Add a bookmark for the displayed location to the bookmarks menu.
* Does nothing if there's already a bookmark for the displayed location.
*/
void
nemo_window_add_bookmark_for_current_location (NemoWindow *window)
{
NemoBookmark *bookmark;
NemoWindowSlot *slot;
NemoBookmarkList *list;
slot = nemo_window_get_active_slot (window);
bookmark = slot->current_location_bookmark;
list = window->details->bookmark_list;
if (!nemo_bookmark_list_contains (list, bookmark)) {
nemo_bookmark_list_append (list, bookmark);
}
}
static void
action_go_to_computer_callback (GtkAction *action,
gpointer user_data)
{
NemoWindow *window;
NemoWindowSlot *slot;
GFile *computer;
window = NEMO_WINDOW (user_data);
slot = nemo_window_get_active_slot (window);
computer = g_file_new_for_uri (COMPUTER_URI);
nemo_window_slot_go_to (slot,
computer,
nemo_event_should_open_in_new_tab ());
g_object_unref (computer);
}
static void
action_go_to_network_callback (GtkAction *action,
gpointer user_data)
{
NemoWindow *window;
NemoWindowSlot *slot;
GFile *network;
window = NEMO_WINDOW (user_data);
slot = nemo_window_get_active_slot (window);
network = g_file_new_for_uri (NETWORK_URI);
nemo_window_slot_go_to (slot,
network,
nemo_event_should_open_in_new_tab ());
g_object_unref (network);
}
static void
action_go_to_trash_callback (GtkAction *action,
gpointer user_data)
{
NemoWindow *window;
NemoWindowSlot *slot;
GFile *trash;
window = NEMO_WINDOW (user_data);
slot = nemo_window_get_active_slot (window);
trash = g_file_new_for_uri ("trash:///");
nemo_window_slot_go_to (slot,
trash,
nemo_event_should_open_in_new_tab ());
g_object_unref (trash);
}
static void
nemo_window_update_split_view_actions_sensitivity (NemoWindow *window)
{
GtkActionGroup *action_group;
GtkAction *action;
gboolean have_multiple_panes;
gboolean next_pane_is_in_same_location;
GFile *active_pane_location;
GFile *next_pane_location;
NemoWindowPane *next_pane;
NemoWindowSlot *active_slot;
active_slot = nemo_window_get_active_slot (window);
action_group = nemo_window_get_main_action_group (window);
/* collect information */
have_multiple_panes = nemo_window_split_view_showing (window);
if (active_slot != NULL) {
active_pane_location = nemo_window_slot_get_location (active_slot);
} else {
active_pane_location = NULL;
}
next_pane = nemo_window_get_next_pane (window);
if (next_pane && next_pane->active_slot) {
next_pane_location = nemo_window_slot_get_location (next_pane->active_slot);
next_pane_is_in_same_location = (active_pane_location && next_pane_location &&
g_file_equal (active_pane_location, next_pane_location));
} else {
next_pane_location = NULL;
next_pane_is_in_same_location = FALSE;
}
/* switch to next pane */
action = gtk_action_group_get_action (action_group, "SplitViewNextPane");
gtk_action_set_sensitive (action, have_multiple_panes);
/* same location */
action = gtk_action_group_get_action (action_group, "SplitViewSameLocation");
gtk_action_set_sensitive (action, have_multiple_panes && !next_pane_is_in_same_location);
/* clean up */
g_clear_object (&active_pane_location);
g_clear_object (&next_pane_location);
}
void
nemo_status_bar_sync_zoom_widgets (NemoStatusBar *bar)
{
NemoWindowSlot *slot = nemo_window_get_active_slot (bar->window);
if (!NEMO_IS_WINDOW_SLOT (slot))
return;
NemoView *view = slot->content_view;
if (!NEMO_IS_VIEW (view))
return;
NemoZoomLevel zoom_level = nemo_view_get_zoom_level (NEMO_VIEW (view));
gtk_range_set_value (GTK_RANGE (bar->zoom_slider), (double) zoom_level);
}
static void
on_slider_changed_cb (GtkWidget *zoom_slider, gpointer user_data)
{
NemoStatusBar *bar = NEMO_STATUS_BAR (user_data);
gdouble val = gtk_range_get_value (GTK_RANGE (zoom_slider));
NemoWindowSlot *slot = nemo_window_get_active_slot (bar->window);
if (!NEMO_IS_WINDOW_SLOT (slot))
return;
NemoView *view = slot->content_view;
if (!NEMO_IS_VIEW (view))
return;
nemo_view_zoom_to_level (view, (int) val);
}
static void
activate_bookmark_by_quicklist (DbusmenuMenuitem *menu,
guint timestamp,
NemoBookmark *bookmark)
{
g_assert (NEMO_IS_BOOKMARK (bookmark));
GFile *location;
NemoApplication *application;
NemoWindow *new_window;
location = nemo_bookmark_get_location (bookmark);
application = nemo_application_get_singleton ();
new_window = nemo_application_create_window (application, gdk_screen_get_default ());
nemo_window_slot_go_to (nemo_window_get_active_slot (new_window), location, FALSE);
g_object_unref (location);
}
static void
activate_bookmark_in_menu_item (GtkAction *action, gpointer user_data)
{
NemoWindowSlot *slot;
BookmarkHolder *holder;
GFile *location;
holder = (BookmarkHolder *)user_data;
if (!nemo_bookmark_get_exists (holder->bookmark)) {
holder->failed_callback (holder->window, holder->bookmark);
} else {
location = nemo_bookmark_get_location (holder->bookmark);
slot = nemo_window_get_active_slot (holder->window);
nemo_window_slot_go_to (slot,
location,
nemo_event_should_open_in_new_tab ());
g_object_unref (location);
}
}
static void
action_go_to_templates_callback (GtkAction *action,
gpointer user_data)
{
NemoWindow *window;
NemoWindowSlot *slot;
char *path;
GFile *location;
window = NEMO_WINDOW (user_data);
slot = nemo_window_get_active_slot (window);
path = nemo_get_templates_directory ();
location = g_file_new_for_path (path);
g_free (path);
nemo_window_slot_go_to (slot,
location,
nemo_event_should_open_in_new_tab ());
g_object_unref (location);
}
static void
action_split_view_same_location_callback (GtkAction *action,
gpointer user_data)
{
NemoWindow *window;
NemoWindowPane *next_pane;
GFile *location;
window = NEMO_WINDOW (user_data);
next_pane = nemo_window_get_next_pane (window);
if (!next_pane) {
return;
}
location = nemo_window_slot_get_location (next_pane->active_slot);
if (location) {
nemo_window_slot_go_to (nemo_window_get_active_slot (window), location, FALSE);
g_object_unref (location);
}
}
void
nemo_window_slot_set_status (NemoWindowSlot *slot,
const char *status,
const char *short_status)
{
NemoWindow *window;
g_assert (NEMO_IS_WINDOW_SLOT (slot));
g_free (slot->status_text);
slot->status_text = g_strdup (status);
if (slot->content_view != NULL) {
set_floating_bar_status (slot, short_status);
}
window = nemo_window_slot_get_window (slot);
if (slot == nemo_window_get_active_slot (window)) {
nemo_window_push_status (window, slot->status_text);
}
}
static gboolean
path_bar_button_released_callback (GtkWidget *widget,
GdkEventButton *event,
NemoWindowPane *pane)
{
NemoWindowSlot *slot;
NemoWindowOpenFlags flags;
GFile *location;
int mask;
gboolean handle_button_release;
mask = event->state & gtk_accelerator_get_default_mod_mask ();
flags = 0;
handle_button_release = GPOINTER_TO_UINT (g_object_get_data (G_OBJECT (widget),
"handle-button-release"));
if (event->type == GDK_BUTTON_RELEASE && handle_button_release) {
location = nemo_path_bar_get_path_for_button (NEMO_PATH_BAR (pane->path_bar), widget);
if (event->button == 2 && mask == 0) {
flags = NEMO_WINDOW_OPEN_FLAG_NEW_TAB;
} else if (event->button == 1 && mask == GDK_CONTROL_MASK) {
flags = NEMO_WINDOW_OPEN_FLAG_NEW_WINDOW;
}
if (flags != 0) {
slot = nemo_window_get_active_slot (pane->window);
nemo_window_slot_open_location (slot, location,
flags, NULL);
g_object_unref (location);
return TRUE;
}
g_object_unref (location);
}
return FALSE;
}
void
nemo_window_pane_sync_location_widgets (NemoWindowPane *pane)
{
NemoWindowSlot *slot, *active_slot;
NemoNavigationState *nav_state;
gchar *view_id;
slot = pane->active_slot;
nemo_window_pane_hide_temporary_bars (pane);
/* Change the location bar and path bar to match the current location. */
if (slot->location != NULL) {
char *uri;
/* this may be NULL if we just created the slot */
uri = nemo_window_slot_get_location_uri (slot);
nemo_location_bar_set_location (NEMO_LOCATION_BAR (pane->location_bar), uri);
g_free (uri);
nemo_path_bar_set_path (NEMO_PATH_BAR (pane->path_bar), slot->location);
restore_focus_widget (pane);
}
/* Update window global UI if this is the active pane */
if (pane == nemo_window_get_active_pane (pane->window)) {
nemo_window_sync_up_button (pane->window);
/* Check if the back and forward buttons need enabling or disabling. */
active_slot = nemo_window_get_active_slot (pane->window);
nav_state = nemo_window_get_navigation_state (pane->window);
nemo_navigation_state_set_boolean (nav_state,
NEMO_ACTION_BACK,
active_slot->back_list != NULL);
nemo_navigation_state_set_boolean (nav_state,
NEMO_ACTION_FORWARD,
active_slot->forward_list != NULL);
}
}
