void list_view::set_row_shown(const boost::dynamic_bitset<>& shown)
{
assert(generator_);
assert(shown.size() == get_item_count());
window* window = get_window();
assert(window);
const int selected_row = get_selected_row();
bool resize_needed = false;
{
window::invalidate_layout_blocker invalidate_layout_blocker(*window);
for(size_t i = 0; i < shown.size(); ++i) {
generator_->set_item_shown(i, shown[i]);
}
generator_->place(generator_->get_origin(),
generator_->calculate_best_size());
// resize_needed = !content_resize_request();
}
if(resize_needed) {
window->invalidate_layout();
} else {
// content_grid_->set_visible_rectangle(content_visible_rectangle());
set_is_dirty(true);
}
if(selected_row != get_selected_row()) {
fire(event::NOTIFY_MODIFIED, *this, nullptr);
}
}
void tlistbox::set_row_shown(const unsigned row, const bool shown)
{
assert(generator_);
twindow *window = get_window();
assert(window);
const int selected_row = get_selected_row();
bool resize_needed;
{
twindow::tinvalidate_layout_blocker invalidate_layout_blocker(*window);
generator_->set_item_shown(row, shown);
generator_->place(generator_->get_origin()
, generator_->calculate_best_size());
resize_needed = !content_resize_request();
}
if(resize_needed) {
window->invalidate_layout();
} else {
content_grid_->set_visible_area(content_visible_area());
set_dirty();
}
if(selected_row != get_selected_row() && callback_value_changed_) {
callback_value_changed_(this);
}
}
void list_view::set_row_shown(const unsigned row, const bool shown)
{
assert(generator_);
window* window = get_window();
assert(window);
const int selected_row = get_selected_row();
bool resize_needed = false;
{
window::invalidate_layout_blocker invalidate_layout_blocker(*window);
generator_->set_item_shown(row, shown);
generator_->place(generator_->get_origin(),
generator_->calculate_best_size());
// resize_needed = !content_resize_request();
}
if(resize_needed) {
window->invalidate_layout();
} else {
// get_grid().set_visible_rectangle(content_visible_rectangle());
set_is_dirty(true);
}
if(selected_row != get_selected_row()) {
fire(event::NOTIFY_MODIFIED, *this, nullptr);
}
}
void tlistbox::set_row_shown(const std::vector<bool>& shown)
{
assert(generator_);
assert(shown.size() == get_item_count());
twindow *window = get_window();
assert(window);
const int selected_row = get_selected_row();
bool resize_needed;
{
twindow::tinvalidate_layout_blocker invalidate_layout_blocker(*window);
for(size_t i = 0; i < shown.size(); ++i) {
generator_->set_item_shown(i, shown[i]);
}
generator_->place(generator_->get_origin()
, generator_->calculate_best_size());
resize_needed = !content_resize_request();
}
if(resize_needed) {
window->invalidate_layout();
} else {
content_grid_->set_visible_area(content_visible_area());
set_dirty();
}
if(selected_row != get_selected_row() && callback_value_changed_) {
callback_value_changed_(this);
}
}
G_MODULE_EXPORT
void
on_details_treeview_row_activate (GtkMenuItem *menuitem,
gpointer user_data)
{
GtkTreeModel *model;
GtkTreeIter iter;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (treeview));
g_assert (model != NULL);
if (get_selected_row (&iter)) {
char *val;
gtk_tree_model_get (model, &iter, 1, &val, -1);
if (val) {
GtkClipboard *clipboard;
clipboard = gtk_clipboard_get
(GDK_SELECTION_CLIPBOARD);
g_assert (clipboard != NULL);
gtk_clipboard_set_text (clipboard, val, -1);
g_free (val);
}
}
}
G_MODULE_EXPORT
gboolean
on_details_treeview_button_release (GtkWidget *widget,
GdkEventButton *event,
gpointer user_data)
{
if (event->type != GDK_BUTTON_RELEASE ||
event->button != 3)
return FALSE;
/* Only show "Copy Value" menuitem when a row is selected */
g_object_set (copy_value_menuitem,
"visible",
get_selected_row (NULL),
NULL);
#if GTK_CHECK_VERSION(3,22,0)
gtk_menu_popup_at_pointer (GTK_MENU (popup), (GdkEvent *)event);
#else
gtk_menu_popup (GTK_MENU (popup),
NULL,
NULL,
NULL,
NULL,
event->button,
event->time);
#endif
return TRUE;
}
static void
update_bookmark_from_text (void)
{
if (text_changed) {
NautilusBookmark *bookmark, *bookmark_in_list;
char *name;
GdkPixbuf *pixbuf;
guint selected_row;
GtkTreeIter iter;
GFile *location;
g_assert (GTK_IS_ENTRY (name_field));
g_assert (GTK_IS_ENTRY (uri_field));
location = g_file_new_for_uri (gtk_entry_get_text (GTK_ENTRY (uri_field)));
bookmark = nautilus_bookmark_new_with_icon (location, gtk_entry_get_text (GTK_ENTRY (name_field)),
name_text_changed, NULL);
g_object_unref (location);
selected_row = get_selected_row ();
/* turn off list updating 'cuz otherwise the list-reordering code runs
* after repopulate(), thus reordering the correctly-ordered list.
*/
g_signal_handler_block (bookmarks,
bookmark_list_changed_signal_id);
nautilus_bookmark_list_delete_item_at (bookmarks, selected_row);
nautilus_bookmark_list_insert_item (bookmarks, bookmark, selected_row);
g_signal_handler_unblock (bookmarks,
bookmark_list_changed_signal_id);
g_object_unref (bookmark);
/* We also have to update the bookmark pointer in the list
store. */
gtk_tree_selection_get_selected (bookmark_selection,
NULL, &iter);
g_signal_handler_block (bookmark_list_store,
row_changed_signal_id);
bookmark_in_list = nautilus_bookmark_list_item_at (bookmarks,
selected_row);
name = nautilus_bookmark_get_name (bookmark_in_list);
pixbuf = nautilus_bookmark_get_pixbuf (bookmark_in_list, GTK_ICON_SIZE_MENU);
gtk_list_store_set (bookmark_list_store, &iter,
BOOKMARK_LIST_COLUMN_BOOKMARK, bookmark_in_list,
BOOKMARK_LIST_COLUMN_NAME, name,
BOOKMARK_LIST_COLUMN_ICON, pixbuf,
-1);
g_signal_handler_unblock (bookmark_list_store,
row_changed_signal_id);
gdk_pixbuf_unref (pixbuf);
g_free (name);
}
}
static gboolean
table_click_cb (GtkWidget *widget,
GdkEventButton *event,
gpointer data)
{
ExchangeDelegates *delegates = data;
GtkWidget *parent_window;
GtkTreeIter iter;
gint row;
if (event->type != GDK_2BUTTON_PRESS)
return FALSE;
row = get_selected_row (delegates->table, &iter);
if (row < 0 || row >= delegates->users->len)
return FALSE;
if (!get_folder_security (delegates))
return FALSE;
parent_window = gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW);
exchange_delegates_user_edit (delegates->account, delegates->users->pdata[row],
parent_window);
return TRUE;
}
void listbox::set_row_shown(const boost::dynamic_bitset<>& shown)
{
assert(generator_);
assert(shown.size() == get_item_count());
if(generator_->get_items_shown() == shown) {
LOG_GUI_G << LOG_HEADER << " returning early" << std::endl;
return;
}
window* window = get_window();
assert(window);
const int selected_row = get_selected_row();
bool resize_needed = false;
// Local scope for invalidate_layout_blocker
{
window::invalidate_layout_blocker invalidate_layout_blocker(*window);
for(size_t i = 0; i < shown.size(); ++i) {
generator_->set_item_shown(i, shown[i]);
}
point best_size = generator_->calculate_best_size();
generator_->place(generator_->get_origin(), {std::max(best_size.x, content_visible_area().w), best_size.y});
resize_needed = !content_resize_request();
}
if(resize_needed) {
window->invalidate_layout();
} else {
content_grid_->set_visible_rectangle(content_visible_area());
set_is_dirty(true);
}
if(selected_row != get_selected_row()) {
fire(event::NOTIFY_MODIFIED, *this, nullptr);
}
}
static void
update_bookmark_from_text (NautilusBookmarksWindow *self)
{
NautilusBookmark *bookmark, *bookmark_in_list;
const char *name;
GIcon *icon;
guint selected_row;
GtkTreeIter iter;
GFile *location;
if (!self->priv->text_changed ||
gtk_entry_get_text_length (GTK_ENTRY (self->priv->uri_field)) == 0) {
return;
}
location = g_file_parse_name
(gtk_entry_get_text (GTK_ENTRY (self->priv->uri_field)));
bookmark = nautilus_bookmark_new (location,
self->priv->name_text_changed ?
gtk_entry_get_text (GTK_ENTRY (self->priv->name_field)) : NULL,
NULL);
g_object_unref (location);
selected_row = get_selected_row (self);
/* turn off list updating 'cuz otherwise the list-reordering code runs
* after repopulate(), thus reordering the correctly-ordered list.
*/
g_signal_handler_block (self->priv->bookmarks, self->priv->bookmarks_changed_id);
nautilus_bookmark_list_delete_item_at (self->priv->bookmarks, selected_row);
nautilus_bookmark_list_insert_item (self->priv->bookmarks, bookmark, selected_row);
g_signal_handler_unblock (self->priv->bookmarks, self->priv->bookmarks_changed_id);
g_object_unref (bookmark);
/* We also have to update the bookmark pointer in the list
store. */
gtk_tree_selection_get_selected (self->priv->selection, NULL, &iter);
g_signal_handler_block (self->priv->model, self->priv->row_changed_id);
bookmark_in_list = nautilus_bookmark_list_item_at (self->priv->bookmarks, selected_row);
name = nautilus_bookmark_get_name (bookmark_in_list);
icon = nautilus_bookmark_get_icon (bookmark_in_list);
gtk_list_store_set (self->priv->model, &iter,
BOOKMARK_LIST_COLUMN_BOOKMARK, bookmark_in_list,
BOOKMARK_LIST_COLUMN_NAME, name,
BOOKMARK_LIST_COLUMN_ICON, icon,
-1);
g_signal_handler_unblock (self->priv->model, self->priv->row_changed_id);
g_object_unref (icon);
}
void tlistbox::set_row_shown(const boost::dynamic_bitset<>& shown)
{
assert(generator_);
assert(shown.size() == get_item_count());
if (generator_->get_items_shown() == shown)
{
LOG_GUI_G << LOG_HEADER << " returning early" << std::endl;
return;
}
twindow* window = get_window();
assert(window);
const int selected_row = get_selected_row();
bool resize_needed;
{
twindow::tinvalidate_layout_blocker invalidate_layout_blocker(*window);
for(size_t i = 0; i < shown.size(); ++i) {
generator_->set_item_shown(i, shown[i]);
}
tpoint best_size = generator_->calculate_best_size();
generator_->place(generator_->get_origin(), { std::max(best_size.x, content_visible_area().w), best_size.y });
resize_needed = !content_resize_request();
}
if(resize_needed) {
window->invalidate_layout();
} else {
content_grid_->set_visible_rectangle(content_visible_area());
set_is_dirty(true);
}
if(selected_row != get_selected_row() && callback_value_changed_) {
callback_value_changed_(*this);
}
}
static NautilusBookmark *
get_selected_bookmark (void)
{
g_return_val_if_fail(NAUTILUS_IS_BOOKMARK_LIST(bookmarks), NULL);
if (!get_selection_exists())
return NULL;
if (nautilus_bookmark_list_length (bookmarks) < 1)
return NULL;
return nautilus_bookmark_list_item_at(bookmarks, get_selected_row ());
}
static CajaBookmark *
get_selected_bookmark (void)
{
g_return_val_if_fail(CAJA_IS_BOOKMARK_LIST(bookmarks), NULL);
if (!get_selection_exists())
return NULL;
if (caja_bookmark_list_length (bookmarks) < 1)
return NULL;
return caja_bookmark_list_item_at(bookmarks, get_selected_row ());
}
static NemoBookmark *
get_selected_bookmark (void)
{
g_return_val_if_fail(NEMO_IS_BOOKMARK_LIST(bookmarks), NULL);
if (!get_selection_exists())
return NULL;
if (nemo_bookmark_list_length (bookmarks) < 1)
return NULL;
return nemo_bookmark_list_item_at(bookmarks, get_selected_row ());
}
static void
on_down_button_clicked (GtkButton *button,
gpointer user_data)
{
NautilusBookmarksWindow *self = user_data;
guint row;
GtkTreeIter iter;
row = get_selected_row (self);
nautilus_bookmark_list_move_item (self->priv->bookmarks, row, row + 1);
gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (self->priv->model),
&iter, NULL, row + 1);
gtk_tree_selection_select_iter (self->priv->selection, &iter);
}
static NautilusBookmark *
get_selected_bookmark (NautilusBookmarksWindow *self)
{
if (!get_selection_exists (self)) {
return NULL;
}
if (nautilus_bookmark_list_length (self->priv->bookmarks) < 1) {
return NULL;
}
return nautilus_bookmark_list_item_at (self->priv->bookmarks,
get_selected_row (self));
}
static void
remove_button_clicked_cb (GtkWidget *widget,
gpointer data)
{
ExchangeDelegates *delegates = data;
ExchangeDelegatesUser *user;
GtkWidget *dialog;
gint row, btn, i;
GtkTreeIter iter;
if (!get_folder_security (delegates))
return;
row = get_selected_row (delegates->table, &iter);
g_return_if_fail (row >= 0 && row < delegates->users->len);
user = delegates->users->pdata[row];
dialog = gtk_message_dialog_new (NULL, GTK_DIALOG_MODAL,
GTK_MESSAGE_QUESTION,
GTK_BUTTONS_YES_NO,
_("Remove the delegate %s?"),
user->display_name);
gtk_window_set_transient_for (GTK_WINDOW (dialog), GTK_WINDOW (gtk_widget_get_toplevel (widget)));
btn = gtk_dialog_run (GTK_DIALOG (dialog));
gtk_widget_destroy (dialog);
if (btn != GTK_RESPONSE_YES)
return;
add_remove_user (user, delegates->removed_users, delegates->added_users);
for (i = 0; i < EXCHANGE_DELEGATES_LAST; i++) {
e2k_security_descriptor_remove_sid (delegates->folder[i].sd,
user->sid);
}
e2k_security_descriptor_remove_sid (delegates->freebusy_folder.sd,
user->sid);
/* Remove the user from the table */
gtk_list_store_remove (delegates->model, &iter);
g_ptr_array_remove_index (delegates->users, row);
g_object_unref (user);
}
static void
edit_button_clicked_cb (GtkWidget *widget,
gpointer data)
{
ExchangeDelegates *delegates = data;
GtkWidget *parent_window;
GtkTreeIter iter;
gint row;
if (!get_folder_security (delegates))
return;
row = get_selected_row (delegates->table, &iter);
g_return_if_fail (row >= 0 && row < delegates->users->len);
parent_window = gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW);
exchange_delegates_user_edit (delegates->account, delegates->users->pdata[row],
parent_window);
}
static void
update_widgets_sensitivity (NautilusBookmarksWindow *self)
{
NautilusBookmark *selected;
int n_active;
int index = -1;
selected = get_selected_bookmark (self);
n_active = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (self->priv->model), NULL);
if (selected != NULL) {
index = get_selected_row (self);
}
/* Set the sensitivity of widgets that require a selection */
gtk_widget_set_sensitive (self->priv->remove_button, index >= 0 && n_active > 1);
gtk_widget_set_sensitive (self->priv->up_button, index > 0);
gtk_widget_set_sensitive (self->priv->down_button, index >= 0 && index < n_active - 1);
gtk_widget_set_sensitive (self->priv->name_field, selected != NULL);
gtk_widget_set_sensitive (self->priv->uri_field, selected != NULL);
}
