static void
readjust_columns(GntTree *tree)
{
int i, col, total;
int width;
#define WIDTH(i) (tree->columns[i].width_ratio ? tree->columns[i].width_ratio : tree->columns[i].width)
gnt_widget_get_size(GNT_WIDGET(tree), &width, NULL);
if (!GNT_WIDGET_IS_FLAG_SET(GNT_WIDGET(tree), GNT_WIDGET_NO_BORDER))
width -= 2;
width -= 1; /* Exclude the scrollbar from the calculation */
for (i = 0, total = 0; i < tree->ncol ; i++) {
if (tree->columns[i].flags & GNT_TREE_COLUMN_INVISIBLE)
continue;
if (tree->columns[i].flags & GNT_TREE_COLUMN_FIXED_SIZE)
width -= WIDTH(i) + (tree->priv->lastvisible != i);
else
total += WIDTH(i) + (tree->priv->lastvisible != i);
}
if (total == 0)
return;
for (i = 0; i < tree->ncol; i++) {
if (tree->columns[i].flags & GNT_TREE_COLUMN_INVISIBLE)
continue;
if (tree->columns[i].flags & GNT_TREE_COLUMN_FIXED_SIZE)
col = WIDTH(i);
else
col = (WIDTH(i) * width) / total;
gnt_tree_set_col_width(GNT_TREE(tree), i, col);
}
}
static void
menuitem_activate(GntMenu *menu, GntMenuItem *item)
{
if (!item)
return;
if (gnt_menuitem_activate(item)) {
menu_hide_all(menu);
} else {
if (item->submenu) {
GntMenu *sub = GNT_MENU(item->submenu);
menu->submenu = sub;
sub->type = GNT_MENU_POPUP; /* Submenus are *never* toplevel */
sub->parentmenu = menu;
if (menu->type != GNT_MENU_TOPLEVEL) {
GntWidget *widget = GNT_WIDGET(menu);
item->priv.x = widget->priv.x + widget->priv.width - 1;
item->priv.y = widget->priv.y + gnt_tree_get_selection_visible_line(GNT_TREE(menu));
}
gnt_widget_set_position(GNT_WIDGET(sub), item->priv.x, item->priv.y);
GNT_WIDGET_UNSET_FLAGS(GNT_WIDGET(sub), GNT_WIDGET_INVISIBLE);
gnt_widget_draw(GNT_WIDGET(sub));
} else {
menu_hide_all(menu);
}
}
}
static void
gnt_text_view_reflow(GntTextView *view)
{
/* This is pretty ugly, and inefficient. Someone do something about it. */
GntTextLine *line;
GList *back, *iter, *list;
GString *string;
int pos = 0; /* no. of 'real' lines */
list = view->list;
while (list->prev) {
line = list->data;
if (!line->soft)
pos++;
list = list->prev;
}
back = g_list_last(view->list);
view->list = NULL;
string = view->string;
view->string = NULL;
reset_text_view(view);
view->string = g_string_set_size(view->string, string->len);
view->string->len = 0;
GNT_WIDGET_SET_FLAGS(GNT_WIDGET(view), GNT_WIDGET_DRAWING);
for (; back; back = back->prev) {
line = back->data;
if (back->next && !line->soft) {
gnt_text_view_append_text_with_flags(view, "\n", GNT_TEXT_FLAG_NORMAL);
}
for (iter = line->segments; iter; iter = iter->next) {
GntTextSegment *seg = iter->data;
char *start = string->str + seg->start;
char *end = string->str + seg->end;
char back = *end;
*end = '\0';
gnt_text_view_append_text_with_flags(view, start, seg->tvflag);
*end = back;
}
free_text_line(line, NULL);
}
g_list_free(list);
list = view->list = g_list_first(view->list);
/* Go back to the line that was in view before resizing started */
while (pos--) {
while (((GntTextLine*)list->data)->soft)
list = list->next;
list = list->next;
}
view->list = list;
GNT_WIDGET_UNSET_FLAGS(GNT_WIDGET(view), GNT_WIDGET_DRAWING);
if (GNT_WIDGET(view)->window)
gnt_widget_draw(GNT_WIDGET(view));
g_string_free(string, TRUE);
}
static gboolean
location_changed(GntFileSel *sel, GError **err)
{
GList *files, *iter;
gboolean success;
if (!sel->dirs)
return TRUE;
gnt_tree_remove_all(GNT_TREE(sel->dirs));
if (sel->files)
gnt_tree_remove_all(GNT_TREE(sel->files));
gnt_entry_set_text(GNT_ENTRY(sel->location), NULL);
if (sel->current == NULL) {
if (GNT_WIDGET_IS_FLAG_SET(GNT_WIDGET(sel), GNT_WIDGET_MAPPED))
gnt_widget_draw(GNT_WIDGET(sel));
return TRUE;
}
/* XXX:\
* XXX: This is blocking.
* XXX:/
*/
files = NULL;
if (sel->read_fn)
success = sel->read_fn(sel->current, &files, err);
else
success = local_read_fn(sel->current, &files, err);
if (!success || *err) {
gnt_warning("error opening location %s (%s)",
sel->current, *err ? (*err)->message : "reason unknown");
return FALSE;
}
for (iter = files; iter; iter = iter->next) {
GntFile *file = iter->data;
char *str = file->basename;
if (file->type == GNT_FILE_DIR) {
gnt_tree_add_row_after(GNT_TREE(sel->dirs), g_strdup(str),
gnt_tree_create_row(GNT_TREE(sel->dirs), str), NULL, NULL);
if (sel->multiselect && sel->dirsonly && is_tagged(sel, str))
gnt_tree_set_row_flags(GNT_TREE(sel->dirs), (gpointer)str, GNT_TEXT_FLAG_BOLD);
} else if (!sel->dirsonly) {
char size[128];
snprintf(size, sizeof(size), "%ld", file->size);
gnt_tree_add_row_after(GNT_TREE(sel->files), g_strdup(str),
gnt_tree_create_row(GNT_TREE(sel->files), str, size, ""), NULL, NULL);
if (sel->multiselect && is_tagged(sel, str))
gnt_tree_set_row_flags(GNT_TREE(sel->files), (gpointer)str, GNT_TEXT_FLAG_BOLD);
}
}
g_list_foreach(files, (GFunc)gnt_file_free, NULL);
g_list_free(files);
if (GNT_WIDGET_IS_FLAG_SET(GNT_WIDGET(sel), GNT_WIDGET_MAPPED))
gnt_widget_draw(GNT_WIDGET(sel));
return TRUE;
}
static gboolean
move_end(GntBindable *bind, GList *null)
{
GntEntry *entry = GNT_ENTRY(bind);
entry->cursor = entry->end;
/* This should be better than this */
while (gnt_util_onscreen_width(entry->scroll, entry->cursor) >= GNT_WIDGET(entry)->priv.width)
entry->scroll = g_utf8_find_next_char(entry->scroll, NULL);
entry_redraw(GNT_WIDGET(entry));
update_kill_ring(entry, ENTRY_JAIL, NULL, 0);
return TRUE;
}
static gboolean
move_forward(GntBindable *bind, GList *list)
{
GntEntry *entry = GNT_ENTRY(bind);
if (entry->cursor >= entry->end)
return FALSE;
entry->cursor = g_utf8_find_next_char(entry->cursor, NULL);
while (gnt_util_onscreen_width(entry->scroll, entry->cursor) >= GNT_WIDGET(entry)->priv.width)
entry->scroll = g_utf8_find_next_char(entry->scroll, NULL);
update_kill_ring(entry, ENTRY_JAIL, NULL, 0);
entry_redraw(GNT_WIDGET(entry));
return TRUE;
}
static void
set_selection(GntComboBox *box, gpointer key)
{
if (box->selected != key)
{
/* XXX: make sure the key actually does exist */
gpointer old = box->selected;
box->selected = key;
if (GNT_WIDGET(box)->window)
gnt_widget_draw(GNT_WIDGET(box));
if (box->dropdown)
gnt_tree_set_selected(GNT_TREE(box->dropdown), key);
g_signal_emit(box, signals[SIG_SELECTION_CHANGED], 0, old, key);
}
}
static void
menu_hide_all(GntMenu *menu)
{
while (menu->parentmenu)
menu = menu->parentmenu;
gnt_widget_hide(GNT_WIDGET(menu));
}
static gboolean
complete_suggest(GntEntry *entry, const char *text)
{
int offstart = 0, offend = 0;
if (entry->word) {
char *s = get_beginning_of_word(entry);
const char *iter = text;
offstart = g_utf8_pointer_to_offset(entry->start, s);
while (*iter && toupper(*s) == toupper(*iter)) {
*s++ = *iter++;
}
if (*iter) {
gnt_entry_key_pressed(GNT_WIDGET(entry), iter);
}
offend = g_utf8_pointer_to_offset(entry->start, entry->cursor);
} else {
offstart = 0;
gnt_entry_set_text_internal(entry, text);
offend = g_utf8_strlen(text, -1);
}
g_signal_emit(G_OBJECT(entry), signals[SIG_COMPLETION], 0,
entry->start + offstart, entry->start + offend);
update_kill_ring(entry, ENTRY_JAIL, NULL, 0);
return TRUE;
}
static void
redraw_slider(GntSlider *slider)
{
GntWidget *widget = GNT_WIDGET(slider);
if (GNT_WIDGET_IS_FLAG_SET(widget, GNT_WIDGET_MAPPED))
gnt_widget_draw(widget);
}
static gboolean
entry_yank(GntBindable *bind, GList *null)
{
GntEntry *entry = GNT_ENTRY(bind);
gnt_entry_key_pressed(GNT_WIDGET(entry), entry->killring->buffer->str);
return TRUE;
}
static gboolean
transpose_chars(GntBindable *bind, GList *null)
{
GntEntry *entry = GNT_ENTRY(bind);
char *current, *prev;
char hold[8]; /* that's right */
if (entry->cursor <= entry->start)
return FALSE;
if (!*entry->cursor)
entry->cursor = g_utf8_find_prev_char(entry->start, entry->cursor);
current = entry->cursor;
prev = g_utf8_find_prev_char(entry->start, entry->cursor);
move_forward(bind, null);
/* Let's do this dance! */
memcpy(hold, prev, current - prev);
memmove(prev, current, entry->cursor - current);
memcpy(prev + (entry->cursor - current), hold, current - prev);
update_kill_ring(entry, ENTRY_JAIL, NULL, 0);
entry_redraw(GNT_WIDGET(entry));
entry_text_changed(entry);
return TRUE;
}
static gboolean
del_prev_word(GntBindable *bind, GList *null)
{
GntWidget *widget = GNT_WIDGET(bind);
GntEntry *entry = GNT_ENTRY(bind);
char *iter = g_utf8_find_prev_char(entry->start, entry->cursor);
int count;
if (iter < entry->start)
return TRUE;
iter = (char*)begin_word(iter, entry->start);
count = entry->cursor - iter;
update_kill_ring(entry, ENTRY_DEL_BWD_WORD, iter, count);
memmove(iter, entry->cursor, entry->end - entry->cursor);
entry->end -= count;
entry->cursor = iter;
if (entry->cursor <= entry->scroll) {
entry->scroll = entry->cursor - widget->priv.width + 2;
if (entry->scroll < entry->start)
entry->scroll = entry->start;
}
memset(entry->end, '\0', entry->buffer - (entry->end - entry->start));
entry_redraw(widget);
entry_text_changed(entry);
return TRUE;
}
static gboolean
check_for_trigger(GntMenu *menu, char trigger)
{
/* check for a trigger key */
GList *iter;
GList *find;
GList *nth = g_list_find(menu->list, gnt_tree_get_selection_data(GNT_TREE(menu)));
if (nth == NULL)
return FALSE;
find = find_item_with_trigger(nth->next, NULL, trigger);
if (!find)
find = find_item_with_trigger(menu->list, nth->next, trigger);
if (!find)
return FALSE;
if (find != nth) {
gnt_tree_set_selected(GNT_TREE(menu), find->data);
iter = find_item_with_trigger(find->next, NULL, trigger);
if (iter != NULL && iter != find)
return TRUE;
iter = find_item_with_trigger(menu->list, nth, trigger);
if (iter != NULL && iter != find)
return TRUE;
}
gnt_widget_activate(GNT_WIDGET(menu));
return TRUE;
}
static gboolean
backspace(GntBindable *bind, GList *null)
{
int len;
GntEntry *entry = GNT_ENTRY(bind);
if (entry->cursor <= entry->start)
return TRUE;
len = entry->cursor - g_utf8_find_prev_char(entry->start, entry->cursor);
update_kill_ring(entry, ENTRY_JAIL, entry->cursor, -len);
entry->cursor -= len;
memmove(entry->cursor, entry->cursor + len, entry->end - entry->cursor);
entry->end -= len;
if (entry->scroll > entry->start)
entry->scroll = g_utf8_find_prev_char(entry->start, entry->scroll);
entry_redraw(GNT_WIDGET(entry));
if (entry->ddown)
show_suggest_dropdown(entry);
entry_text_changed(entry);
return TRUE;
}
static void
gnt_box_size_request(GntWidget *widget)
{
GntBox *box = GNT_BOX(widget);
GList *iter;
int maxw = 0, maxh = 0;
g_list_foreach(box->list, (GFunc)gnt_widget_size_request, NULL);
for (iter = box->list; iter; iter = iter->next)
{
int w, h;
gnt_widget_get_size(GNT_WIDGET(iter->data), &w, &h);
if (maxh < h)
maxh = h;
if (maxw < w)
maxw = w;
}
for (iter = box->list; iter; iter = iter->next)
{
int w, h;
GntWidget *wid = GNT_WIDGET(iter->data);
gnt_widget_get_size(wid, &w, &h);
if (box->homogeneous)
{
if (box->vertical)
h = maxh;
else
w = maxw;
}
if (box->fill)
{
if (box->vertical)
w = maxw;
else
h = maxh;
}
gnt_widget_confirm_size(wid, w, h);
gnt_widget_set_size(wid, w, h);
}
reposition_children(widget);
}
gboolean gnt_screen_menu_show(gpointer newmenu)
{
if (wm->menu) {
/* For now, if a menu is being displayed, then another menu
* can NOT take over. */
return FALSE;
}
wm->menu = newmenu;
GNT_WIDGET_UNSET_FLAGS(GNT_WIDGET(wm->menu), GNT_WIDGET_INVISIBLE);
gnt_widget_draw(GNT_WIDGET(wm->menu));
g_signal_connect(G_OBJECT(wm->menu), "hide", G_CALLBACK(reset_menu), NULL);
g_signal_connect(G_OBJECT(wm->menu), "destroy", G_CALLBACK(reset_menu), NULL);
return TRUE;
}
static gboolean
move_start(GntBindable *bind, GList *null)
{
GntEntry *entry = GNT_ENTRY(bind);
entry->scroll = entry->cursor = entry->start;
entry_redraw(GNT_WIDGET(entry));
update_kill_ring(entry, ENTRY_JAIL, NULL, 0);
return TRUE;
}
static void *
finch_notify_userinfo(PurpleConnection *gc, const char *who, PurpleNotifyUserInfo *user_info)
{
char *primary;
char *info;
void *ui_handle;
char *key = userinfo_hash(purple_connection_get_account(gc), who);
info = purple_notify_user_info_get_xhtml(user_info);
ui_handle = g_hash_table_lookup(userinfo, key);
if (ui_handle != NULL) {
GntTextView *msg = GNT_TEXT_VIEW(g_object_get_data(G_OBJECT(ui_handle), "info-widget"));
char *strip = purple_markup_strip_html(info);
int tvw, tvh, width, height, ntvw, ntvh;
while (GNT_WIDGET(ui_handle)->parent)
ui_handle = GNT_WIDGET(ui_handle)->parent;
gnt_widget_get_size(GNT_WIDGET(ui_handle), &width, &height);
gnt_widget_get_size(GNT_WIDGET(msg), &tvw, &tvh);
gnt_text_view_clear(msg);
if (!gnt_util_parse_xhtml_to_textview(info, msg))
gnt_text_view_append_text_with_flags(msg, strip, GNT_TEXT_FLAG_NORMAL);
gnt_text_view_scroll(msg, 0);
gnt_util_get_text_bound(strip, &ntvw, &ntvh);
ntvw += 3;
ntvh++;
gnt_screen_resize_widget(GNT_WIDGET(ui_handle), width + MAX(0, ntvw - tvw), height + MAX(0, ntvh - tvh));
g_free(strip);
g_free(key);
} else {
primary = g_strdup_printf(_("Info for %s"), who);
ui_handle = finch_notify_formatted(_("Buddy Information"), primary, NULL, info);
g_hash_table_insert(userinfo, key, ui_handle);
g_free(primary);
g_signal_connect(G_OBJECT(ui_handle), "destroy", G_CALLBACK(remove_userinfo), key);
}
g_free(info);
return ui_handle;
}
static void
gnt_menu_hide(GntWidget *widget)
{
GntMenu *sub, *menu = GNT_MENU(widget);
while ((sub = menu->submenu))
gnt_widget_hide(GNT_WIDGET(sub));
if (menu->parentmenu)
menu->parentmenu->submenu = NULL;
}
static void
add_to_focus(gpointer value, gpointer data)
{
GntBox *box = GNT_BOX(data);
GntWidget *w = GNT_WIDGET(value);
if (GNT_IS_BOX(w))
g_list_foreach(GNT_BOX(w)->list, add_to_focus, box);
else if (GNT_WIDGET_IS_FLAG_SET(w, GNT_WIDGET_CAN_TAKE_FOCUS))
box->focus = g_list_append(box->focus, w);
}
/* Ensures that the current widget can take focus */
static GntWidget *
find_focusable_widget(GntBox *box)
{
/* XXX: Make sure the widget is visible? */
if (box->focus == NULL && GNT_WIDGET(box)->parent == NULL)
g_list_foreach(box->list, add_to_focus, box);
if (box->active == NULL && box->focus)
box->active = box->focus->data;
return box->active;
}
static void
gnt_window_destroy(GntWidget *widget)
{
GntWindow *window = GNT_WINDOW(widget);
if (window->menu)
gnt_widget_destroy(GNT_WIDGET(window->menu));
if (window->priv) {
if (window->priv->accels)
g_hash_table_destroy(window->priv->accels);
g_free(window->priv);
}
org_destroy(widget);
}
static void
get_title_thingies(GntBox *box, char *title, int *p, int *r)
{
GntWidget *widget = GNT_WIDGET(box);
int len;
char *end = (char*)gnt_util_onscreen_width_to_pointer(title, widget->priv.width - 4, &len);
if (p)
*p = (widget->priv.width - len) / 2;
if (r)
*r = (widget->priv.width + len) / 2;
*end = '\0';
}
static gboolean
del_to_end(GntBindable *bind, GList *null)
{
GntEntry *entry = GNT_ENTRY(bind);
if (entry->end <= entry->cursor)
return TRUE;
update_kill_ring(entry, ENTRY_DEL_EOL, entry->cursor, entry->end - entry->cursor);
entry->end = entry->cursor;
memset(entry->end, '\0', entry->buffer - (entry->end - entry->start));
entry_redraw(GNT_WIDGET(bind));
entry_text_changed(entry);
return TRUE;
}
static gboolean
move_forward_word(GntBindable *bind, GList *list)
{
GntEntry *entry = GNT_ENTRY(bind);
GntWidget *widget = GNT_WIDGET(bind);
entry->cursor = (char *)next_begin_word(entry->cursor, entry->end);
while (gnt_util_onscreen_width(entry->scroll, entry->cursor) >= widget->priv.width) {
entry->scroll = g_utf8_find_next_char(entry->scroll, NULL);
}
update_kill_ring(entry, ENTRY_JAIL, NULL, 0);
entry_redraw(widget);
return TRUE;
}
static void
finch_close_request(PurpleRequestType type, gpointer ui_handle)
{
GntWidget *widget = GNT_WIDGET(ui_handle);
if (type == PURPLE_REQUEST_FIELDS) {
PurpleRequestFields *fields = g_object_get_data(G_OBJECT(widget), "fields");
purple_request_fields_destroy(fields);
}
while (widget->parent)
widget = widget->parent;
gnt_widget_destroy(widget);
}
static void
file_cb(GntFileSel *w, const char *path, const char *file, gpointer data)
{
FinchSoundEvent *event = data;
g_free(event->file);
event->file = g_strdup(path);
gnt_tree_change_text(GNT_TREE(pref_dialog->events), GINT_TO_POINTER(event->id), 1, file);
gnt_tree_set_choice(GNT_TREE(pref_dialog->events), GINT_TO_POINTER(event->id), TRUE);
gnt_widget_destroy(GNT_WIDGET(w));
}
static void
gnt_menu_toggled(GntTree *tree, gpointer key)
{
GntMenuItem *item = GNT_MENU_ITEM(key);
GntMenu *menu = GNT_MENU(tree);
gboolean check = gnt_menuitem_check_get_checked(GNT_MENU_ITEM_CHECK(item));
gnt_menuitem_check_set_checked(GNT_MENU_ITEM_CHECK(item), !check);
gnt_menuitem_activate(item);
while (menu) {
gnt_widget_hide(GNT_WIDGET(menu));
menu = menu->parentmenu;
}
}
static gboolean
move_back(GntBindable *bind, GList *null)
{
GntEntry *entry = GNT_ENTRY(bind);
if (entry->cursor <= entry->start)
return FALSE;
entry->cursor = g_utf8_find_prev_char(entry->start, entry->cursor);
if (entry->cursor < entry->scroll)
entry->scroll = entry->cursor;
update_kill_ring(entry, ENTRY_JAIL, NULL, 0);
entry_redraw(GNT_WIDGET(entry));
return TRUE;
}
