inline static void
personal_save(char *fname, struct account *account)
{
struct csv_header *header;
struct csv_row *row;
FILE *stream;
if ((stream = fopen(fname, "w")) == NULL)
ERROR("write personal: %s", fname);
header = csv_read_header_from_string(DEFAULT_HEADER);
prepare_header(header);
row = csv_create_row(header);
prepare_row(row, account);
csv_write_header(stream, header);
csv_write_row(stream, row);
csv_destory_row(row);
csv_destory_header(header);
fclose(stream);
}
static void
value_propagate_body (GimpDrawable *drawable,
GimpPreview *preview)
{
GimpImageType dtype;
ModeParam operation;
GimpPixelRgn srcRgn, destRgn;
guchar *here, *best, *dest;
guchar *dest_row, *prev_row, *cur_row, *next_row;
guchar *pr, *cr, *nr, *swap;
gint width, height, bytes, index;
gint begx, begy, endx, endy, x, y, dx;
gint left_index, right_index, up_index, down_index;
gpointer tmp;
GimpRGB foreground;
/* calculate neighbors' indexes */
left_index = (vpvals.direction_mask & (1 << Left2Right)) ? -1 : 0;
right_index = (vpvals.direction_mask & (1 << Right2Left)) ? 1 : 0;
up_index = (vpvals.direction_mask & (1 << Top2Bottom)) ? -1 : 0;
down_index = (vpvals.direction_mask & (1 << Bottom2Top)) ? 1 : 0;
operation = modes[vpvals.propagate_mode];
tmp = NULL;
dtype = gimp_drawable_type (drawable->drawable_id);
bytes = drawable->bpp;
/* Here I use the algorithm of blur.c */
if (preview)
{
gimp_preview_get_position (preview, &begx, &begy);
gimp_preview_get_size (preview, &width, &height);
endx = begx + width;
endy = begy + height;
}
else
{
if (! gimp_drawable_mask_intersect (drawable->drawable_id,
&begx, &begy, &width, &height))
return;
endx = begx + width;
endy = begy + height;
}
gimp_tile_cache_ntiles (2 * ((width) / gimp_tile_width () + 1));
prev_row = g_new (guchar, (width + 2) * bytes);
cur_row = g_new (guchar, (width + 2) * bytes);
next_row = g_new (guchar, (width + 2) * bytes);
dest_row = g_new (guchar, width * bytes);
gimp_pixel_rgn_init (&srcRgn, drawable,
begx, begy, width, height,
FALSE, FALSE);
gimp_pixel_rgn_init (&destRgn, drawable,
begx, begy, width, height,
(preview == NULL), TRUE);
pr = prev_row + bytes;
cr = cur_row + bytes;
nr = next_row + bytes;
prepare_row (&srcRgn, pr, begx, (0 < begy) ? begy : begy - 1, endx-begx);
prepare_row (&srcRgn, cr, begx, begy, endx-begx);
best = g_new (guchar, bytes);
if (!preview)
gimp_progress_init (_("Value Propagate"));
gimp_context_get_foreground (&foreground);
gimp_rgb_get_uchar (&foreground, fore+0, fore+1, fore+2);
/* start real job */
for (y = begy ; y < endy ; y++)
{
prepare_row (&srcRgn, nr, begx, ((y+1) < endy) ? y+1 : endy, endx-begx);
for (index = 0; index < (endx - begx) * bytes; index++)
dest_row[index] = cr[index];
for (x = 0 ; x < endx - begx; x++)
{
dest = dest_row + (x * bytes);
here = cr + (x * bytes);
/* *** copy source value to best value holder *** */
memcpy (best, here, bytes);
if (operation.initializer)
(* operation.initializer)(dtype, bytes, best, here, &tmp);
/* *** gather neighbors' values: loop-unfolded version *** */
if (up_index == -1)
for (dx = left_index ; dx <= right_index ; dx++)
(* operation.updater)(dtype, bytes, here, pr+((x+dx)*bytes), best, tmp);
for (dx = left_index ; dx <= right_index ; dx++)
if (dx != 0)
(* operation.updater)(dtype, bytes, here, cr+((x+dx)*bytes), best, tmp);
if (down_index == 1)
for (dx = left_index ; dx <= right_index ; dx++)
(* operation.updater)(dtype, bytes, here, nr+((x+dx)*bytes), best, tmp);
/* *** store it to dest_row*** */
(* operation.finalizer)(dtype, bytes, best, here, dest, tmp);
}
/* now store destline to destRgn */
gimp_pixel_rgn_set_row (&destRgn, dest_row, begx, y, endx - begx);
/* shift the row pointers */
swap = pr;
pr = cr;
cr = nr;
nr = swap;
if (((y % 16) == 0) && !preview)
gimp_progress_update ((gdouble) y / (gdouble) (endy - begy));
}
if (preview)
{
gimp_drawable_preview_draw_region (GIMP_DRAWABLE_PREVIEW (preview),
&destRgn);
}
else
{
/* update the region */
gimp_progress_update (1.0);
gimp_drawable_flush (drawable);
gimp_drawable_merge_shadow (drawable->drawable_id, TRUE);
gimp_drawable_update (drawable->drawable_id, begx, begy, endx-begx, endy-begy);
}
}
/**
* Append entry to list of found items
*
* @param __dir - directory where item has been found
* @param __name - name of item
* @param __stat - stat information of item
* @param __res_wnd - window with results
*/
static void
append_result (const wchar_t *__dir, const wchar_t *__name, vfs_stat_t __stat,
action_find_res_wnd_t *__res_wnd)
{
wchar_t *string, *dummy;
size_t len, tmp_len;
wchar_t buf[128];
wchar_t suffix;
w_list_item_t *item;
#ifdef __USE_FILE_OFFSET64
__u64_t size;
static wchar_t format[] = L"%lld %c";
#else
__u32_t size;
static wchar_t format[] = L"%ld %c";
#endif
len = __res_wnd->list->position.width - 2;
string = malloc ((len + 1) * sizeof (wchar_t));
dummy = malloc ((len + 1) * sizeof (wchar_t));
/* Append directory for which item belongs to */
if (!__res_wnd->dir_opened)
{
size_t l;
prepare_row (string, len);
l = __res_wnd->list->position.width / 4 * 3 - 5;
fit_dirname (__dir, l, dummy);
print_cell (string, dummy, 0, len);
print_cell (string, _(L"<DIR>"), l + 1, len);
item = w_list_append_item (__res_wnd->list, string, FIND_RES_DIR);
store_item_value (item, FIND_RES_DIR, __dir, NULL);
__res_wnd->dir_opened = TRUE;
}
prepare_row (string, len);
/* Name of file */
fit_dirname (__name, __res_wnd->list->position.width / 2, dummy);
print_cell (string, dummy, 4, len);
/* Mode of file */
umasktowcs (__stat.st_mode, buf);
print_cell (string, buf, __res_wnd->list->position.width - 10, len);
/* Modification time */
format_file_time (buf, BUF_LEN (buf), __stat.st_mtime);
print_cell (string, buf, __res_wnd->list->position.width - 24, len);
/* Size of file */
if (!S_ISDIR (__stat.st_mode))
{
size = fsizetohuman (__stat.st_size, &suffix);
swprintf (buf, BUF_LEN(buf), format, size, suffix);
}
else
{
wcscpy (buf, _(L"<DIR>"));
}
tmp_len = wcslen (buf);
if (buf[tmp_len - 1] == ' ')
{
buf[tmp_len - 1] = 0;
--tmp_len;
}
print_cell (string, buf,
__res_wnd->list->position.width - 26 - tmp_len, len);
item = w_list_append_item (__res_wnd->list, string, FIND_RES_ITEM);
store_item_value (item, FIND_RES_ITEM, __dir, __name);
free (string);
free (dummy);
}
