static void t_key(ui_tab_t *tab, guint64 key) { tab_t *t = (tab_t *)tab; if(ui_listing_key(t->list, key, winrows/2)) return; hub_user_t *sel = g_sequence_iter_is_end(t->list->sel) ? NULL : g_sequence_get(t->list->sel); gboolean sort = FALSE; switch(key) { case INPT_CHAR('?'): uit_main_keys("userlist"); break; // Sorting #define SETSORT(c) \ t->reverse = t->order == c ? !t->reverse : FALSE;\ t->order = c;\ sort = TRUE; case INPT_CHAR('s'): // s/S - sort on share size case INPT_CHAR('S'): SETSORT(SORT_SHARE); break; case INPT_CHAR('u'): // u/U - sort on username case INPT_CHAR('U'): SETSORT(SORT_USER) break; case INPT_CHAR('D'): // D - sort on description SETSORT(SORT_DESC) break; case INPT_CHAR('T'): // T - sort on client (= tag) SETSORT(SORT_CLIENT) break; case INPT_CHAR('E'): // E - sort on email SETSORT(SORT_MAIL) break; case INPT_CHAR('C'): // C - sort on connection SETSORT(SORT_CONN) break; case INPT_CHAR('P'): // P - sort on IP SETSORT(SORT_IP) break; case INPT_CHAR('o'): // o - toggle sorting OPs before others t->opfirst = !t->opfirst; sort = TRUE; break; #undef SETSORT // Column visibility case INPT_CHAR('d'): // d (toggle description visibility) t->hide_desc = !t->hide_desc; break; case INPT_CHAR('t'): // t (toggle tag visibility) t->hide_tag = !t->hide_tag; break; case INPT_CHAR('e'): // e (toggle e-mail visibility) t->hide_mail = !t->hide_mail; break; case INPT_CHAR('c'): // c (toggle connection visibility) t->hide_conn = !t->hide_conn; break; case INPT_CHAR('p'): // p (toggle IP visibility) t->hide_ip = !t->hide_ip; break; case INPT_CTRL('j'): // newline case INPT_CHAR('i'): // i (toggle user info) t->details = !t->details; break; case INPT_CHAR('m'): // m (/msg user) if(!sel) ui_m(NULL, 0, "No user selected."); else uit_msg_open(sel->uid, tab); break; case INPT_CHAR('g'): // g (grant slot) if(!sel) ui_m(NULL, 0, "No user selected."); else { db_users_set(sel->hub->id, sel->uid, sel->name, db_users_get(sel->hub->id, sel->name) | DB_USERFLAG_GRANT); ui_m(NULL, 0, "Slot granted."); } break; case INPT_CHAR('b'): // b (/browse userlist) case INPT_CHAR('B'): // B (force /browse userlist) if(!sel) ui_m(NULL, 0, "No user selected."); else uit_fl_queue(sel->uid, key == INPT_CHAR('B'), NULL, tab, TRUE, FALSE); break; case INPT_CHAR('q'): // q - download filelist and match queue for selected user if(!sel) ui_m(NULL, 0, "No user selected."); else uit_fl_queue(sel->uid, FALSE, NULL, NULL, FALSE, TRUE); break; } if(sort) { g_sequence_sort(t->list->list, sort_func, tab); ui_listing_sorted(t->list); ui_mf(NULL, 0, "Ordering by %s (%s%s)", t->order == SORT_USER ? "user name" : t->order == SORT_SHARE ? "share size" : t->order == SORT_CONN ? "connection" : t->order == SORT_DESC ? "description" : t->order == SORT_MAIL ? "e-mail" : t->order == SORT_CLIENT? "tag" : "IP address", t->reverse ? "descending" : "ascending", t->opfirst ? ", OPs first" : ""); } }
static void nemo_list_model_get_value (GtkTreeModel *tree_model, GtkTreeIter *iter, int column, GValue *value) { NemoListModel *model; FileEntry *file_entry; NemoFile *file; char *str; GdkPixbuf *icon, *rendered_icon; GIcon *gicon, *emblemed_icon, *emblem_icon; NemoIconInfo *icon_info; GEmblem *emblem; GList *emblem_icons, *l; int icon_size; NemoZoomLevel zoom_level; NemoFile *parent_file; char *emblems_to_ignore[3]; int i; NemoFileIconFlags flags; model = (NemoListModel *)tree_model; g_return_if_fail (model->details->stamp == iter->stamp); g_return_if_fail (!g_sequence_iter_is_end (iter->user_data)); file_entry = g_sequence_get (iter->user_data); file = file_entry->file; switch (column) { case NEMO_LIST_MODEL_FILE_COLUMN: g_value_init (value, NEMO_TYPE_FILE); g_value_set_object (value, file); break; case NEMO_LIST_MODEL_SUBDIRECTORY_COLUMN: g_value_init (value, NEMO_TYPE_DIRECTORY); g_value_set_object (value, file_entry->subdirectory); break; case NEMO_LIST_MODEL_SMALLEST_ICON_COLUMN: case NEMO_LIST_MODEL_SMALLER_ICON_COLUMN: case NEMO_LIST_MODEL_SMALL_ICON_COLUMN: case NEMO_LIST_MODEL_STANDARD_ICON_COLUMN: case NEMO_LIST_MODEL_LARGE_ICON_COLUMN: case NEMO_LIST_MODEL_LARGER_ICON_COLUMN: case NEMO_LIST_MODEL_LARGEST_ICON_COLUMN: g_value_init (value, GDK_TYPE_PIXBUF); if (file != NULL) { zoom_level = nemo_list_model_get_zoom_level_from_column_id (column); icon_size = nemo_get_icon_size_for_zoom_level (zoom_level); flags = NEMO_FILE_ICON_FLAGS_USE_THUMBNAILS | NEMO_FILE_ICON_FLAGS_FORCE_THUMBNAIL_SIZE | NEMO_FILE_ICON_FLAGS_USE_MOUNT_ICON_AS_EMBLEM; if (model->details->drag_view != NULL) { GtkTreePath *path_a, *path_b; gtk_tree_view_get_drag_dest_row (model->details->drag_view, &path_a, NULL); if (path_a != NULL) { path_b = gtk_tree_model_get_path (tree_model, iter); if (gtk_tree_path_compare (path_a, path_b) == 0) { flags |= NEMO_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT; } gtk_tree_path_free (path_a); gtk_tree_path_free (path_b); } } gicon = G_ICON (nemo_file_get_icon_pixbuf (file, icon_size, TRUE, flags)); /* render emblems with GEmblemedIcon */ parent_file = nemo_file_get_parent (file); i = 0; emblems_to_ignore[i++] = NEMO_FILE_EMBLEM_NAME_TRASH; if (parent_file) { if (!nemo_file_can_write (parent_file)) { emblems_to_ignore[i++] = NEMO_FILE_EMBLEM_NAME_CANT_WRITE; } nemo_file_unref (parent_file); } emblems_to_ignore[i++] = NULL; emblem_icons = nemo_file_get_emblem_icons (file, emblems_to_ignore); /* pick only the first emblem we can render for the list view */ for (l = emblem_icons; l != NULL; l = l->next) { emblem_icon = l->data; if (nemo_icon_theme_can_render (G_THEMED_ICON (emblem_icon))) { emblem = g_emblem_new (emblem_icon); emblemed_icon = g_emblemed_icon_new (gicon, emblem); g_object_unref (gicon); g_object_unref (emblem); gicon = emblemed_icon; break; } } g_list_free_full (emblem_icons, g_object_unref); icon_info = nemo_icon_info_lookup (gicon, icon_size); icon = nemo_icon_info_get_pixbuf_at_size (icon_info, icon_size); g_object_unref (icon_info); g_object_unref (gicon); if (model->details->highlight_files != NULL && g_list_find_custom (model->details->highlight_files, file, (GCompareFunc) nemo_file_compare_location)) { rendered_icon = eel_create_spotlight_pixbuf (icon); if (rendered_icon != NULL) { g_object_unref (icon); icon = rendered_icon; } } g_value_set_object (value, icon); g_object_unref (icon); } break; case NEMO_LIST_MODEL_FILE_NAME_IS_EDITABLE_COLUMN: g_value_init (value, G_TYPE_BOOLEAN); g_value_set_boolean (value, file != NULL && nemo_file_can_rename (file)); break; default: if (column >= NEMO_LIST_MODEL_NUM_COLUMNS || column < NEMO_LIST_MODEL_NUM_COLUMNS + model->details->columns->len) { NemoColumn *nemo_column; GQuark attribute; nemo_column = model->details->columns->pdata[column - NEMO_LIST_MODEL_NUM_COLUMNS]; g_value_init (value, G_TYPE_STRING); g_object_get (nemo_column, "attribute_q", &attribute, NULL); if (file != NULL) { str = nemo_file_get_string_attribute_with_default_q (file, attribute); g_value_take_string (value, str); } else if (attribute == attribute_name_q) { if (file_entry->parent->loaded) { g_value_set_string (value, _("(Empty)")); } else { g_value_set_string (value, _("Loading...")); } } } else { g_assert_not_reached (); } } }
static void t_draw(ui_tab_t *tab) { tab_t *t = (tab_t *)tab; calc_widths(t); // header attron(UIC(list_header)); mvhline(1, 0, ' ', wincols); mvaddstr(1, 2, "opt"); int i = 6; DRAW_COL(1, i, t->cw_country, "CC"); DRAW_COL(1, i, t->cw_user, "Username"); DRAW_COL(1, i, t->cw_share, "Share"); DRAW_COL(1, i, t->cw_desc, "Description"); DRAW_COL(1, i, t->cw_tag, "Tag"); DRAW_COL(1, i, t->cw_mail, "E-Mail"); DRAW_COL(1, i, t->cw_conn, "Connection"); DRAW_COL(1, i, t->cw_ip, "IP"); attroff(UIC(list_header)); // rows int bottom = t->details ? winrows-7 : winrows-3; ui_cursor_t cursor; int pos = ui_listing_draw(t->list, 2, bottom-1, &cursor, draw_row); // footer attron(UIC(separator)); mvhline(bottom, 0, ' ', wincols); int count = g_hash_table_size(t->tab.hub->users); mvaddstr(bottom, 0, "Totals:"); mvprintw(bottom, t->cw_user+6, "%s%c %d users", str_formatsize(t->tab.hub->sharesize), t->tab.hub->sharecount == count ? ' ' : '+', count); mvprintw(bottom, wincols-6, "%3d%%", pos); attroff(UIC(separator)); // detailed info box if(t->details && g_sequence_iter_is_end(t->list->sel)) mvaddstr(bottom+1, 2, "No user selected."); else if(t->details) { hub_user_t *u = g_sequence_get(t->list->sel); attron(A_BOLD); mvaddstr(bottom+1, 4, "Username:"******"Share:"); mvaddstr(bottom+2, 2, "Connection:"); mvaddstr(bottom+2, 25+19, "IP:"); mvaddstr(bottom+3, 6, "E-Mail:"); mvaddstr(bottom+3, 25+18, "Tag:"); mvaddstr(bottom+4, 1, "Description:"); attroff(A_BOLD); mvaddstr(bottom+1, 14, u->name); if(u->hasinfo) mvprintw(bottom+1, 25+23, "%s (%s bytes)", str_formatsize(u->sharesize), str_fullsize(u->sharesize)); else mvaddstr(bottom+1, 25+23, "-"); char *conn = hub_user_conn(u); mvaddstr(bottom+2, 14, conn?conn:"-"); g_free(conn); mvaddstr(bottom+2, 25+23, hub_user_ip(u, "-")); mvaddstr(bottom+3, 14, u->mail?u->mail:"-"); char *tag = hub_user_tag(u); mvaddstr(bottom+3, 25+23, tag?tag:"-"); g_free(tag); mvaddstr(bottom+4, 14, u->desc?u->desc:"-"); // TODO: CID? } move(cursor.y, cursor.x); }
static ClutterModelIter * clutter_list_model_get_iter_at_row (ClutterModel *model, guint row) { ClutterListModel *model_default = CLUTTER_LIST_MODEL (model); GSequence *sequence = model_default->priv->sequence; gint seq_length = g_sequence_get_length (sequence); ClutterListModelIter *retval; if (row >= seq_length) return NULL; retval = g_object_new (CLUTTER_TYPE_LIST_MODEL_ITER, "model", model, "row", row, NULL); /* short-circuit in case we don't have a filter in place */ if (!clutter_model_get_filter_set (model)) { retval->seq_iter = g_sequence_get_iter_at_pos (sequence, row); return CLUTTER_MODEL_ITER (retval); } if (row == 0) { GSequenceIter *filter_next; gboolean row_found = FALSE; filter_next = g_sequence_get_begin_iter (sequence); g_assert (filter_next != NULL); while (!g_sequence_iter_is_end (filter_next)) { retval->seq_iter = filter_next; if (clutter_model_filter_iter (model, CLUTTER_MODEL_ITER (retval))) { /* We've found a row that is valid under the filter */ row_found = TRUE; break; } filter_next = g_sequence_iter_next (filter_next); } /* Everything has been filtered -> there is no first row */ if (!row_found) { g_object_unref (retval); return NULL; } } else { GSequenceIter *filter_prev; filter_prev = g_sequence_get_end_iter (sequence); g_assert (filter_prev != NULL); filter_prev = g_sequence_iter_prev (filter_prev); while (!g_sequence_iter_is_begin (filter_prev)) { retval->seq_iter = filter_prev; if (clutter_model_filter_iter (model, CLUTTER_MODEL_ITER (retval))) break; filter_prev = g_sequence_iter_prev (filter_prev); } } return CLUTTER_MODEL_ITER (retval); }
/** * @brief Remove an alarm by id. * * {"alarmId":1} * * Response: * * {"returnValue":true} * * @param sh * @param message * @param ctx * * @retval */ static bool alarmRemove(LSHandle *sh, LSMessage *message, void *ctx) { LSError lserror; LSErrorInit(&lserror); bool found = false; bool retVal; const char *payload = LSMessageGetPayload(message); struct json_object *object = json_tokener_parse(payload); if (is_error(object)) { goto malformed_json; } SLEEPDLOG(LOG_DEBUG, "%s: %s", __FUNCTION__, LSMessageGetPayload(message)); int alarmId = json_object_get_int(json_object_object_get(object, "alarmId")); GSequenceIter *iter = g_sequence_get_begin_iter(gAlarmQueue->alarms); while (!g_sequence_iter_is_end (iter)) { _Alarm *alarm = (_Alarm*)g_sequence_get(iter); GSequenceIter *next = g_sequence_iter_next(iter); if (alarm && alarm->id == alarmId) { char *timeout_key = g_strdup_printf("%s-%d", alarm->key, alarm->id); _timeout_clear("com.palm.sleep", timeout_key, false /*public_bus*/); g_free(timeout_key); g_sequence_remove(iter); found = true; } iter = next; } const char *response; if (found) { alarm_write_db(); response = "{\"returnValue\":true}"; } else { response = "{\"returnValue\":false}"; } retVal = LSMessageReply(sh, message, response, &lserror); if (!retVal) { LSErrorPrint(&lserror,stderr); LSErrorFree(&lserror); } goto cleanup; malformed_json: LSMessageReplyErrorBadJSON(sh, message); goto cleanup; cleanup: if (!is_error(object)) json_object_put(object); return true; }
/** * @brief Query for set of alarms identified by 'serviceName' & 'key'. * * {"serviceName":"com.palm.X", "key":"calendarAlarm"} * * Response: * * {"alarms": * [{"alarmId":1,"key":"calendarAlarm"}, * {"alarmId":2,"key":"calendarAlarm"}, * ]} * * @param sh * @param message * @param ctx * * @retval */ static bool alarmQuery(LSHandle *sh, LSMessage *message, void *ctx) { bool retVal; const char *serviceName, *key; struct json_object *object; GString *alarm_str = NULL; GString *buf = NULL; object = json_tokener_parse(LSMessageGetPayload(message)); if ( is_error(object) ) { goto malformed_json; } serviceName = json_object_get_string( json_object_object_get(object, "serviceName")); key = json_object_get_string( json_object_object_get(object, "key")); if (!serviceName || !key) goto invalid_format; alarm_str = g_string_sized_new(512); if (!alarm_str) goto cleanup; bool first = true; GSequenceIter *iter = g_sequence_get_begin_iter(gAlarmQueue->alarms); while (!g_sequence_iter_is_end (iter)) { _Alarm *alarm = (_Alarm*)g_sequence_get(iter); GSequenceIter *next = g_sequence_iter_next(iter); if (alarm && alarm->serviceName && alarm->key && (strcmp(alarm->serviceName, serviceName) == 0) && (strcmp(alarm->key, key) == 0)) { g_string_append_printf(alarm_str, "%s{\"alarmId\":%d,\"key\":\"%s\"}", first ? "" : "\n,", alarm->id, alarm->key); first = false; } iter = next; } buf = g_string_sized_new(512); g_string_append_printf(buf, "{\"alarms\": [%s]}", alarm_str->str); LSError lserror; LSErrorInit(&lserror); retVal = LSMessageReply(sh, message, buf->str, &lserror); if (!retVal) { LSErrorPrint(&lserror, stderr); LSErrorFree(&lserror); } goto cleanup; invalid_format: retVal = LSMessageReply(sh, message, "{\"returnValue\":false," "\"errorText\":\"alarmQuery parameters are missing.\"}", &lserror); goto cleanup; malformed_json: LSMessageReplyErrorBadJSON(sh, message); goto cleanup; cleanup: if (alarm_str) g_string_free(alarm_str, TRUE); if (buf) g_string_free(buf, TRUE); if (!is_error(object)) json_object_put(object); return true; }
static void nautilus_list_model_get_value (GtkTreeModel *tree_model, GtkTreeIter *iter, int column, GValue *value) { NautilusListModel *model; FileEntry *file_entry; NautilusFile *file; char *str; GdkPixbuf *icon, *rendered_icon; int icon_size, icon_scale; NautilusListZoomLevel zoom_level; NautilusFileIconFlags flags; cairo_surface_t *surface; model = (NautilusListModel *)tree_model; g_return_if_fail (model->details->stamp == iter->stamp); g_return_if_fail (!g_sequence_iter_is_end (iter->user_data)); file_entry = g_sequence_get (iter->user_data); file = file_entry->file; switch (column) { case NAUTILUS_LIST_MODEL_FILE_COLUMN: g_value_init (value, NAUTILUS_TYPE_FILE); g_value_set_object (value, file); break; case NAUTILUS_LIST_MODEL_SUBDIRECTORY_COLUMN: g_value_init (value, NAUTILUS_TYPE_DIRECTORY); g_value_set_object (value, file_entry->subdirectory); break; case NAUTILUS_LIST_MODEL_SMALL_ICON_COLUMN: case NAUTILUS_LIST_MODEL_STANDARD_ICON_COLUMN: case NAUTILUS_LIST_MODEL_LARGE_ICON_COLUMN: g_value_init (value, CAIRO_GOBJECT_TYPE_SURFACE); if (file != NULL) { zoom_level = nautilus_list_model_get_zoom_level_from_column_id (column); icon_size = nautilus_list_model_get_icon_size_for_zoom_level (zoom_level); icon_scale = nautilus_list_model_get_icon_scale (model); flags = NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS | NAUTILUS_FILE_ICON_FLAGS_FORCE_THUMBNAIL_SIZE | NAUTILUS_FILE_ICON_FLAGS_USE_EMBLEMS | NAUTILUS_FILE_ICON_FLAGS_USE_ONE_EMBLEM; if (model->details->drag_view != NULL) { GtkTreePath *path_a, *path_b; gtk_tree_view_get_drag_dest_row (model->details->drag_view, &path_a, NULL); if (path_a != NULL) { path_b = gtk_tree_model_get_path (tree_model, iter); if (gtk_tree_path_compare (path_a, path_b) == 0) { flags |= NAUTILUS_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT; } gtk_tree_path_free (path_a); gtk_tree_path_free (path_b); } } icon = nautilus_file_get_icon_pixbuf (file, icon_size, TRUE, icon_scale, flags); if (model->details->highlight_files != NULL && g_list_find_custom (model->details->highlight_files, file, (GCompareFunc) nautilus_file_compare_location)) { rendered_icon = eel_create_spotlight_pixbuf (icon); if (rendered_icon != NULL) { g_object_unref (icon); icon = rendered_icon; } } surface = gdk_cairo_surface_create_from_pixbuf (icon, icon_scale, NULL); g_value_take_boxed (value, surface); g_object_unref (icon); } break; case NAUTILUS_LIST_MODEL_FILE_NAME_IS_EDITABLE_COLUMN: g_value_init (value, G_TYPE_BOOLEAN); g_value_set_boolean (value, file != NULL && nautilus_file_can_rename (file)); break; default: if (column >= NAUTILUS_LIST_MODEL_NUM_COLUMNS || column < NAUTILUS_LIST_MODEL_NUM_COLUMNS + model->details->columns->len) { NautilusColumn *nautilus_column; GQuark attribute; nautilus_column = model->details->columns->pdata[column - NAUTILUS_LIST_MODEL_NUM_COLUMNS]; g_value_init (value, G_TYPE_STRING); g_object_get (nautilus_column, "attribute_q", &attribute, NULL); if (file != NULL) { str = nautilus_file_get_string_attribute_with_default_q (file, attribute); g_value_take_string (value, str); } else if (attribute == attribute_name_q) { if (file_entry->parent->loaded) { g_value_set_string (value, _("(Empty)")); } else { g_value_set_string (value, _("Loading…")); } } } else { g_assert_not_reached (); } } }
static void gtk_mate_exporter_scope_to_html (GtkMateExporter* self, GString* _result_, GtkMateScope* scope) { char* names; gboolean _tmp0_; GtkTextIter position; gboolean opened_inner; gboolean closed_inner; gboolean _tmp26_; g_return_if_fail (self != NULL); g_return_if_fail (_result_ != NULL); g_return_if_fail (scope != NULL); names = gtk_mate_exporter_css_names (self, scope, FALSE); _tmp0_ = FALSE; if (_vala_strcmp0 (names, "") != 0) { _tmp0_ = names != NULL; } else { _tmp0_ = FALSE; } if (_tmp0_) { char* _tmp2_; char* _tmp1_; _tmp2_ = NULL; _tmp1_ = NULL; g_string_append (_result_, _tmp2_ = g_strconcat (_tmp1_ = g_strconcat ("<span class=\"", names, NULL), "\">", NULL)); _tmp2_ = (g_free (_tmp2_), NULL); _tmp1_ = (g_free (_tmp1_), NULL); } position = gtk_mate_scope_start_iter (scope); opened_inner = FALSE; closed_inner = FALSE; if (g_sequence_get_length (gtk_mate_scope_get_children (scope)) > 0) { GSequenceIter* iter; GtkMateScope* child; gboolean _tmp15_; iter = g_sequence_get_begin_iter (gtk_mate_scope_get_children (scope)); child = NULL; while (!g_sequence_iter_is_end (iter)) { GtkMateScope* _tmp8_; GtkMateScope* _tmp7_; GtkTextIter _tmp9_ = {0}; if (gtk_mate_exporter_scope_has_inner (self, scope)) { gboolean _tmp3_; GtkTextIter _tmp4_ = {0}; _tmp3_ = FALSE; if (gtk_text_iter_compare (&position, (_tmp4_ = gtk_mate_scope_inner_start_iter (scope), &_tmp4_)) >= 0) { _tmp3_ = !opened_inner; } else { _tmp3_ = FALSE; } if (_tmp3_) { char* inner_names; char* _tmp6_; char* _tmp5_; inner_names = gtk_mate_exporter_css_names (self, scope, TRUE); _tmp6_ = NULL; _tmp5_ = NULL; g_string_append (_result_, _tmp6_ = g_strconcat (_tmp5_ = g_strconcat ("<span class=\"", inner_names, NULL), "\">", NULL)); _tmp6_ = (g_free (_tmp6_), NULL); _tmp5_ = (g_free (_tmp5_), NULL); opened_inner = TRUE; inner_names = (g_free (inner_names), NULL); } } _tmp8_ = NULL; _tmp7_ = NULL; child = (_tmp8_ = (_tmp7_ = (GtkMateScope*) g_sequence_get (iter), (_tmp7_ == NULL) ? NULL : g_object_ref (_tmp7_)), (child == NULL) ? NULL : (child = (g_object_unref (child), NULL)), _tmp8_); if (gtk_text_iter_compare ((_tmp9_ = gtk_mate_scope_start_iter (child), &_tmp9_), &position) > 0) { char* _tmp12_; GtkTextIter _tmp11_ = {0}; GtkMateBuffer* _tmp10_; _tmp12_ = NULL; _tmp10_ = NULL; g_string_append (_result_, _tmp12_ = g_markup_escape_text (gtk_text_buffer_get_slice ((GtkTextBuffer*) (_tmp10_ = gtk_mate_exporter_buffer (self)), &position, (_tmp11_ = gtk_mate_scope_start_iter (child), &_tmp11_), TRUE), -1)); _tmp12_ = (g_free (_tmp12_), NULL); (_tmp10_ == NULL) ? NULL : (_tmp10_ = (g_object_unref (_tmp10_), NULL)); position = gtk_mate_scope_start_iter (child); } if (gtk_mate_exporter_scope_has_inner (self, scope)) { gboolean _tmp13_; GtkTextIter _tmp14_ = {0}; _tmp13_ = FALSE; if (gtk_text_iter_compare (&position, (_tmp14_ = gtk_mate_scope_inner_end_iter (scope), &_tmp14_)) >= 0) { _tmp13_ = !closed_inner; } else { _tmp13_ = FALSE; } if (_tmp13_) { g_string_append (_result_, "</span>"); closed_inner = TRUE; } } gtk_mate_exporter_scope_to_html (self, _result_, child); position = gtk_mate_scope_end_iter (child); iter = g_sequence_iter_next (iter); } _tmp15_ = FALSE; if (child != NULL) { GtkTextIter _tmp17_ = {0}; GtkTextIter _tmp16_ = {0}; _tmp15_ = gtk_text_iter_compare ((_tmp16_ = gtk_mate_scope_end_iter (child), &_tmp16_), (_tmp17_ = gtk_mate_scope_end_iter (scope), &_tmp17_)) < 0; } else { _tmp15_ = FALSE; } if (_tmp15_) { char* _tmp21_; GtkTextIter _tmp20_ = {0}; GtkTextIter _tmp19_ = {0}; GtkMateBuffer* _tmp18_; _tmp21_ = NULL; _tmp18_ = NULL; g_string_append (_result_, _tmp21_ = g_markup_escape_text (gtk_text_buffer_get_slice ((GtkTextBuffer*) (_tmp18_ = gtk_mate_exporter_buffer (self)), (_tmp19_ = gtk_mate_scope_end_iter (child), &_tmp19_), (_tmp20_ = gtk_mate_scope_end_iter (scope), &_tmp20_), TRUE), -1)); _tmp21_ = (g_free (_tmp21_), NULL); (_tmp18_ == NULL) ? NULL : (_tmp18_ = (g_object_unref (_tmp18_), NULL)); } (child == NULL) ? NULL : (child = (g_object_unref (child), NULL)); } else { char* _tmp25_; GtkTextIter _tmp24_ = {0}; GtkTextIter _tmp23_ = {0}; GtkMateBuffer* _tmp22_; _tmp25_ = NULL; _tmp22_ = NULL; g_string_append (_result_, _tmp25_ = g_markup_escape_text (gtk_text_buffer_get_slice ((GtkTextBuffer*) (_tmp22_ = gtk_mate_exporter_buffer (self)), (_tmp23_ = gtk_mate_scope_start_iter (scope), &_tmp23_), (_tmp24_ = gtk_mate_scope_end_iter (scope), &_tmp24_), TRUE), -1)); _tmp25_ = (g_free (_tmp25_), NULL); (_tmp22_ == NULL) ? NULL : (_tmp22_ = (g_object_unref (_tmp22_), NULL)); } _tmp26_ = FALSE; if (_vala_strcmp0 (names, "") != 0) { _tmp26_ = names != NULL; } else { _tmp26_ = FALSE; } if (_tmp26_) { g_string_append (_result_, "</span>"); } names = (g_free (names), NULL); return; }