#define COLOR_MAN_CHUNK_SIZE 81900
-static void color_man_lib_init(void)
+static void color_man_lib_init()
{
static gboolean init_done = FALSE;
#endif
}
-static cmsHPROFILE color_man_create_adobe_comp(void)
+static cmsHPROFILE color_man_create_adobe_comp()
{
/* ClayRGB1998 is AdobeRGB compatible */
#include "ClayRGB1998_icc.h"
*-------------------------------------------------------------------
*/
-static GList *cm_cache_list = NULL;
+static GList *cm_cache_list = nullptr;
static void color_man_cache_ref(ColorManCache *cc)
static cmsHPROFILE color_man_cache_load_profile(ColorManProfileType type, const gchar *file,
guchar *data, guint data_len)
{
- cmsHPROFILE profile = NULL;
+ cmsHPROFILE profile = nullptr;
switch (type)
{
(!cc->profile_in) ? cc->profile_in_file : cc->profile_out_file);
color_man_cache_unref(cc);
- return NULL;
+ return nullptr;
}
cc->transform = cmsCreateTransform(cc->profile_in,
DEBUG_1("failed to create color profile transform");
color_man_cache_unref(cc);
- return NULL;
+ return nullptr;
}
if (cc->profile_in_type != COLOR_PROFILE_MEM && cc->profile_out_type != COLOR_PROFILE_MEM )
color_man_cache_unref(cc);
}
-static void color_man_cache_reset(void)
+static void color_man_cache_reset()
{
while (cm_cache_list)
{
if (match) return cc;
}
- return NULL;
+ return nullptr;
}
static ColorManCache *color_man_cache_get(ColorManProfileType in_type, const gchar *in_file,
if (!cm->profile)
{
color_man_free(cm);
- return NULL;
+ return nullptr;
}
return cm;
guchar *screen_data, guint screen_data_len)
{
return color_man_new_real(imd, pixbuf,
- input_type, input_file, NULL, 0,
+ input_type, input_file, nullptr, 0,
screen_type, screen_file, screen_data, screen_data_len);
}
guchar *screen_data, guint screen_data_len)
{
return color_man_new_real(imd, pixbuf,
- COLOR_PROFILE_MEM, NULL, input_data, input_data_len,
+ COLOR_PROFILE_MEM, nullptr, input_data, input_data_len,
screen_type, screen_file, screen_data, screen_data_len);
}
g_free(cm);
}
-void color_man_update(void)
+void color_man_update()
{
color_man_cache_reset();
}
static cmsToneCurve* colorspaces_create_transfer(int32_t size, double (*fct)(double))
{
- float *values = static_cast<float *>(g_malloc(sizeof(float) * size));
+ auto values = static_cast<float *>(g_malloc(sizeof(float) * size));
for(int32_t i = 0; i < size; ++i)
{
values[i] = static_cast<float>(y);
}
- cmsToneCurve* result = cmsBuildTabulatedToneCurveFloat(NULL, size, values);
+ cmsToneCurve* result = cmsBuildTabulatedToneCurveFloat(nullptr, size, values);
g_free(values);
return result;
}
{
const gchar *primaries_name = "";
const gchar *trc_name = "";
- cmsHPROFILE *profile = NULL;
+ cmsHPROFILE *profile = nullptr;
cmsCIExyY whitepoint;
cmsCIExyYTRIPLE primaries;
cmsToneCurve *curve[3];
cmsUInt32Number size;
- guint8 *data = NULL;
+ guint8 *data = nullptr;
cmsFloat64Number srgb_parameters[5] =
{ 2.4, 1.0 / 1.055, 0.055 / 1.055, 1.0 / 12.92, 0.04045 };
cmsFloat64Number rec709_parameters[5] =
{ 2.2, 1.0 / 1.099, 0.099 / 1.099, 1.0 / 4.5, 0.081 };
- if (nclx == NULL)
+ if (nclx == nullptr)
{
- return NULL;
+ return nullptr;
}
if (nclx->color_primaries == heif_color_primaries_unspecified)
{
- return NULL;
+ return nullptr;
}
whitepoint.x = nclx->color_primary_white_x;
break;
default:
log_printf("nclx unsupported color_primaries value: %d\n", nclx->color_primaries);
- return NULL;
+ return nullptr;
break;
}
switch (nclx->transfer_characteristics)
{
case heif_transfer_characteristic_ITU_R_BT_709_5:
- curve[0] = curve[1] = curve[2] = cmsBuildParametricToneCurve(NULL, 4, rec709_parameters);
+ curve[0] = curve[1] = curve[2] = cmsBuildParametricToneCurve(nullptr, 4, rec709_parameters);
profile = static_cast<cmsHPROFILE *>(cmsCreateRGBProfile(&whitepoint, &primaries, curve));
cmsFreeToneCurve(curve[0]);
trc_name = "Rec709 RGB";
break;
case heif_transfer_characteristic_ITU_R_BT_470_6_System_M:
- curve[0] = curve[1] = curve[2] = cmsBuildGamma (NULL, 2.2f);
+ curve[0] = curve[1] = curve[2] = cmsBuildGamma (nullptr, 2.2f);
profile = static_cast<cmsHPROFILE *>(cmsCreateRGBProfile(&whitepoint, &primaries, curve));
cmsFreeToneCurve(curve[0]);
trc_name = "Gamma2.2 RGB";
break;
case heif_transfer_characteristic_ITU_R_BT_470_6_System_B_G:
- curve[0] = curve[1] = curve[2] = cmsBuildGamma (NULL, 2.8f);
+ curve[0] = curve[1] = curve[2] = cmsBuildGamma (nullptr, 2.8f);
profile = static_cast<cmsHPROFILE *>(cmsCreateRGBProfile(&whitepoint, &primaries, curve));
cmsFreeToneCurve(curve[0]);
trc_name = "Gamma2.8 RGB";
break;
case heif_transfer_characteristic_linear:
- curve[0] = curve[1] = curve[2] = cmsBuildGamma (NULL, 1.0f);
+ curve[0] = curve[1] = curve[2] = cmsBuildGamma (nullptr, 1.0f);
profile = static_cast<cmsHPROFILE *>(cmsCreateRGBProfile(&whitepoint, &primaries, curve));
cmsFreeToneCurve(curve[0]);
trc_name = "linear RGB";
case heif_transfer_characteristic_IEC_61966_2_1:
/* same as default */
default:
- curve[0] = curve[1] = curve[2] = cmsBuildParametricToneCurve(NULL, 4, srgb_parameters);
+ curve[0] = curve[1] = curve[2] = cmsBuildParametricToneCurve(nullptr, 4, srgb_parameters);
profile = static_cast<cmsHPROFILE *>(cmsCreateRGBProfile(&whitepoint, &primaries, curve));
cmsFreeToneCurve(curve[0]);
trc_name = "sRGB-TRC RGB";
if (profile)
{
- if (cmsSaveProfileToMem(profile, NULL, &size))
+ if (cmsSaveProfileToMem(profile, nullptr, &size))
{
data = static_cast<guint8 *>(g_malloc(size));
if (cmsSaveProfileToMem(profile, data, &size))
else
{
cmsCloseProfile(profile);
- return NULL;
+ return nullptr;
}
}
else
{
- return NULL;
+ return nullptr;
}
}
gint profile_type;
guchar *profile;
cmsUInt32Number size;
- guint8 *data = NULL;
+ guint8 *data = nullptr;
ctx = heif_context_alloc();
- error_code = heif_context_read_from_file(ctx, fd->path, NULL);
+ error_code = heif_context_read_from_file(ctx, fd->path, nullptr);
if (error_code.code)
{
log_printf("warning: heif reader error: %s\n", error_code.message);
heif_context_free(ctx);
- return NULL;
+ return nullptr;
}
error_code = heif_context_get_primary_image_handle(ctx, &handle);
{
log_printf("warning: heif reader error: %s\n", error_code.message);
heif_context_free(ctx);
- return NULL;
+ return nullptr;
}
nclxcp = heif_nclx_color_profile_alloc();
log_printf("warning: heif reader error: %s\n", error_code.message);
heif_context_free(ctx);
heif_nclx_color_profile_free(nclxcp);
- return NULL;
+ return nullptr;
}
DEBUG_1("heif color profile type: prof");
log_printf("warning: heif reader error: %s\n", error_code.message);
heif_context_free(ctx);
heif_nclx_color_profile_free(nclxcp);
- return NULL;
+ return nullptr;
}
profile = nclx_to_lcms_profile(nclxcp, profile_len);
#include "similar.h"
-/** @typedef DupeMatchType
+/** @enum DupeMatchType
* match methods
*/
enum DupeMatchType
EDITOR_ERROR_MASK = ~0xffff,
};
-struct _EditorDescription {
+struct EditorDescription {
gchar *key; /**< desktop file name, not including path, including extension */
gchar *name; /**< Name, localized name presented to user */
gchar *icon; /**< Icon */
script_name_utf8 = g_strdup(key + 4);
script_name = path_from_utf8(script_name_utf8);
- raw_data = lua_callvalue(fd, script_name, NULL);
+ raw_data = lua_callvalue(fd, script_name, nullptr);
valid_data = g_utf8_make_valid(raw_data, -1);
data = g_utf8_substring(valid_data, 0, 150);
/* this implements a simple LRU algorithm */
-struct _FileCacheData {
+struct FileCacheData {
FileCacheReleaseFunc release;
GList *list;
gulong max_size;
#include "main.h"
#include "filedata.h"
-using FileCacheData = struct _FileCacheData;
+struct FileCacheData;
using FileCacheReleaseFunc = void (*)(FileData *);
#include <glib.h>
#include "main.h"
-void lua_init(void);
+void lua_init();
gchar *lua_callvalue(FileData *fd, const gchar *file, const gchar *function);
#define HISTMAP_SIZE 256
-struct _HistMap {
+struct HistMap {
gulong r[HISTMAP_SIZE];
gulong g[HISTMAP_SIZE];
gulong b[HISTMAP_SIZE];
static gboolean image_loader_heif_load(gpointer loader, const guchar *buf, gsize count, GError **UNUSED(error))
{
- ImageLoaderHEIF *ld = static_cast<ImageLoaderHEIF *>(loader);
+ auto ld = static_cast<ImageLoaderHEIF *>(loader);
struct heif_context* ctx;
struct heif_image* img;
struct heif_error error_code;
ctx = heif_context_alloc();
- error_code = heif_context_read_from_memory_without_copy(ctx, buf, count, NULL);
+ error_code = heif_context_read_from_memory_without_copy(ctx, buf, count, nullptr);
if (error_code.code)
{
log_printf("warning: heif reader error: %s\n", error_code.message);
}
// decode the image and convert colorspace to RGB, saved as 24bit interleaved
- error_code = heif_decode_image(handle, &img, heif_colorspace_RGB, heif_chroma_interleaved_24bit, NULL);
+ error_code = heif_decode_image(handle, &img, heif_colorspace_RGB, heif_chroma_interleaved_24bit, nullptr);
if (error_code.code)
{
log_printf("warning: heif reader error: %s\n", error_code.message);
static gpointer image_loader_heif_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data)
{
- ImageLoaderHEIF *loader = g_new0(ImageLoaderHEIF, 1);
+ auto loader = g_new0(ImageLoaderHEIF, 1);
loader->area_updated_cb = area_updated_cb;
loader->size_cb = size_cb;
loader->area_prepared_cb = area_prepared_cb;
static void image_loader_heif_set_size(gpointer loader, int width, int height)
{
- ImageLoaderHEIF *ld = static_cast<ImageLoaderHEIF *>(loader);
+ auto ld = static_cast<ImageLoaderHEIF *>(loader);
ld->requested_width = width;
ld->requested_height = height;
}
static GdkPixbuf* image_loader_heif_get_pixbuf(gpointer loader)
{
- ImageLoaderHEIF *ld = static_cast<ImageLoaderHEIF *>(loader);
+ auto ld = static_cast<ImageLoaderHEIF *>(loader);
return ld->pixbuf;
}
static gchar** image_loader_heif_get_format_mime_types(gpointer UNUSED(loader))
{
- static const gchar *mime[] = {"image/heic", NULL};
+ static const gchar *mime[] = {"image/heic", nullptr};
return g_strdupv(const_cast<gchar **>(mime));
}
static void image_loader_heif_set_page_num(gpointer loader, gint page_num)
{
- ImageLoaderHEIF *ld = static_cast<ImageLoaderHEIF *>(loader);
+ auto ld = static_cast<ImageLoaderHEIF *>(loader);
ld->page_num = page_num;
}
static gint image_loader_heif_get_page_total(gpointer loader)
{
- ImageLoaderHEIF *ld = static_cast<ImageLoaderHEIF *>(loader);
+ auto ld = static_cast<ImageLoaderHEIF *>(loader);
return ld->page_total;
}
static void image_loader_heif_abort(gpointer loader)
{
- ImageLoaderHEIF *ld = static_cast<ImageLoaderHEIF *>(loader);
+ auto ld = static_cast<ImageLoaderHEIF *>(loader);
ld->abort = TRUE;
}
static void image_loader_heif_free(gpointer loader)
{
- ImageLoaderHEIF *ld = static_cast<ImageLoaderHEIF *>(loader);
+ auto ld = static_cast<ImageLoaderHEIF *>(loader);
if (ld->pixbuf) g_object_unref(ld->pixbuf);
g_free(ld);
}
funcs->loader_new = image_loader_heif_new;
funcs->set_size = image_loader_heif_set_size;
funcs->load = image_loader_heif_load;
- funcs->write = NULL;
+ funcs->write = nullptr;
funcs->get_pixbuf = image_loader_heif_get_pixbuf;
funcs->close = image_loader_heif_close;
funcs->abort = image_loader_heif_abort;
g_free (pixels);
}
-struct opj_buffer_info {
+struct opj_buffer_info_t {
OPJ_BYTE* buf;
OPJ_BYTE* cur;
OPJ_SIZE_T len;
libraw_data_t *lrdt;
};
-static GList *libraw_unmap_list = 0;
+static GList *libraw_unmap_list = nullptr;
void libraw_free_preview(guchar *buf)
{
while (work)
{
- UnmapData *ud = static_cast<UnmapData *>(work->data);
+ auto ud = static_cast<UnmapData *>(work->data);
if (ud->ptr == buf)
{
munmap(ud->map_data, ud->map_len);
size_t map_len;
int fd;
- if (!filter_file_class(il->fd->path, FORMAT_CLASS_RAWIMAGE)) return NULL;
+ if (!filter_file_class(il->fd->path, FORMAT_CLASS_RAWIMAGE)) return nullptr;
fd = open(il->fd->path, O_RDONLY);
if (fd == -1)
{
- return NULL;
+ return nullptr;
}
if (fstat(fd, &st) == -1)
{
close(fd);
- return NULL;
+ return nullptr;
}
map_len = st.st_size;
- map_data = static_cast<guchar *>(mmap(0, map_len, PROT_READ, MAP_PRIVATE, fd, 0));
+ map_data = static_cast<guchar *>(mmap(nullptr, map_len, PROT_READ, MAP_PRIVATE, fd, 0));
close(fd);
if (map_data == MAP_FAILED)
{
- return NULL;
+ return nullptr;
}
lrdt = libraw_init(0);
if (!lrdt)
{
log_printf("Warning: Cannot create libraw handle\n");
- return NULL;
+ return nullptr;
}
ret = libraw_open_buffer(lrdt, map_data, map_len);
libraw_close(lrdt);
- return NULL;
+ return nullptr;
}
#else /* !define HAVE_RAW */
static gboolean image_loader_pdf_load(gpointer loader, const guchar *buf, gsize count, GError **UNUSED(error))
{
- ImageLoaderPDF *ld = static_cast<ImageLoaderPDF *>(loader);
- GError *poppler_error = NULL;
+ auto ld = static_cast<ImageLoaderPDF *>(loader);
+ GError *poppler_error = nullptr;
PopplerPage *page;
PopplerDocument *document;
gdouble width, height;
gboolean ret = FALSE;
gint page_total;
- document = poppler_document_new_from_data((gchar *)(buf), count, NULL, &poppler_error);
+ document = poppler_document_new_from_data((gchar *)(buf), count, nullptr, &poppler_error);
if (poppler_error)
{
static gpointer image_loader_pdf_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data)
{
- ImageLoaderPDF *loader = g_new0(ImageLoaderPDF, 1);
+ auto loader = g_new0(ImageLoaderPDF, 1);
loader->area_updated_cb = area_updated_cb;
loader->size_cb = size_cb;
loader->area_prepared_cb = area_prepared_cb;
static void image_loader_pdf_set_size(gpointer loader, int width, int height)
{
- ImageLoaderPDF *ld = static_cast<ImageLoaderPDF *>(loader);
+ auto ld = static_cast<ImageLoaderPDF *>(loader);
ld->requested_width = width;
ld->requested_height = height;
}
static GdkPixbuf* image_loader_pdf_get_pixbuf(gpointer loader)
{
- ImageLoaderPDF *ld = static_cast<ImageLoaderPDF *>(loader);
+ auto ld = static_cast<ImageLoaderPDF *>(loader);
return ld->pixbuf;
}
static gchar** image_loader_pdf_get_format_mime_types(gpointer UNUSED(loader))
{
- static const gchar *mime[] = {"application/pdf", NULL};
+ static const gchar *mime[] = {"application/pdf", nullptr};
return g_strdupv(const_cast<gchar **>(mime));
}
static void image_loader_pdf_set_page_num(gpointer loader, gint page_num)
{
- ImageLoaderPDF *ld = static_cast<ImageLoaderPDF *>(loader);
+ auto ld = static_cast<ImageLoaderPDF *>(loader);
ld->page_num = page_num;
}
static gint image_loader_pdf_get_page_total(gpointer loader)
{
- ImageLoaderPDF *ld = static_cast<ImageLoaderPDF *>(loader);
+ auto ld = static_cast<ImageLoaderPDF *>(loader);
return ld->page_total;
}
static void image_loader_pdf_abort(gpointer loader)
{
- ImageLoaderPDF *ld = static_cast<ImageLoaderPDF *>(loader);
+ auto ld = static_cast<ImageLoaderPDF *>(loader);
ld->abort = TRUE;
}
static void image_loader_pdf_free(gpointer loader)
{
- ImageLoaderPDF *ld = static_cast<ImageLoaderPDF *>(loader);
+ auto ld = static_cast<ImageLoaderPDF *>(loader);
if (ld->pixbuf) g_object_unref(ld->pixbuf);
g_free(ld);
}
funcs->loader_new = image_loader_pdf_new;
funcs->set_size = image_loader_pdf_set_size;
funcs->load = image_loader_pdf_load;
- funcs->write = NULL;
+ funcs->write = nullptr;
funcs->get_pixbuf = image_loader_pdf_get_pixbuf;
funcs->close = image_loader_pdf_close;
funcs->abort = image_loader_pdf_abort;
static tsize_t
tiff_load_read (thandle_t handle, tdata_t buf, tsize_t size)
{
- ImageLoaderTiff *context = static_cast<ImageLoaderTiff *>(handle);
+ auto context = static_cast<ImageLoaderTiff *>(handle);
if (context->pos + size > context->used)
return 0;
static toff_t
tiff_load_seek (thandle_t handle, toff_t offset, int whence)
{
- ImageLoaderTiff *context = static_cast<ImageLoaderTiff *>(handle);
+ auto context = static_cast<ImageLoaderTiff *>(handle);
switch (whence)
{
static toff_t
tiff_load_size (thandle_t handle)
{
- ImageLoaderTiff *context = static_cast<ImageLoaderTiff *>(handle);
+ auto context = static_cast<ImageLoaderTiff *>(handle);
return context->used;
}
static int
tiff_load_map_file (thandle_t handle, tdata_t *buf, toff_t *size)
{
- ImageLoaderTiff *context = static_cast<ImageLoaderTiff *>(handle);
+ auto context = static_cast<ImageLoaderTiff *>(handle);
*buf = const_cast<guchar *>(context->buffer);
*size = context->used;
static gboolean image_loader_tiff_load (gpointer loader, const guchar *buf, gsize count, GError **UNUSED(error))
{
- ImageLoaderTiff *lt = static_cast<ImageLoaderTiff *>(loader);
+ auto lt = static_cast<ImageLoaderTiff *>(loader);
TIFF *tiff;
- guchar *pixels = NULL;
+ guchar *pixels = nullptr;
gint width, height, rowstride;
size_t bytes;
guint32 rowsperstrip;
lt->used = count;
lt->pos = 0;
- TIFFSetWarningHandler(NULL);
+ TIFFSetWarningHandler(nullptr);
tiff = TIFFClientOpen ( "libtiff-geeqie", "r", lt,
tiff_load_read, tiff_load_write,
lt->pixbuf = gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB, TRUE, 8,
width, height, rowstride,
- free_buffer, NULL);
+ free_buffer, nullptr);
if (!lt->pixbuf)
{
g_free (pixels);
/* read by strip */
ptrdiff_t row;
const size_t line_bytes = width * sizeof(guint32);
- guchar *wrk_line = static_cast<guchar *>(g_malloc(line_bytes));
+ auto wrk_line = static_cast<guchar *>(g_malloc(line_bytes));
for (row = 0; row < height; row += rowsperstrip)
{
static gpointer image_loader_tiff_new(ImageLoaderBackendCbAreaUpdated area_updated_cb, ImageLoaderBackendCbSize size_cb, ImageLoaderBackendCbAreaPrepared area_prepared_cb, gpointer data)
{
- ImageLoaderTiff *loader = g_new0(ImageLoaderTiff, 1);
+ auto loader = g_new0(ImageLoaderTiff, 1);
loader->area_updated_cb = area_updated_cb;
loader->size_cb = size_cb;
static void image_loader_tiff_set_size(gpointer loader, int width, int height)
{
- ImageLoaderTiff *lt = static_cast<ImageLoaderTiff *>(loader);
+ auto lt = static_cast<ImageLoaderTiff *>(loader);
lt->requested_width = width;
lt->requested_height = height;
}
static GdkPixbuf* image_loader_tiff_get_pixbuf(gpointer loader)
{
- ImageLoaderTiff *lt = static_cast<ImageLoaderTiff *>(loader);
+ auto lt = static_cast<ImageLoaderTiff *>(loader);
return lt->pixbuf;
}
}
static gchar** image_loader_tiff_get_format_mime_types(gpointer UNUSED(loader))
{
- static const gchar *mime[] = {"image/tiff", NULL};
+ static const gchar *mime[] = {"image/tiff", nullptr};
return g_strdupv(const_cast<gchar **>(mime));
}
static void image_loader_tiff_abort(gpointer loader)
{
- ImageLoaderTiff *lt = static_cast<ImageLoaderTiff *>(loader);
+ auto lt = static_cast<ImageLoaderTiff *>(loader);
lt->abort = TRUE;
}
static void image_loader_tiff_free(gpointer loader)
{
- ImageLoaderTiff *lt = static_cast<ImageLoaderTiff *>(loader);
+ auto lt = static_cast<ImageLoaderTiff *>(loader);
if (lt->pixbuf) g_object_unref(lt->pixbuf);
g_free(lt);
}
static void image_loader_tiff_set_page_num(gpointer loader, gint page_num)
{
- ImageLoaderTiff *lt = static_cast<ImageLoaderTiff *>(loader);
+ auto lt = static_cast<ImageLoaderTiff *>(loader);
lt->page_num = page_num;
}
static gint image_loader_tiff_get_page_total(gpointer loader)
{
- ImageLoaderTiff *lt = static_cast<ImageLoaderTiff *>(loader);
+ auto lt = static_cast<ImageLoaderTiff *>(loader);
return lt->page_total;
}
funcs->loader_new = image_loader_tiff_new;
funcs->set_size = image_loader_tiff_set_size;
funcs->load = image_loader_tiff_load;
- funcs->write = NULL;
+ funcs->write = nullptr;
funcs->get_pixbuf = image_loader_tiff_get_pixbuf;
funcs->close = image_loader_tiff_close;
funcs->abort = image_loader_tiff_abort;
using ImageLoaderBackendFuncSetPageNum = void (*)(gpointer, gint);
using ImageLoaderBackendFuncGetPageTotal = gint (*)(gpointer);
-using ImageLoaderBackend = struct _ImageLoaderBackend;
-struct _ImageLoaderBackend
+struct ImageLoaderBackend
{
ImageLoaderBackendFuncLoaderNew loader_new;
ImageLoaderBackendFuncSetSize set_size;
};
-//typedef struct _ImageLoader ImageLoader;
-using ImageLoaderClass = struct _ImageLoaderClass;
-
-struct _ImageLoader
+struct ImageLoader
{
GObject parent;
guint idle_read_loop_count;
};
-struct _ImageLoaderClass {
+struct ImageLoaderClass {
GObjectClass parent;
/* class members */
#ifdef HAVE_LCMS
static void layout_color_menu_enable_cb(GtkToggleAction *action, gpointer data)
{
- LayoutWindow *lw = static_cast<LayoutWindow *>(data);
+ auto lw = static_cast<LayoutWindow *>(data);
if (layout_image_color_profile_get_use(lw) == gtk_toggle_action_get_active(action)) return;
#ifdef HAVE_LCMS
static void layout_color_menu_use_image_cb(GtkToggleAction *action, gpointer data)
{
- LayoutWindow *lw = static_cast<LayoutWindow *>(data);
+ auto lw = static_cast<LayoutWindow *>(data);
gint input;
gboolean use_image;
#ifdef HAVE_LCMS
static void layout_color_menu_input_cb(GtkRadioAction *action, GtkRadioAction *UNUSED(current), gpointer data)
{
- LayoutWindow *lw = static_cast<LayoutWindow *>(data);
+ auto lw = static_cast<LayoutWindow *>(data);
gint type;
gint input;
gboolean use_image;
FileData **fd;
luaL_checktype(L, index, LUA_TUSERDATA);
fd = static_cast<FileData **>(luaL_checkudata(L, index, "Image"));
- if (fd == NULL) luaL_typerror(L, index, "Image");
+ if (fd == nullptr) luaL_typerror(L, index, "Image");
return *fd;
}
ExifData **exif;
luaL_checktype(L, index, LUA_TUSERDATA);
exif = static_cast<ExifData **>(luaL_checkudata(L, index, "Exif"));
- if (exif == NULL) luaL_typerror(L, index, "Exif");
+ if (exif == nullptr) luaL_typerror(L, index, "Exif");
return *exif;
}
static int lua_exif_get_datum(lua_State *L)
{
const gchar *key;
- gchar *value = NULL;
+ gchar *value = nullptr;
ExifData *exif;
struct tm tm;
time_t datetime;
{"get_size", lua_image_get_size},
{"get_exif", lua_image_get_exif},
{"get_marks", lua_image_get_marks},
- {NULL, NULL}
+ {nullptr, nullptr}
};
/**
*/
static const luaL_Reg exif_methods[] = {
{"get_datum", lua_exif_get_datum},
- {NULL, NULL}
+ {nullptr, nullptr}
};
/**
* @brief Initialize the lua interpreter.
*/
-void lua_init(void)
+void lua_init()
{
L = luaL_newstate();
luaL_openlibs(L); /* Open all libraries for lua programs */
/* Now create custom methodes to do something */
static const luaL_Reg meta_methods[] = {
- {NULL, NULL}
+ {nullptr, nullptr}
};
LUA_register_global(L, "Image", image_methods);
gchar *lua_callvalue(FileData *fd, const gchar *file, const gchar *function)
{
gint result;
- gchar *data = NULL;
+ gchar *data = nullptr;
gchar *path;
FileData **image_data;
gchar *tmp;
- GError *error = NULL;
+ GError *error = nullptr;
gboolean ok;
ok = access(g_build_filename(get_rc_dir(), "lua", file, NULL), R_OK);
return data;
}
data = g_strdup(lua_tostring(L, -1));
- tmp = g_locale_to_utf8(data, strlen(data), NULL, NULL, &error);
+ tmp = g_locale_to_utf8(data, strlen(data), nullptr, nullptr, &error);
if (error)
{
log_printf("Error converting lua output from locale to UTF-8: %s\n", error->message);
tmp_lw = static_cast<LayoutWindow *>(list->data);
if (!g_str_has_prefix(tmp_lw->options.id, "lw"))
{
- save_layout(static_cast<_LayoutWindow *>(list->data));
+ save_layout(static_cast<LayoutWindow *>(list->data));
}
list = list->next;
}
#ifdef HAVE_LUA
else if (strncmp(key, "lua.", 4) == 0)
{
- return g_list_append(NULL, metadata_lua_info(fd, key, format));
+ return g_list_append(nullptr, metadata_lua_info(fd, key, format));
}
#endif
};
/**
- * @typedef _PanViewFilterUi
+ * @struct PanViewFilterUi
* Defined in pan-view-filter.h
*/
-using PanViewFilterUi = struct _PanViewFilterUi;
+struct PanViewFilterUi;
struct PanWindow
{
GList *filter_element;
};
-struct _PanViewFilterUi
+struct PanViewFilterUi
{
GtkWidget *filter_box;
GtkWidget *filter_entry;
#define ROUND_DOWN(A,B) ((gint)(((A))/(B))*(B))
-using RendererFuncs = struct _RendererFuncs;
+struct RendererFuncs;
-using PixbufRenderer = struct _PixbufRenderer;
-using PixbufRendererClass = struct _PixbufRendererClass;
+struct PixbufRenderer;
+struct PixbufRendererClass;
using PixbufRendererTileRequestFunc = gint (*)(PixbufRenderer *, gint, gint, gint, gint, GdkPixbuf *, gpointer);
/* OVL_HIDE_ON_SCROLL = 1 << 1*/ /**< hide temporarily when scrolling (not yet implemented) */
};
-struct _RendererFuncs
+struct RendererFuncs
{
// void (*redraw)(void *renderer, gint x, gint y, gint w, gint h,
// gint clamp, ImageRenderType render, gboolean new_data, gboolean only_existing);
void (*free)(void *renderer);
};
-struct _PixbufRenderer
+struct PixbufRenderer
{
GtkEventBox eventbox;
gboolean ignore_alpha;
};
-struct _PixbufRendererClass
+struct PixbufRendererClass
{
GtkEventBoxClass parent_class;
void pixbuf_renderer_stereo_fixed_set(PixbufRenderer *pr, gint width, gint height, gint x1, gint y1, gint x2, gint y2);
/**
- * @struct _SourceTile
+ * @struct SourceTile
* protected - for renderer use only
*/
-using SourceTile = struct _SourceTile;
-struct _SourceTile
+struct SourceTile
{
gint x;
gint y;
#ifdef HAVE_LCMS
for (i = 0; i < COLOR_PROFILE_INPUTS; i++)
{
- config_entry_to_option(color_profile_input_name_entry[i], &options->color_profile.input_name[i], NULL);
- config_entry_to_option(color_profile_input_file_entry[i], &options->color_profile.input_file[i], NULL);
+ config_entry_to_option(color_profile_input_name_entry[i], &options->color_profile.input_name[i], nullptr);
+ config_entry_to_option(color_profile_input_file_entry[i], &options->color_profile.input_file[i], nullptr);
}
- config_entry_to_option(color_profile_screen_file_entry, &options->color_profile.screen_file, NULL);
+ config_entry_to_option(color_profile_screen_file_entry, &options->color_profile.screen_file, nullptr);
options->color_profile.use_x11_screen_profile = c_options->color_profile.use_x11_screen_profile;
if (options->color_profile.render_intent != c_options->color_profile.render_intent)
{
#ifdef HAVE_LCMS
static void intent_menu_cb(GtkWidget *combo, gpointer data)
{
- gint *option = static_cast<gint *>(data);
+ auto option = static_cast<gint *>(data);
switch (gtk_combo_box_get_active(GTK_COMBO_BOX(combo)))
{
* xml file structure (private)
*-----------------------------------------------------------------------------
*/
-struct _GQParserData
+struct GQParserData
{
GList *parse_func_stack;
gboolean startup; /* reading config for the first time - add commandline and defaults */
*/
-struct _GQParserFuncData
+struct GQParserFuncData
{
GQParserStartFunc start_func;
GQParserEndFunc end_func;
#define READ_DUMMY(_target_, _name_, _msg_) read_dummy_option(option, #_name_, _msg_)
-using GQParserFuncData = struct _GQParserFuncData;
-using GQParserData = struct _GQParserData;
+struct GQParserFuncData;
+struct GQParserData;
using GQParserStartFunc = void (*)(GQParserData *, GMarkupParseContext *, const gchar *, const gchar **, const gchar **, gpointer, GError **);
using GQParserEndFunc = void (*)(GQParserData *, GMarkupParseContext *, const gchar *, gpointer, GError **);
#ifdef HAVE_LUA
static void gr_lua(const gchar *text, GIOChannel *channel, gpointer UNUSED(data))
{
- gchar *result = NULL;
+ gchar *result = nullptr;
gchar **lua_command;
lua_command = g_strsplit(text, ",", 2);
if (lua_command[0] && lua_command[1])
{
FileData *fd = file_data_new_group(lua_command[0]);
- result = g_strdup(lua_callvalue(fd, lua_command[1], NULL));
+ result = g_strdup(lua_callvalue(fd, lua_command[1], nullptr));
if (result)
{
- g_io_channel_write_chars(channel, result, -1, NULL, NULL);
+ g_io_channel_write_chars(channel, result, -1, nullptr, nullptr);
}
else
{
- g_io_channel_write_chars(channel, N_("lua error: no data"), -1, NULL, NULL);
+ g_io_channel_write_chars(channel, N_("lua error: no data"), -1, nullptr, nullptr);
}
}
else
{
- g_io_channel_write_chars(channel, N_("lua error: no data"), -1, NULL, NULL);
+ g_io_channel_write_chars(channel, N_("lua error: no data"), -1, nullptr, nullptr);
}
- g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, NULL, NULL);
+ g_io_channel_write_chars(channel, "<gq_end_of_command>", -1, nullptr, nullptr);
g_strfreev(lua_command);
g_free(result);
{ nullptr, "--list-add:", gr_list_add, TRUE, FALSE, N_("<FILE>"), N_("add FILE to command line collection list") },
{ nullptr, "--list-clear", gr_list_clear, FALSE, FALSE, nullptr, N_("clear command line collection list") },
#ifdef HAVE_LUA
- { NULL, "--lua:", gr_lua, TRUE, FALSE, N_("<FILE>,<lua script>"), N_("run lua script on FILE") },
+ { nullptr, "--lua:", gr_lua, TRUE, FALSE, N_("<FILE>,<lua script>"), N_("run lua script on FILE") },
#endif
{ nullptr, "--new-window", gr_new_window, FALSE, FALSE, nullptr, N_("new window") },
{ "-n", "--next", gr_image_next, FALSE, FALSE, nullptr, N_("next image") },
};
#endif
-using QueueData = struct _QueueData;
+struct QueueData;
struct ImageTile
{
guint size; /* est. memory used by pixmap and pixbuf */
};
-struct _QueueData
+struct QueueData
{
ImageTile *it;
gint x;
#define THUMB_NAME_EXTENSION ".png"
-using ThumbLoaderStd = struct _ThumbLoaderStd;
+struct ThumbLoaderStd;
using ThumbLoaderStdFunc = void (*)(ThumbLoaderStd *, gpointer);
-struct _ThumbLoaderStd
+struct ThumbLoaderStd
{
gboolean standard_loader;
};
/**
- * @typedef DnDAction
+ * @enum DnDAction
* drag and drop default action
*/
enum DnDAction {
extern const gchar *format_class_list[]; /**< defined in preferences.cc */
/**
- * @typedef SecureSaveErrno
+ * @enum SecureSaveErrno
* see err field in #SecureSaveInfo
*/
enum SecureSaveErrno {
SELECTION_FOCUS = 1 << 2
};
-using ImageLoader = struct _ImageLoader;
-using ThumbLoader = struct _ThumbLoader;
+struct ImageLoader;
+struct ThumbLoader;
-using AnimationData = struct _AnimationData;
+struct AnimationData;
-using CollectInfo = struct _CollectInfo;
-using CollectionData = struct _CollectionData;
-using CollectTable = struct _CollectTable;
-using CollectWindow = struct _CollectWindow;
+struct CollectInfo;
+struct CollectionData;
+struct CollectTable;
+struct CollectWindow;
-using ImageWindow = struct _ImageWindow;
+struct ImageWindow;
-using FileData = struct _FileData;
-using FileDataChangeInfo = struct _FileDataChangeInfo;
+struct FileData;
+struct FileDataChangeInfo;
-using LayoutWindow = struct _LayoutWindow;
-using LayoutOptions = struct _LayoutOptions;
+struct LayoutWindow;
+struct LayoutOptions;
-using ViewDir = struct _ViewDir;
-using ViewDirInfoList = struct _ViewDirInfoList;
-using ViewDirInfoTree = struct _ViewDirInfoTree;
+struct ViewDir;
+struct ViewDirInfoList;
+struct ViewDirInfoTree;
-using ViewFile = struct _ViewFile;
-using ViewFileInfoList = struct _ViewFileInfoList;
-using ViewFileInfoIcon = struct _ViewFileInfoIcon;
+struct ViewFile;
+struct ViewFileInfoList;
+struct ViewFileInfoIcon;
-using SlideShowData = struct _SlideShowData;
-using FullScreenData = struct _FullScreenData;
+struct SlideShowData;
+struct FullScreenData;
-using PixmapFolders = struct _PixmapFolders;
-using Histogram = struct _Histogram;
-using HistMap = struct _HistMap;
+struct PixmapFolders;
+struct Histogram;
+struct HistMap;
-using SecureSaveInfo = struct _SecureSaveInfo;
+struct SecureSaveInfo;
struct ExifData;
-using EditorDescription = struct _EditorDescription;
+struct EditorDescription;
-using CommandLine = struct _CommandLine;
+struct CommandLine;
-struct _Histogram {
+struct Histogram {
gint histogram_channel; /**< drawing mode for histogram */
gint histogram_mode; /**< logarithmical or not */
guint vgrid; /**< number of vertical divisions, 0 for none */
-struct _ImageLoader;
+struct ImageLoader;
using ThumbLoaderFunc = void (*)(ThumbLoader *, gpointer);
using FileUtilDoneFunc = void (*)(gboolean, const gchar *, gpointer);
-struct _ThumbLoader
+struct ThumbLoader
{
gboolean standard_loader;
guint idle_done_id; /**< event source id */
};
-struct _AnimationData
+struct AnimationData
{
ImageWindow *iw;
LayoutWindow *lw;
GFileInputStream *gfstream;
};
-struct _CollectInfo
+struct CollectInfo
{
FileData *fd;
GdkPixbuf *pixbuf;
guint flag_mask;
};
-struct _CollectionData
+struct CollectionData
{
gchar *path;
gchar *name;
GHashTable *existence;
};
-struct _CollectTable
+struct CollectTable
{
GtkWidget *scrolled;
GtkWidget *listview;
GList *editmenu_fd_list; /**< file list for edit menu */
};
-struct _CollectWindow
+struct CollectWindow
{
GtkWidget *window;
CollectTable *table;
using ImageTileRequestFunc = gint (*)(ImageWindow *, gint, gint, gint, gint, GdkPixbuf *, gpointer);
using ImageTileDisposeFunc = void (*)(ImageWindow *, gint, gint, gint, gint, GdkPixbuf *, gpointer);
-struct _ImageWindow
+struct ImageWindow
{
GtkWidget *widget; /**< use this to add it and show it */
GtkWidget *pr;
#define FILEDATA_MARKS_SIZE 10
-struct _FileDataChangeInfo {
+struct FileDataChangeInfo {
FileDataChangeType type;
gchar *source;
gchar *dest;
gboolean regroup_when_finished;
};
-struct _FileData {
+struct FileData {
guint magick;
gint type;
gchar *original_path; /**< key to file_data_pool hash table */
gint page_total;
};
-struct _LayoutOptions
+struct LayoutOptions
{
gchar *id;
gchar *filter_key;
};
-struct _LayoutWindow
+struct LayoutWindow
{
LayoutOptions options;
GtkWidget *log_window;
};
-struct _ViewDir
+struct ViewDir
{
DirViewType type;
gpointer info;
PixmapFolders *pf;
};
-struct _ViewDirInfoList
+struct ViewDirInfoList
{
GList *list;
};
-struct _ViewDirInfoTree
+struct ViewDirInfoTree
{
guint drop_expand_id; /**< event source id */
gint busy_ref;
};
-struct _ViewFile
+struct ViewFile
{
FileViewType type; /**< @todo (xsdg): Turn this into a union (see VFLIST and VFICON from view-file.h). */
guint read_metadata_in_idle_id;
};
-struct _ViewFileInfoList
+struct ViewFileInfoList
{
FileData *click_fd;
FileData *select_fd;
guint select_idle_id; /**< event source id */
};
-struct _ViewFileInfoIcon
+struct ViewFileInfoIcon
{
/* table stuff */
gint columns;
gboolean show_text;
};
-struct _SlideShowData
+struct SlideShowData
{
LayoutWindow *lw; /**< use this window to display the slideshow */
ImageWindow *imd; /**< use this window only if lw is not available,
gboolean paused;
};
-struct _FullScreenData
+struct FullScreenData
{
GtkWidget *window;
ImageWindow *imd;
gboolean same_region; /**< the returned region will overlap the current location of widget. */
};
-struct _PixmapFolders
+struct PixmapFolders
{
GdkPixbuf *close;
GdkPixbuf *open;
GdkPixbuf *read_only;
};
-struct _SecureSaveInfo {
+struct SecureSaveInfo {
FILE *fp; /**< file stream pointer */
gchar *file_name; /**< final file name */
gchar *tmp_file_name; /**< temporary file name */
gboolean unlink_on_error; /**< whether to remove temporary file on save failure, TRUE by default */
};
-struct _CommandLine
+struct CommandLine
{
int argc;
gchar **argv;
};
/**
- * @struct _hard_coded_window_keys
+ * @struct hard_coded_window_keys
* @brief hard coded window shortcut keys
*
* Used for two purposes:\n
* used by ./doc/create-shortcuts-xml.sh to generate shortcut documentation in the Help files
*
*/
-using hard_coded_window_keys = struct _hard_coded_window_keys;
-struct _hard_coded_window_keys {
+struct hard_coded_window_keys {
GdkModifierType mask; /**< modifier key mask */
guint key_value; /**< GDK_keyval */
const gchar *text; /**< menu item label - NULL if end of list */
ZD_E_PARSE_HEADER
};
-struct ZoneDetectOpaque {
+struct ZoneDetect {
#if defined(_MSC_VER) || defined(__MINGW32__)
HANDLE fd;
HANDLE fdMap;
char **data;
};
-struct ZoneDetectOpaque;
-using ZoneDetect = struct ZoneDetectOpaque;
+struct ZoneDetect;
#ifdef __cplusplus
extern "C" {
projects / geeqie.git / commitdiff