static gboolean fullscreen_key_accel_callback(GtkAccelGroup *accel_group,
GObject *acceleratable, guint keyval,
GdkModifierType modifier,
gpointer data)
{
GtkWidget *widget;
int fullscreen;
if(data)
{
widget = dt_ui_main_window(darktable.gui->ui);
fullscreen = dt_conf_get_bool("ui_last/fullscreen");
if(fullscreen) gtk_window_unfullscreen(GTK_WINDOW(widget));
else gtk_window_fullscreen (GTK_WINDOW(widget));
fullscreen ^= 1;
dt_conf_set_bool("ui_last/fullscreen", fullscreen);
dt_dev_invalidate(darktable.develop);
}
else
{
widget = dt_ui_main_window(darktable.gui->ui);
gtk_window_unfullscreen(GTK_WINDOW(widget));
fullscreen = 0;
dt_conf_set_bool("ui_last/fullscreen", fullscreen);
dt_dev_invalidate(darktable.develop);
}
/* redraw center view */
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return TRUE;
}
void dt_configure_defaults()
{
const int atom_cores = dt_get_num_atom_cores();
const int threads = dt_get_num_threads();
const size_t mem = dt_get_total_memory();
const int bits = (sizeof(void*) == 4) ? 32 : 64;
fprintf(stderr, "[defaults] found a %d-bit system with %zu kb ram and %d cores (%d atom based)\n", bits, mem, threads, atom_cores);
if(mem > (2u<<20) && threads > 4)
{
fprintf(stderr, "[defaults] setting high quality defaults\n");
dt_conf_set_int("worker_threads", 8);
dt_conf_set_int64("cache_memory", 1u<<30);
dt_conf_set_int("plugins/lighttable/thumbnail_width", 1300);
dt_conf_set_int("plugins/lighttable/thumbnail_height", 1000);
dt_conf_set_bool("plugins/lighttable/low_quality_thumbnails", FALSE);
}
if(mem < (1u<<20) || threads <= 2 || bits < 64 || atom_cores > 0)
{
fprintf(stderr, "[defaults] setting very conservative defaults\n");
dt_conf_set_int("worker_threads", 1);
dt_conf_set_int64("cache_memory", 200u<<20);
dt_conf_set_int("host_memory_limit", 500);
dt_conf_set_int("singlebuffer_limit", 8);
dt_conf_set_int("plugins/lighttable/thumbnail_width", 800);
dt_conf_set_int("plugins/lighttable/thumbnail_height", 500);
dt_conf_set_string("plugins/darkroom/demosaic/quality", "always bilinear (fast)");
dt_conf_set_bool("plugins/lighttable/low_quality_thumbnails", TRUE);
}
}
static void
_check_button_callback(GtkWidget *cb, gpointer user_data)
{
_camera_import_dialog_t *cid=(_camera_import_dialog_t*)user_data;
if( cb == cid->settings.general.ignore_jpeg )
{
dt_conf_set_bool ("ui_last/import_ignore_jpegs", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cid->settings.general.ignore_jpeg)));
}
else if (cb==cid->settings.general.date_override )
{
// Enable/disable the date entry widget
gtk_widget_set_sensitive( cid->settings.general.date_entry, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cid->settings.general.date_override)));
}
else if (cb==cid->settings.backup.enable)
{
dt_conf_set_bool ("plugins/capture/backup/enable", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cid->settings.backup.enable)));
// Enable/disable the date entry widget
gtk_widget_set_sensitive( cid->settings.backup.warn, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cid->settings.backup.enable)));
gtk_widget_set_sensitive( cid->settings.backup.foldername, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cid->settings.backup.enable)));
}
else if (cb==cid->settings.backup.warn)
{
dt_conf_set_bool ("plugins/capture/backup/warning", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cid->settings.backup.enable)));
}
}
static gboolean _lib_histogram_button_press_callback(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_histogram_t *d = (dt_lib_histogram_t *)self->data;
/* check if exposure hooks are available */
gboolean hooks_available = dt_dev_exposure_hooks_available(darktable.develop);
if(!hooks_available)
return TRUE;
if(event->type == GDK_2BUTTON_PRESS)
{
dt_dev_exposure_reset_defaults(darktable.develop);
}
else
{
if(d->highlight == 3) // mode button
{
darktable.develop->histogram_type = (darktable.develop->histogram_type + 1) % DT_DEV_HISTOGRAM_N;
dt_conf_set_string("plugins/darkroom/histogram/mode", dt_dev_histogram_type_names[darktable.develop->histogram_type]);
}
else if(d->highlight == 4) // red button
{
d->red = !d->red;
dt_conf_set_bool("plugins/darkroom/histogram/show_red", d->red);
}
else if(d->highlight == 5) // green button
{
d->green = !d->green;
dt_conf_set_bool("plugins/darkroom/histogram/show_green", d->green);
}
else if(d->highlight == 6) // blue button
{
d->blue = !d->blue;
dt_conf_set_bool("plugins/darkroom/histogram/show_blue", d->blue);
}
else
{
d->dragging = 1;
if(d->highlight == 2)
d->white = dt_dev_exposure_get_white(darktable.develop);
if(d->highlight == 1)
d->black = dt_dev_exposure_get_black(darktable.develop);
d->button_down_x = event->x;
d->button_down_y = event->y;
}
}
// update for good measure
dt_control_queue_redraw_widget(self->widget);
return TRUE;
}
static void _lib_import_evaluate_extra_widget(dt_lib_import_metadata_t *data, gboolean import_folder)
{
if(import_folder == TRUE)
{
dt_conf_set_bool("ui_last/import_recursive", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (data->recursive)));
dt_conf_set_bool("ui_last/import_ignore_jpegs", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (data->ignore_jpeg)));
}
dt_conf_set_bool("ui_last/import_options_expanded", gtk_expander_get_expanded(GTK_EXPANDER (data->expander)));
dt_conf_set_bool("ui_last/import_apply_metadata", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (data->apply_metadata)));
dt_conf_set_string("ui_last/import_last_creator", gtk_entry_get_text(GTK_ENTRY(data->creator)));
dt_conf_set_string("ui_last/import_last_publisher", gtk_entry_get_text(GTK_ENTRY(data->publisher)));
dt_conf_set_string("ui_last/import_last_rights", gtk_entry_get_text(GTK_ENTRY(data->rights)));
dt_conf_set_string("ui_last/import_last_tags", gtk_entry_get_text(GTK_ENTRY(data->tags)));
}
static int write_pref(lua_State*L)
{
const char *script = luaL_checkstring(L,1);
const char *name = luaL_checkstring(L,2);
const char* type_name = luaL_checkstring(L,3);
int i;
for (i=0; pref_type_name[i]; i++)
if (strcmp(pref_type_name[i], type_name) == 0)
{
break;
}
if(!pref_type_name[i]) luaL_argerror(L,3,NULL);
char pref_name[1024];
get_pref_name(pref_name,1024,script,name);
switch(i)
{
case pref_string:
dt_conf_set_string(pref_name,luaL_checkstring(L,4));
break;
case pref_bool:
luaL_checktype(L,4,LUA_TBOOLEAN);
dt_conf_set_bool(pref_name,lua_toboolean(L,4));
break;
case pref_int:
dt_conf_set_int(pref_name,luaL_checkinteger(L,4));
break;
}
return 0;
}
static gboolean
duplicate_callback (GtkEntry *entry, gpointer user_data)
{
dt_lib_styles_t *d = (dt_lib_styles_t *)user_data;
dt_conf_set_bool ("ui_last/styles_create_duplicate", gtk_toggle_button_get_active ( GTK_TOGGLE_BUTTON (d->duplicate)));
return FALSE;
}
static void response_callback_bool(GtkDialog *dialog, gint response_id, pref_element* cur_elt)
{
if(response_id == GTK_RESPONSE_ACCEPT)
{
char pref_name[1024];
get_pref_name(pref_name,1024,cur_elt->script,cur_elt->name);
dt_conf_set_bool(pref_name, gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(cur_elt->widget)));
}
}
static void _lib_overlays_button_clicked (GtkWidget *widget, gpointer user_data)
{
darktable.gui->show_overlays = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
if(darktable.gui->show_overlays)
g_object_set(G_OBJECT(widget), "tooltip-text", _("hide image overlays"), (char *)NULL);
else
g_object_set(G_OBJECT(widget), "tooltip-text", _("show image overlays"), (char *)NULL);
dt_conf_set_bool("lighttable/ui/expose_statuses", darktable.gui->show_overlays);
dt_control_signal_raise(darktable.signals, DT_SIGNAL_COLLECTION_CHANGED);
}
int dt_control_write_config(dt_control_t *c)
{
// TODO: move to gtk.c
GtkWidget *widget = dt_ui_main_window(darktable.gui->ui);
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
gint x, y;
gtk_window_get_position(GTK_WINDOW(widget), &x, &y);
dt_conf_set_int("ui_last/window_x", x);
dt_conf_set_int("ui_last/window_y", y);
dt_conf_set_int("ui_last/window_w", allocation.width);
dt_conf_set_int("ui_last/window_h", allocation.height);
dt_conf_set_bool("ui_last/maximized",
(gdk_window_get_state(gtk_widget_get_window(widget)) & GDK_WINDOW_STATE_MAXIMIZED));
dt_conf_set_bool("ui_last/fullscreen",
(gdk_window_get_state(gtk_widget_get_window(widget)) & GDK_WINDOW_STATE_FULLSCREEN));
return 0;
}
void dt_lib_gui_set_expanded(dt_lib_module_t *module, gboolean expanded)
{
if(!module->expander) return;
/* update expander arrow state */
GtkWidget *icon;
GtkWidget *header = gtk_bin_get_child(GTK_BIN(g_list_nth_data(gtk_container_get_children(GTK_CONTAINER(module->expander)),0)));
gint flags = CPF_DIRECTION_DOWN;
int c = module->container();
if ( (c == DT_UI_CONTAINER_PANEL_LEFT_TOP) ||
(c == DT_UI_CONTAINER_PANEL_LEFT_CENTER) ||
(c == DT_UI_CONTAINER_PANEL_LEFT_BOTTOM) )
{
icon = g_list_nth_data(gtk_container_get_children(GTK_CONTAINER(header)),0);
if(!expanded)
flags=CPF_DIRECTION_RIGHT;
}
else
{
icon = g_list_last(gtk_container_get_children(GTK_CONTAINER(header)))->data;
if(!expanded)
flags=CPF_DIRECTION_LEFT;
}
dtgtk_icon_set_paint(icon, dtgtk_cairo_paint_solid_arrow, flags);
/* show / hide plugin widget */
if(expanded)
{
gtk_widget_show_all(module->widget);
/* register to receive draw events */
darktable.lib->gui_module = module;
/* focus the current module */
for(int k=0; k<DT_UI_CONTAINER_SIZE; k++)
dt_ui_container_focus_widget(darktable.gui->ui, k, GTK_WIDGET(module->expander));
}
else
{
gtk_widget_hide_all(module->widget);
if(darktable.lib->gui_module == module)
{
darktable.lib->gui_module = NULL;
dt_control_queue_redraw();
}
}
/* store expanded state of module */
char var[1024];
snprintf(var, 1024, "plugins/lighttable/%s/expanded", module->plugin_name);
dt_conf_set_bool(var, gtk_widget_get_visible(module->widget));
}
void dt_lib_gui_set_expanded(dt_lib_module_t *module, gboolean expanded)
{
if(!module->expander) return;
dtgtk_expander_set_expanded(DTGTK_EXPANDER(module->expander), expanded);
/* update expander arrow state */
GtkWidget *icon;
GtkWidget *header = dtgtk_expander_get_header(DTGTK_EXPANDER(module->expander));
gint flags = CPF_DIRECTION_DOWN;
int c = module->container(module);
GList *header_childs = gtk_container_get_children(GTK_CONTAINER(header));
if((c == DT_UI_CONTAINER_PANEL_LEFT_TOP) || (c == DT_UI_CONTAINER_PANEL_LEFT_CENTER)
|| (c == DT_UI_CONTAINER_PANEL_LEFT_BOTTOM))
{
icon = g_list_nth_data(header_childs, 0);
if(!expanded) flags = CPF_DIRECTION_RIGHT;
}
else
{
icon = g_list_last(header_childs)->data;
if(!expanded) flags = CPF_DIRECTION_LEFT;
}
g_list_free(header_childs);
dtgtk_icon_set_paint(icon, dtgtk_cairo_paint_solid_arrow, flags);
/* show / hide plugin widget */
if(expanded)
{
/* register to receive draw events */
darktable.lib->gui_module = module;
/* focus the current module */
for(int k = 0; k < DT_UI_CONTAINER_SIZE; k++)
dt_ui_container_focus_widget(darktable.gui->ui, k, GTK_WIDGET(module->expander));
}
else
{
if(darktable.lib->gui_module == module)
{
darktable.lib->gui_module = NULL;
dt_control_queue_redraw();
}
}
/* store expanded state of module */
char var[1024];
const dt_view_t *current_view = dt_view_manager_get_current_view(darktable.view_manager);
snprintf(var, sizeof(var), "plugins/%s/%s/expanded", current_view->module_name, module->plugin_name);
dt_conf_set_bool(var, expanded);
}
static void _lib_filter_grouping_button_clicked (GtkWidget *widget, gpointer user_data)
{
darktable.gui->grouping = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
if(darktable.gui->grouping)
g_object_set(G_OBJECT(widget), "tooltip-text", _("expand grouped images"), (char *)NULL);
else
g_object_set(G_OBJECT(widget), "tooltip-text", _("collapse grouped images"), (char *)NULL);
dt_conf_set_bool("ui_last/grouping", darktable.gui->grouping);
darktable.gui->expanded_group_id = -1;
dt_collection_update_query(darktable.collection);
}
void dt_lib_set_visible(dt_lib_module_t *module, gboolean visible)
{
char key[512];
g_snprintf(key,512,"plugins/lighttable/%s/visible", module->plugin_name);
dt_conf_set_bool(key, visible);
if (module->expander)
gtk_widget_set_visible(GTK_WIDGET(module->expander), visible);
else if (module->widget)
{
if (visible)
gtk_widget_show_all(GTK_WIDGET(module->widget));
else
gtk_widget_hide(GTK_WIDGET(module->widget));
}
}
void _view_map_show_osd(const dt_view_t *view, gboolean enabled)
{
dt_map_t *lib = (dt_map_t*)view->data;
gboolean old_value = dt_conf_get_bool("plugins/map/show_map_osd");
if(enabled == old_value)
return;
dt_conf_set_bool("plugins/map/show_map_osd", enabled);
if(enabled)
osm_gps_map_layer_add(OSM_GPS_MAP(lib->map), lib->osd);
else
osm_gps_map_layer_remove(OSM_GPS_MAP(lib->map), lib->osd);
g_signal_emit_by_name(lib->map, "changed");
}
void dt_configure_defaults()
{
const int atom_cores = dt_get_num_atom_cores();
const int threads = dt_get_num_threads();
const size_t mem = dt_get_total_memory();
const int bits = (sizeof(void *) == 4) ? 32 : 64;
fprintf(stderr, "[defaults] found a %d-bit system with %zu kb ram and %d cores (%d atom based)\n", bits,
mem, threads, atom_cores);
if(mem >= (8u << 20) && threads > 4)
{
fprintf(stderr, "[defaults] setting very high quality defaults\n");
dt_conf_set_int("worker_threads", 8);
// if no less than 8Gb, half the total size
dt_conf_set_int("host_memory_limit", mem >> 11);
dt_conf_set_bool("plugins/lighttable/low_quality_thumbnails", FALSE);
}
static void _lib_overlays_button_clicked(GtkWidget *widget, gpointer user_data)
{
darktable.gui->show_overlays = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
if(darktable.gui->show_overlays)
gtk_widget_set_tooltip_text(widget, _("hide image overlays"));
else
gtk_widget_set_tooltip_text(widget, _("show image overlays"));
dt_conf_set_bool("lighttable/ui/expose_statuses", darktable.gui->show_overlays);
dt_control_signal_raise(darktable.signals, DT_SIGNAL_COLLECTION_CHANGED);
#ifdef USE_LUA
dt_lua_do_chunk_async(dt_lua_event_trigger_wrapper,
LUA_ASYNC_TYPENAME,"const char*","global_toolbox-overlay_toggle",
LUA_ASYNC_TYPENAME,"bool",darktable.gui->show_overlays,
LUA_ASYNC_DONE);
#endif // USE_LUA
}
static gboolean _lib_modulelist_tristate_set_state(GtkWidget *w,gint state,dt_iop_module_t *module)
{
char option[1024];
gboolean expand = FALSE;
if(state==0)
{
/* module is hidden lets set conf values */
gtk_widget_hide(GTK_WIDGET(module->expander));
snprintf(option, 512, "plugins/darkroom/%s/visible", module->op);
dt_conf_set_bool (option, FALSE);
snprintf(option, 512, "plugins/darkroom/%s/favorite", module->op);
dt_conf_set_bool (option, FALSE);
/* construct tooltip text into option */
snprintf(option, 512, _("show %s"), module->name());
}
else if(state==1)
{
/* module is shown lets set conf values */
// FIXME
// dt_gui_iop_modulegroups_switch(module->groups());
gtk_widget_show(GTK_WIDGET(module->expander));
snprintf(option, 512, "plugins/darkroom/%s/visible", module->op);
dt_conf_set_bool (option, TRUE);
snprintf(option, 512, "plugins/darkroom/%s/favorite", module->op);
dt_conf_set_bool (option, FALSE);
expand = TRUE;
/* construct tooltip text into option */
snprintf(option, 512, _("%s as favorite"), module->name());
}
else if(state==2)
{
/* module is shown and favorite lets set conf values */
// FIXME
// dt_gui_iop_modulegroups_switch(module->groups());
gtk_widget_show(GTK_WIDGET(module->expander));
snprintf(option, 512, "plugins/darkroom/%s/visible", module->op);
dt_conf_set_bool (option, TRUE);
snprintf(option, 512, "plugins/darkroom/%s/favorite", module->op);
dt_conf_set_bool (option, TRUE);
expand = TRUE;
/* construct tooltip text into option */
snprintf(option, 512, _("hide %s"), module->name());
}
g_object_set(G_OBJECT(w), "tooltip-text", option, (char *)NULL);
return expand;
}
static void _lib_filter_grouping_button_clicked(GtkWidget *widget, gpointer user_data)
{
darktable.gui->grouping = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget));
if(darktable.gui->grouping)
gtk_widget_set_tooltip_text(widget, _("expand grouped images"));
else
gtk_widget_set_tooltip_text(widget, _("collapse grouped images"));
dt_conf_set_bool("ui_last/grouping", darktable.gui->grouping);
darktable.gui->expanded_group_id = -1;
dt_collection_update_query(darktable.collection);
#ifdef USE_LUA
dt_lua_do_chunk_async(dt_lua_event_trigger_wrapper,
LUA_ASYNC_TYPENAME,"const char*","global_toolbox-grouping_toggle",
LUA_ASYNC_TYPENAME,"bool",darktable.gui->grouping,
LUA_ASYNC_DONE);
#endif // USE_LUA
}
static int _dt_collection_store(const dt_collection_t *collection, gchar *query)
{
/* store flags to conf */
if(collection == darktable.collection)
{
dt_conf_set_int("plugins/collection/query_flags", collection->params.query_flags);
dt_conf_set_int("plugins/collection/filter_flags", collection->params.filter_flags);
dt_conf_set_int("plugins/collection/film_id", collection->params.film_id);
dt_conf_set_int("plugins/collection/rating", collection->params.rating);
dt_conf_set_int("plugins/collection/rating_comparator", collection->params.comparator);
dt_conf_set_int("plugins/collection/sort", collection->params.sort);
dt_conf_set_bool("plugins/collection/descending", collection->params.descending);
}
/* store query in context */
g_free(collection->query);
((dt_collection_t *)collection)->query = g_strdup(query);
return 1;
}
int dt_control_key_pressed_override(guint key, guint state)
{
dt_control_accels_t *accels = &darktable.control->accels;
// TODO: if darkroom mode
// did a : vim-style command start?
static GList *autocomplete = NULL;
static char vimkey_input[256];
if(darktable.control->vimkey_cnt)
{
guchar unichar = gdk_keyval_to_unicode(key);
if(key == GDK_KEY_Return)
{
if(!strcmp(darktable.control->vimkey, ":q"))
{
dt_control_quit();
}
else
{
dt_bauhaus_vimkey_exec(darktable.control->vimkey);
}
darktable.control->vimkey[0] = 0;
darktable.control->vimkey_cnt = 0;
dt_control_log_ack_all();
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_Escape)
{
darktable.control->vimkey[0] = 0;
darktable.control->vimkey_cnt = 0;
dt_control_log_ack_all();
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_BackSpace)
{
darktable.control->vimkey_cnt
-= (darktable.control->vimkey + darktable.control->vimkey_cnt)
- g_utf8_prev_char(darktable.control->vimkey + darktable.control->vimkey_cnt);
darktable.control->vimkey[darktable.control->vimkey_cnt] = 0;
if(darktable.control->vimkey_cnt == 0)
dt_control_log_ack_all();
else
dt_control_log("%s", darktable.control->vimkey);
g_list_free(autocomplete);
autocomplete = NULL;
}
else if(key == GDK_KEY_Tab)
{
// TODO: also support :preset and :get?
// auto complete:
if(darktable.control->vimkey_cnt < 5)
{
snprintf(darktable.control->vimkey, sizeof(darktable.control->vimkey), ":set ");
darktable.control->vimkey_cnt = 5;
}
else if(!autocomplete)
{
// TODO: handle '.'-separated things separately
// this is a static list, and tab cycles through the list
g_strlcpy(vimkey_input, darktable.control->vimkey + 5, sizeof(vimkey_input));
autocomplete = dt_bauhaus_vimkey_complete(darktable.control->vimkey + 5);
autocomplete = g_list_append(autocomplete, vimkey_input); // remember input to cycle back
}
if(autocomplete)
{
// pop first.
// the paths themselves are owned by bauhaus,
// no free required.
snprintf(darktable.control->vimkey, sizeof(darktable.control->vimkey), ":set %s",
(char *)autocomplete->data);
autocomplete = g_list_remove(autocomplete, autocomplete->data);
darktable.control->vimkey_cnt = strlen(darktable.control->vimkey);
}
dt_control_log("%s", darktable.control->vimkey);
}
else if(g_unichar_isprint(unichar)) // printable unicode character
{
gchar utf8[6];
gint char_width = g_unichar_to_utf8(unichar, utf8);
if(darktable.control->vimkey_cnt + 1 + char_width < 256)
{
g_utf8_strncpy(darktable.control->vimkey + darktable.control->vimkey_cnt, utf8, 1);
darktable.control->vimkey_cnt += char_width;
darktable.control->vimkey[darktable.control->vimkey_cnt] = 0;
dt_control_log("%s", darktable.control->vimkey);
g_list_free(autocomplete);
autocomplete = NULL;
}
}
else if(key == GDK_KEY_Up)
{
// TODO: step history up and copy to vimkey
}
else if(key == GDK_KEY_Down)
{
// TODO: step history down and copy to vimkey
}
return 1;
}
else if(key == ':' && darktable.control->key_accelerators_on)
{
darktable.control->vimkey[0] = ':';
darktable.control->vimkey[1] = 0;
darktable.control->vimkey_cnt = 1;
dt_control_log("%s", darktable.control->vimkey);
return 1;
}
/* check if key accelerators are enabled*/
if(darktable.control->key_accelerators_on != 1) return 0;
if(key == accels->global_sideborders.accel_key && state == accels->global_sideborders.accel_mods)
{
/* toggle panel viewstate */
dt_ui_toggle_panels_visibility(darktable.gui->ui);
/* trigger invalidation of centerview to reprocess pipe */
dt_dev_invalidate(darktable.develop);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return 1;
}
else if(key == accels->global_header.accel_key && state == accels->global_header.accel_mods)
{
char key[512];
const dt_view_t *cv = dt_view_manager_get_current_view(darktable.view_manager);
/* do nothing if in collapse panel state
TODO: reconsider adding this check to ui api */
g_snprintf(key, sizeof(key), "%s/ui/panel_collaps_state", cv->module_name);
if(dt_conf_get_int(key)) return 0;
/* toggle the header visibility state */
g_snprintf(key, sizeof(key), "%s/ui/show_header", cv->module_name);
gboolean header = !dt_conf_get_bool(key);
dt_conf_set_bool(key, header);
/* show/hide the actual header panel */
dt_ui_panel_show(darktable.gui->ui, DT_UI_PANEL_TOP, header, TRUE);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
return 1;
}
return 0;
}
/** disable opencl */
void dt_opencl_disable(void)
{
if(!darktable.opencl->inited) return;
darktable.opencl->enabled = FALSE;
dt_conf_set_bool("opencl", FALSE);
}
static int register_pref(lua_State*L)
{
// to avoid leaks, we need to first get all params (which could raise errors) then alloc and fill the struct
// this is complicated, but needed
pref_element * built_elt = malloc(sizeof(pref_element));
memset(built_elt,0,sizeof(pref_element));
int cur_param =1;
if(!lua_isstring(L,cur_param)) goto error;
built_elt->script = strdup(lua_tostring(L,cur_param));
cur_param++;
if(!lua_isstring(L,cur_param)) goto error;
built_elt->name = strdup(lua_tostring(L,cur_param));
cur_param++;
int i;
const char* type_name = lua_tostring(L,cur_param);
if(!type_name) goto error;
for (i=0; pref_type_name[i]; i++)
if (strcmp(pref_type_name[i], type_name) == 0)
{
built_elt->type =i;
break;
}
if(!pref_type_name[i]) goto error;
cur_param++;
if(!lua_isstring(L,cur_param)) goto error;
built_elt->label = strdup(lua_tostring(L,cur_param));
cur_param++;
if(!lua_isstring(L,cur_param)) goto error;
built_elt->tooltip = strdup(lua_tostring(L,cur_param));
cur_param++;
char pref_name[1024];
get_pref_name(pref_name,1024,built_elt->script,built_elt->name);
switch(built_elt->type)
{
case pref_string:
if(!lua_isstring(L,cur_param)) goto error;
built_elt->string_data.default_value = strdup(lua_tostring(L,cur_param));
cur_param++;
if(!dt_conf_key_exists(pref_name)) dt_conf_set_string(pref_name,built_elt->string_data.default_value);
break;
case pref_bool:
if(!lua_isboolean(L,cur_param)) goto error;
built_elt->bool_data.default_value = lua_toboolean(L,cur_param);
cur_param++;
if(!dt_conf_key_exists(pref_name)) dt_conf_set_bool(pref_name,built_elt->bool_data.default_value);
break;
case pref_int:
if(!lua_isnumber(L,cur_param)) goto error;
built_elt->int_data.default_value = lua_tointeger(L,cur_param);
cur_param++;
if(!lua_isnumber(L,cur_param)) goto error;
built_elt->int_data.min = lua_tointeger(L,cur_param);
cur_param++;
if(!lua_isnumber(L,cur_param)) goto error;
built_elt->int_data.max = lua_tointeger(L,cur_param);
cur_param++;
if(!dt_conf_key_exists(pref_name)) dt_conf_set_int(pref_name,built_elt->int_data.default_value);
break;
}
built_elt->next = pref_list;
pref_list = built_elt;
return 0;
error:
destroy_pref_element(built_elt);
return luaL_argerror(L,cur_param,NULL);
}
void init_widgets()
{
GtkWidget* container;
GtkWidget* widget;
// Creating the main window
widget = gtk_window_new(GTK_WINDOW_TOPLEVEL);
darktable.gui->ui->main_window = widget;
gtk_window_set_default_size(GTK_WINDOW(widget), 900, 500);
gtk_window_set_icon_name(GTK_WINDOW(widget), "darktable");
gtk_window_set_title(GTK_WINDOW(widget), "Darktable");
g_signal_connect (G_OBJECT (widget), "delete_event",
G_CALLBACK (dt_control_quit), NULL);
g_signal_connect (G_OBJECT (widget), "key-press-event",
G_CALLBACK (key_pressed_override), NULL);
g_signal_connect (G_OBJECT (widget), "key-release-event",
G_CALLBACK (key_released), NULL);
container = widget;
// Adding the outermost vbox
widget = gtk_vbox_new(FALSE, 0);
gtk_container_add(GTK_CONTAINER(container), widget);
gtk_widget_show(widget);
/* connect to signal redraw all */
dt_control_signal_connect(darktable.signals,
DT_SIGNAL_CONTROL_REDRAW_ALL,
G_CALLBACK(_ui_widget_redraw_callback),
darktable.gui->ui->main_window);
container = widget;
// Initializing the top border
widget = gtk_drawing_area_new();
darktable.gui->widgets.top_border = widget;
gtk_box_pack_start(GTK_BOX(container), widget, FALSE, TRUE, 0);
gtk_widget_set_size_request(widget, -1, 10);
gtk_widget_set_app_paintable(widget, TRUE);
gtk_widget_set_events(widget,
GDK_EXPOSURE_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_ENTER_NOTIFY_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_STRUCTURE_MASK
| GDK_SCROLL_MASK);
gtk_widget_show(widget);
// Initializing the main table
init_main_table(container);
// Initializing the bottom border
widget = gtk_drawing_area_new();
darktable.gui->widgets.bottom_border = widget;
gtk_box_pack_start(GTK_BOX(container), widget, FALSE, TRUE, 0);
gtk_widget_set_size_request(widget, -1, 10);
gtk_widget_set_app_paintable(widget, TRUE);
gtk_widget_set_events(widget,
GDK_EXPOSURE_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_ENTER_NOTIFY_MASK
| GDK_LEAVE_NOTIFY_MASK
| GDK_STRUCTURE_MASK
| GDK_SCROLL_MASK);
gtk_widget_show(widget);
// Showing everything
gtk_widget_show_all(dt_ui_main_window(darktable.gui->ui));
/* hide panels depending on last ui state */
for(int k=0;k<DT_UI_PANEL_SIZE;k++)
{
/* prevent show all */
gtk_widget_set_no_show_all(GTK_WIDGET(darktable.gui->ui->containers[k]), TRUE);
/* check last visible state of panel */
char key[512];
g_snprintf(key, 512, "ui_last/%s/visible", _ui_panel_config_names[k]);
/* if no key, lets default to TRUE*/
if(!dt_conf_key_exists(key))
dt_conf_set_bool(key,TRUE);
if (!dt_conf_get_bool(key))
gtk_widget_set_visible(darktable.gui->ui->panels[k],FALSE);
}
}
static void callback_bool(GtkWidget *widget, pref_element*cur_elt )
{
char pref_name[1024];
get_pref_name(pref_name,1024,cur_elt->script,cur_elt->name);
dt_conf_set_bool(pref_name,gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(widget)));
}
static void _lib_import_folder_callback(GtkWidget *widget,gpointer user_data)
{
GtkWidget *win = dt_ui_main_window(darktable.gui->ui);
GtkWidget *filechooser = gtk_file_chooser_dialog_new (_("import film"),
GTK_WINDOW (win),
GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,
(char *)NULL);
gtk_file_chooser_set_select_multiple(GTK_FILE_CHOOSER(filechooser), TRUE);
char *last_directory = dt_conf_get_string("ui_last/import_last_directory");
if(last_directory != NULL)
gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER (filechooser), last_directory);
// add extra lines to 'extra'. don't forget to destroy the widgets later.
GtkWidget *extra;
extra = gtk_vbox_new(FALSE, 0);
// recursive opening.
GtkWidget *recursive;
recursive = gtk_check_button_new_with_label (_("import directories recursively"));
g_object_set(recursive, "tooltip-text", _("recursively import subdirectories. each directory goes into a new film roll."), NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (recursive), dt_conf_get_bool("ui_last/import_recursive"));
gtk_widget_show (recursive);
gtk_box_pack_start(GTK_BOX (extra), recursive, FALSE, FALSE, 0);
// ignoring of jpegs. hack while we don't handle raw+jpeg in the same directories.
GtkWidget *ignore_jpeg;
ignore_jpeg = gtk_check_button_new_with_label (_("ignore jpeg files"));
g_object_set(ignore_jpeg, "tooltip-text", _("do not load files with an extension of .jpg or .jpeg. this can be useful when there are raw+jpeg in a directory."), NULL);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (ignore_jpeg), dt_conf_get_bool("ui_last/import_ignore_jpegs"));
gtk_widget_show (ignore_jpeg);
gtk_box_pack_start(GTK_BOX (extra), ignore_jpeg, FALSE, FALSE, 0);
gtk_file_chooser_set_extra_widget (GTK_FILE_CHOOSER (filechooser), extra);
if (gtk_dialog_run (GTK_DIALOG (filechooser)) == GTK_RESPONSE_ACCEPT)
{
dt_conf_set_bool("ui_last/import_recursive", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (recursive)));
dt_conf_set_bool("ui_last/import_ignore_jpegs", gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON (ignore_jpeg)));
dt_conf_set_string("ui_last/import_last_directory", gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER (filechooser)));
char *filename = NULL, *first_filename = NULL;
GSList *list = gtk_file_chooser_get_filenames (GTK_FILE_CHOOSER (filechooser));
GSList *it = list;
/* for each selected folder add import job */
while(it)
{
filename = (char *)it->data;
dt_film_import(filename);
if (!first_filename)
first_filename = dt_util_dstrcat(g_strdup(filename), "%%");
g_free (filename);
it = g_slist_next(it);
}
/* update collection to view import */
if (first_filename)
{
dt_conf_set_int("plugins/lighttable/collect/num_rules", 1);
dt_conf_set_int("plugins/lighttable/collect/item0", 0);
dt_conf_set_string("plugins/lighttable/collect/string0",first_filename);
dt_collection_update_query(darktable.collection);
g_free(first_filename);
}
g_slist_free (list);
}
gtk_widget_destroy(recursive);
gtk_widget_destroy(ignore_jpeg);
gtk_widget_destroy(extra);
gtk_widget_destroy (filechooser);
gtk_widget_queue_draw(dt_ui_center(darktable.gui->ui));
}
static void overwrite_toggle_callback(GtkWidget *widget, gpointer user_data)
{
dt_conf_set_bool("plugins/imageio/storage/disk/overwrite", dt_bauhaus_combobox_get(widget) == 1);
}
