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;
}
