Exemplo n.º 1
0
static int lua_job_valid(lua_State*L)
{
    dt_progress_t *progress;
    luaA_to(L, dt_lua_backgroundjob_t, &progress, 1);
    if(lua_isnone(L, 3))
    {
        dt_lua_unlock(false);
        gboolean i_own_lock = dt_control_gdk_lock();
        dt_pthread_mutex_lock(&darktable.control->progress_system.mutex);
        GList *iter = g_list_find(darktable.control->progress_system.list, progress);
        dt_pthread_mutex_unlock(&darktable.control->progress_system.mutex);
        if(i_own_lock) dt_control_gdk_unlock();
        dt_lua_lock();

        if(iter)
            lua_pushboolean(L, true);
        else
            lua_pushboolean(L, false);

        return 1;
    }
    else
    {
        int validity = lua_toboolean(L, 3);
        if(validity)
            return luaL_argerror(L, 3, "a job can not be made valid");
        dt_lua_unlock(false);
        dt_control_progress_destroy(darktable.control, progress);
        dt_lua_lock();
        return 0;
    }
}
Exemplo n.º 2
0
static void finalize_store_wrapper(struct dt_imageio_module_storage_t *self, dt_imageio_module_data_t *data)
{
  dt_lua_lock();
  lua_State *L = darktable.lua_state.state;

  lua_getfield(L, LUA_REGISTRYINDEX, "dt_lua_storages");
  lua_getfield(L, -1, self->plugin_name);
  lua_getfield(L, -1, "finalize_store");

  if(lua_isnil(L, -1))
  {
    lua_pop(L, 3);
    dt_lua_unlock();
    return;
  }

  luaA_push_type(L, self->parameter_lua_type, data);

  lua_storage_t *d = (lua_storage_t *)data;
  push_lua_data(L,d);
  dt_lua_goto_subtable(L,"files");

  push_lua_data(L,d);
  dt_lua_goto_subtable(L,"extra");

  dt_lua_treated_pcall(L,3,0);
  lua_pop(L, 2);
  dt_lua_unlock();
}
Exemplo n.º 3
0
static int lua_job_progress(lua_State *L)
{
    dt_progress_t *progress;
    luaA_to(L, dt_lua_backgroundjob_t, &progress, 1);
    dt_lua_unlock(false);
    gboolean i_own_lock = dt_control_gdk_lock();
    dt_pthread_mutex_lock(&darktable.control->progress_system.mutex);
    GList *iter = g_list_find(darktable.control->progress_system.list, progress);
    dt_pthread_mutex_unlock(&darktable.control->progress_system.mutex);
    if(i_own_lock) dt_control_gdk_unlock();
    dt_lua_lock();
    if(!iter) luaL_error(L,"Accessing an invalid job");
    if(lua_isnone(L, 3))
    {
        dt_lua_unlock(false);
        double result = dt_control_progress_get_progress(progress);
        dt_lua_lock();
        if(!dt_control_progress_has_progress_bar(progress))
            lua_pushnil(L);
        else
            lua_pushnumber(L, result);
        return 1;
    }
    else
    {
        double value;
        luaA_to(L,progress_double,&value,3);
        dt_lua_unlock(false);
        dt_control_progress_set_progress(darktable.control, progress, value);
        dt_lua_lock();
        return 0;
    }
}
Exemplo n.º 4
0
static void initialize_store_wrapper (struct dt_imageio_module_storage_t *self, dt_imageio_module_data_t *data, dt_imageio_module_format_t *format, dt_imageio_module_data_t *fdata, GList **images, const gboolean high_quality)
{
  gboolean has_lock = dt_lua_lock();
  lua_State *L =darktable.lua_state.state;

  lua_getfield(L,LUA_REGISTRYINDEX,"dt_lua_storages");
  lua_getfield(L,-1,self->plugin_name);
  lua_getfield(L,-1,"initialize_store");

  if(lua_isnil(L,-1)) {
    lua_pop(L,3);
    dt_lua_unlock(has_lock);
    return;
  }

  luaA_push_typeid(L,self->parameter_lua_type,data);
  luaA_push_typeid(L,format->parameter_lua_type,fdata);

  GList* imgids =*images;
  lua_newtable(L);
  while(imgids) {
    luaA_push(L,dt_lua_image_t,&(imgids->data));
    luaL_ref(L,-2);
    imgids = g_list_next(imgids);
  }
  lua_pushboolean(L,high_quality);

  lua_storage_t *d = (lua_storage_t*) data;
  if(!d->data_created) {
    lua_pushlightuserdata(L,d);
    lua_newtable(L);
    lua_settable(L,LUA_REGISTRYINDEX);
    d->data_created = true;
  }
  lua_pushlightuserdata(L,data);
  lua_gettable(L,LUA_REGISTRYINDEX);

  dt_lua_do_chunk_silent(L,5,1);
  if(!lua_isnoneornil(L,-1)) {
    luaL_checktype(L,-1,LUA_TTABLE);
    g_list_free(*images);
    GList *new_images=NULL;
    lua_pushnil(L);
    while(lua_next(L,-2)){
      dt_lua_image_t imgid;
      luaA_to(L,dt_lua_image_t,&imgid,-1);
      new_images = g_list_prepend(new_images,GINT_TO_POINTER(imgid));
      lua_pop(L,1);
    }
    new_images = g_list_reverse(new_images);
    *images = new_images;
  }
  lua_pop(L,3);
  dt_lua_unlock(has_lock);
}
Exemplo n.º 5
0
static int selection_cb(lua_State *L)
{
    GList *image = dt_collection_get_selected(darktable.collection, -1);
    if(lua_gettop(L) > 0)
    {
        GList * new_selection = NULL;
        luaL_checktype(L,-1,LUA_TTABLE);
        lua_pushnil(L);
        while (lua_next(L, -2) != 0)
        {
            /* uses 'key' (at index -2) and 'value' (at index -1) */
            int imgid;
            luaA_to(L,dt_lua_image_t,&imgid,-1);
            new_selection = g_list_prepend(new_selection,GINT_TO_POINTER(imgid));
            lua_pop(L,1);
        }
        new_selection = g_list_reverse(new_selection);
        dt_lua_unlock(true);// we need the gdk lock to update ui information
        dt_selection_clear(darktable.selection);
        dt_selection_select_list(darktable.selection,new_selection);
        dt_lua_lock();
        g_list_free(new_selection);
    }
    lua_newtable(L);
    while(image)
    {
        luaA_push(L,dt_lua_image_t,&image->data);
        luaL_ref(L,-2);
        image = g_list_delete_link(image, image);
    }
    return 1;
}
Exemplo n.º 6
0
static int write_image(lua_State *L)
{
  /* check that param 1 is a module_format_t */
  luaL_argcheck(L,dt_lua_isa(L,1,dt_imageio_module_format_t),-1,"dt_imageio_module_format_t expected");

  lua_getmetatable(L,1);
  lua_getfield(L,-1,"__luaA_Type");
  luaA_Type format_type = luaL_checkint(L,-1);
  lua_pop(L,1);
  lua_getfield(L,-1,"__associated_object");
  dt_imageio_module_format_t * format = lua_touserdata(L,-1);
  lua_pop(L,2);
  dt_imageio_module_data_t* fdata = format->get_params(format);
  luaA_to_type(L,format_type,fdata,1);

  /* check that param 2 is an image */
  dt_lua_image_t imgid;
  luaA_to(L,dt_lua_image_t,&imgid,2);

  /* check that param 3 is a string (filename) */
  const char * filename = luaL_checkstring(L,3);


  dt_lua_unlock(false);
  gboolean high_quality = dt_conf_get_bool("plugins/lighttable/export/high_quality_processing");
  gboolean result = dt_imageio_export(imgid,filename,format,fdata,high_quality,FALSE,NULL,NULL);
  dt_lua_lock();
  lua_pushboolean(L,result);
  format->free_params(format,fdata);
  return 1;
}
Exemplo n.º 7
0
int dt_lua_gtk_wrap(lua_State*L)
{ 
  lua_pushvalue(L,lua_upvalueindex(1));
  lua_insert(L,1);
  if(pthread_equal(darktable.control->gui_thread, pthread_self())) {
    return dt_lua_do_chunk_raise(L,lua_gettop(L)-1,LUA_MULTRET);
  } else {
    dt_lua_unlock();
    gtk_wrap_communication communication;
    g_mutex_init(&communication.end_mutex);
    g_cond_init(&communication.end_cond);
    communication.L = L;
    g_mutex_lock(&communication.end_mutex);
    g_main_context_invoke(NULL,dt_lua_gtk_wrap_callback,&communication);
    g_cond_wait(&communication.end_cond,&communication.end_mutex);
    g_mutex_unlock(&communication.end_mutex);
    g_mutex_clear(&communication.end_mutex);
    dt_lua_lock();
    if(communication.retval == LUA_OK) {
      return lua_gettop(L);
    } else {
      return lua_error(L);
    }
  }

}
Exemplo n.º 8
0
Arquivo: call.c Projeto: rgo/darktable
static int gtk_wrap(lua_State*L)
{ 
  lua_pushvalue(L,lua_upvalueindex(1));
  lua_insert(L,1);
  if(pthread_equal(darktable.control->gui_thread, pthread_self())) {
    lua_call(L, lua_gettop(L)-1, LUA_MULTRET);
    return lua_gettop(L);
  } else {
#ifdef _DEBUG
    dt_print(DT_DEBUG_LUA, "LUA DEBUG : %s called from %s %llu\n", __FUNCTION__,
             lua_tostring(L, lua_upvalueindex(2)), lua_tointeger(L, lua_upvalueindex(3)));
#endif
    dt_lua_unlock();
    gtk_wrap_communication communication;
    g_mutex_init(&communication.end_mutex);
    g_cond_init(&communication.end_cond);
    communication.L = L;
    g_mutex_lock(&communication.end_mutex);
    g_main_context_invoke(NULL,dt_lua_gtk_wrap_callback,&communication);
    g_cond_wait(&communication.end_cond,&communication.end_mutex);
    g_mutex_unlock(&communication.end_mutex);
    g_mutex_clear(&communication.end_mutex);
    dt_lua_lock();
#ifdef _DEBUG
    dt_print(DT_DEBUG_LUA, "LUA DEBUG : %s return for call from from %s %llu\n", __FUNCTION__,
             lua_tostring(L, lua_upvalueindex(2)), lua_tointeger(L, lua_upvalueindex(3)));
#endif
    if(communication.retval == LUA_OK) {
      return lua_gettop(L);
    } else {
      return lua_error(L);
    }
  }

}
Exemplo n.º 9
0
Arquivo: call.c Projeto: rgo/darktable
static void run_async_thread_main(gpointer data,gpointer user_data)
{
  // lua lock ownership transfered from parent thread
  int thread_num = GPOINTER_TO_INT(data);
  lua_State*L = darktable.lua_state.state;
  lua_State* thread = get_thread(L,thread_num);
  if(!thread) {
    dt_print(DT_DEBUG_LUA, "LUA ERROR : no thread found, this should never happen\n");
    return;
  }
  dt_lua_finish_callback  cb = lua_touserdata(thread,1);
  void * cb_data = lua_touserdata(thread,2);
  int nresults = lua_tointeger(thread, 3);
  lua_pushcfunction(thread,create_backtrace);
  lua_insert(thread,4);
  int thread_result = lua_pcall(thread,  lua_gettop(thread)-5,nresults,4);
  if(cb) {
    cb(thread,thread_result,cb_data);
  } else {
    dt_lua_check_print_error(thread,thread_result);
  }
  drop_thread(L,thread_num);
  dt_lua_unlock();
  return;

}
Exemplo n.º 10
0
static int lua_create_job(lua_State *L)
{
    const char * message = luaL_checkstring(L, 1);
    gboolean has_progress_bar = lua_toboolean(L, 2);
    int cancellable = FALSE;
    if(!lua_isnoneornil(L,3))
    {
        luaL_checktype(L, 3, LUA_TFUNCTION);
        cancellable = TRUE;
    }
    dt_lua_unlock(false);
    dt_progress_t *progress = dt_control_progress_create(darktable.control, has_progress_bar, message);
    if(cancellable)
    {
        dt_control_progress_make_cancellable(darktable.control, progress, lua_job_cancelled, progress);
    }
    dt_lua_lock();
    luaA_push(L, dt_lua_backgroundjob_t, &progress);
    if(cancellable)
    {
        lua_getuservalue(L, -1);
        lua_pushvalue(L, 3);
        lua_setfield(L, -2, "cancel_callback");
        lua_pop(L, 1);
    }
    return 1;
}
Exemplo n.º 11
0
void dt_lua_finalize_early()
{
  darktable.lua_state.ending = true;
  dt_lua_lock();
  dt_lua_event_trigger(darktable.lua_state.state,"exit",0);
  dt_lua_unlock();
  g_main_context_wakeup(darktable.lua_state.context);
}
Exemplo n.º 12
0
Arquivo: call.c Projeto: rgo/darktable
static int sleep_cb(lua_State*L)
{
  const int delay = luaL_optinteger(L, 1, 0);
  dt_lua_unlock();
  g_usleep(delay*1000);
  dt_lua_lock();
  return 0;
}
Exemplo n.º 13
0
Arquivo: call.c Projeto: rgo/darktable
static int execute_cb(lua_State*L)
{
  const char *cmd = luaL_optstring(L, 1, NULL);
  dt_lua_unlock();
  int stat = system(cmd);
  dt_lua_lock();
  lua_pushinteger(L,stat);
  return 1;
}
Exemplo n.º 14
0
static int32_t shortcut_callback_job(struct dt_job_t *job) {
  gboolean has_lock = dt_lua_lock();
  shortcut_callback_data *t = (shortcut_callback_data*)job->param;
  lua_pushstring(darktable.lua_state.state,t->name);
  free(t->name);
  run_event("shortcut",1);
  dt_lua_unlock(has_lock);
  return 0;
}
Exemplo n.º 15
0
static int32_t on_image_imported_callback_job(dt_job_t *job) {
  gboolean has_lock = dt_lua_lock();
  on_image_imported_callback_data_t *t = dt_control_job_get_params(job);
  luaA_push(darktable.lua_state.state,dt_lua_image_t,&t->imgid);
  dt_lua_event_trigger(darktable.lua_state.state,"post-import-image",1);
  free(t); // i am not sure if the free() may happen before the dt_lua_event_trigger as a pointer to the imgid inside of it is pushed to the lua stack
  dt_lua_unlock(has_lock);
  return 0;
}
Exemplo n.º 16
0
static void on_export_image_tmpfile(gpointer instance,
    int imgid,
    char *filename,
     gpointer user_data){
  gboolean has_lock = dt_lua_lock();
  luaA_push(darktable.lua_state.state,dt_lua_image_t,&imgid);
  lua_pushstring(darktable.lua_state.state,filename);
  run_event("intermediate-export-image",2);
  dt_lua_unlock(has_lock);
}
Exemplo n.º 17
0
void dt_lua_redraw_screen()
{
  if(darktable.gui != NULL)
  {
    dt_lua_unlock(false);
    dt_control_signal_raise(darktable.signals, DT_SIGNAL_FILMROLLS_CHANGED); // just for good measure
    dt_control_queue_redraw();
    dt_lua_lock();
  }
}
Exemplo n.º 18
0
static void finalize_store_wrapper (struct dt_imageio_module_storage_t *self, dt_imageio_module_data_t *data)
{
  gboolean has_lock = dt_lua_lock();
  lua_State *L =darktable.lua_state.state;

  lua_getfield(L,LUA_REGISTRYINDEX,"dt_lua_storages");
  lua_getfield(L,-1,self->plugin_name);
  lua_getfield(L,-1,"finalize_store");

  if(lua_isnil(L,-1)) {
    lua_pop(L,3);
    dt_lua_unlock(has_lock);
    return;
  }

  luaA_push_typeid(L,self->parameter_lua_type,data);

  lua_storage_t *d = (lua_storage_t*) data;
  GList* imgids =d->imgids;
  GList* file_names = d->file_names;
  lua_newtable(L);
  while(imgids) {
    luaA_push(L,dt_lua_image_t,&(imgids->data));
    lua_pushstring(L,file_names->data);
    lua_settable(L,-3);
    imgids = g_list_next(imgids);
    file_names = g_list_next(file_names);
  }

  if(!d->data_created) {
    lua_pushlightuserdata(darktable.lua_state.state,d);
    lua_newtable(darktable.lua_state.state);
    lua_settable(darktable.lua_state.state,LUA_REGISTRYINDEX);
    d->data_created = true;
  }
  lua_pushlightuserdata(L,data);
  lua_gettable(L,LUA_REGISTRYINDEX);

  dt_lua_do_chunk_silent(L,3,0);
  lua_pop(L,2);
  dt_lua_unlock(has_lock);
}
Exemplo n.º 19
0
Arquivo: call.c Projeto: rgo/darktable
static gboolean alien_job_dispatch (GSource* source, GSourceFunc callback, gpointer user_data)
{
  gpointer message;
  message = g_async_queue_try_pop (darktable.lua_state.alien_job_queue);
  if (message == NULL)
  {
    return TRUE;
  }

  async_call_data* data = (async_call_data*)message;
  dt_lua_lock();
  lua_State* L= darktable.lua_state.state;
  lua_State *new_thread = lua_newthread(L);
  int reference = save_thread(L);
  lua_pushlightuserdata(new_thread,data->cb);
  lua_pushlightuserdata(new_thread,data->cb_data);
  lua_pushinteger(new_thread,data->nresults);
  lua_pushcfunction(new_thread,data->pusher);

  GList* cur_elt = data->extra;
  while(cur_elt) {
    GList * type_type_elt = cur_elt;
    cur_elt = g_list_next(cur_elt);
    GList * type_elt = cur_elt;
    cur_elt = g_list_next(cur_elt);
    GList * data_elt = cur_elt;
    cur_elt = g_list_next(cur_elt);
    switch(GPOINTER_TO_INT(type_type_elt->data)) {
      case LUA_ASYNC_TYPEID_WITH_FREE:
        // skip the destructor
        cur_elt = g_list_next(cur_elt);
        // do not break
      case LUA_ASYNC_TYPEID:
        luaA_push_type(new_thread,GPOINTER_TO_INT(type_elt->data),data_elt->data);
        break;
      case LUA_ASYNC_TYPENAME_WITH_FREE:
        // skip the destructor
        cur_elt = g_list_next(cur_elt);
        // do not break
      case LUA_ASYNC_TYPENAME:
        luaA_push_type(new_thread,luaA_type_find(L,type_elt->data),&data_elt->data);
        break;
      case LUA_ASYNC_DONE:
      default:
        // should never happen
        g_assert(false);
        break;
    }
  }
  run_async_thread(L,reference);
  dt_lua_unlock();
  alien_job_destroy(data);
  return G_SOURCE_CONTINUE;
}
Exemplo n.º 20
0
static int32_t view_changed_callback_job(dt_job_t *job)
{
  dt_lua_lock();
  view_changed_callback_data_t *t = dt_control_job_get_params(job);
  dt_lua_module_entry_push(darktable.lua_state.state, "view", t->old_view->module_name);
  dt_lua_module_entry_push(darktable.lua_state.state, "view", t->new_view->module_name);
  free(t);
  dt_lua_event_trigger(darktable.lua_state.state, "view-changed", 2);
  dt_lua_unlock();
  return 0;
}
Exemplo n.º 21
0
gboolean dt_lua_gtk_wrap_callback(gpointer data)
{
  dt_lua_lock_silent();
  gtk_wrap_communication *communication = (gtk_wrap_communication*)data;
  g_mutex_lock(&communication->end_mutex);
  communication->retval = dt_lua_do_chunk(communication->L,lua_gettop(communication->L)-1,LUA_MULTRET);
  g_cond_signal(&communication->end_cond);
  g_mutex_unlock(&communication->end_mutex);
  dt_lua_unlock();
  return false;
} 
Exemplo n.º 22
0
Arquivo: call.c Projeto: rgo/darktable
gboolean dt_lua_gtk_wrap_callback(gpointer data)
{
  dt_lua_lock_silent();
  gtk_wrap_communication *communication = (gtk_wrap_communication*)data;
  g_mutex_lock(&communication->end_mutex);
  // TODO : propre stack unwinding
  communication->retval = lua_pcall(communication->L,lua_gettop(communication->L)-1,LUA_MULTRET,0);
  g_cond_signal(&communication->end_cond);
  g_mutex_unlock(&communication->end_mutex);
  dt_lua_unlock();
  return false;
} 
Exemplo n.º 23
0
static int32_t on_mouse_over_image_changed_callback_job(dt_job_t *job)
{
  dt_lua_lock();
  on_mouse_over_image_changed_callback_data_t *t = dt_control_job_get_params(job);
  int n_params = (t->imgid != -1);
  if(n_params)
    luaA_push(darktable.lua_state.state, dt_lua_image_t, &t->imgid);
  dt_lua_event_trigger(darktable.lua_state.state, "mouse-over-image-changed", n_params);
  free(t); 
  dt_lua_unlock();
  return 0;
}
Exemplo n.º 24
0
static int32_t widget_callback_job(dt_job_t *job)
{
  dt_lua_lock();
  lua_State* L= darktable.lua_state.state;
  widget_callback_data* data = (widget_callback_data*)dt_control_job_get_params(job);
  dt_lua_widget_trigger_callback_glist(L,data->object,data->event_name,data->extra);
  free(data->event_name);
  free(data);
  dt_lua_unlock();
  return 0;

}
Exemplo n.º 25
0
void dt_lua_init(lua_State *L, const char *lua_command)
{
  char tmp_path[PATH_MAX] = { 0 };
  // init the lua environment
  lua_CFunction *cur_type = init_funcs;
  while(*cur_type)
  {
    (*cur_type)(L);
    cur_type++;
  }
  assert(lua_gettop(L)
         == 0); // if you are here, you have probably added an initialisation function that is not stack clean

  // build the table containing the configuration info

  lua_getglobal(L, "package");
  dt_lua_goto_subtable(L, "loaded");
  lua_pushstring(L, "darktable");
  dt_lua_push_darktable_lib(L);
  lua_settable(L, -3);
  lua_pop(L, 1);

  lua_getglobal(L, "package");
  lua_getfield(L, -1, "path");
  lua_pushstring(L, ";");
  dt_loc_get_datadir(tmp_path, sizeof(tmp_path));
  lua_pushstring(L, tmp_path);
  lua_pushstring(L, "/lua/?.lua");
  lua_pushstring(L, ";");
  dt_loc_get_user_config_dir(tmp_path, sizeof(tmp_path));
  lua_pushstring(L, tmp_path);
  lua_pushstring(L, "/lua/?.lua");
  lua_concat(L, 7);
  lua_setfield(L, -2, "path");
  lua_pop(L, 1);



  lua_pushcfunction(L,run_early_script);
  lua_pushstring(L,lua_command);

  if(darktable.gui)
  {
    dt_lua_do_chunk_later(L,1);
  }
  else
  {
    dt_lua_do_chunk_silent(L,1,0);
  }
  // allow other threads to wake up and do their job
  dt_lua_unlock();
}
Exemplo n.º 26
0
static int32_t on_mouse_over_image_changed_callback_job(dt_job_t *job)
{
  gboolean has_lock = dt_lua_lock();
  on_mouse_over_image_changed_callback_data_t *t = dt_control_job_get_params(job);
  int n_params = (t->imgid != -1);
  if(n_params)
    luaA_push(darktable.lua_state.state, dt_lua_image_t, &t->imgid);
  dt_lua_event_trigger(darktable.lua_state.state, "mouse-over-image-changed", n_params);
  free(t); // i am not sure if the free() may happen before the dt_lua_event_trigger as a pointer to the imgid
  // inside of it is pushed to the lua stack
  dt_lua_unlock(has_lock);
  return 0;
}
Exemplo n.º 27
0
Arquivo: call.c Projeto: rgo/darktable
static int read_cb(lua_State*L)
{
  luaL_checkudata(L,1,LUA_FILEHANDLE);
  luaL_Stream *stream = lua_touserdata(L, 1);
  int myfileno = fileno(stream->f);
  fd_set fdset;
  FD_ZERO(&fdset);
  FD_SET(myfileno, &fdset);
  dt_lua_unlock();
  select(myfileno + 1, &fdset, NULL, NULL, 0);
  dt_lua_lock();
  return 0;
}
Exemplo n.º 28
0
static int32_t lua_job_canceled_job(dt_job_t *job)
{
    dt_progress_t *progress = dt_control_job_get_params(job);
    lua_State * L = darktable.lua_state.state;
    gboolean has_lock = dt_lua_lock();
    luaA_push(L, dt_lua_backgroundjob_t, &progress);
    lua_getuservalue(L, -1);
    lua_getfield(L, -1, "cancel_callback");
    lua_pushvalue(L, -3);
    dt_lua_do_chunk(L, 1, 0);
    lua_pop(L, 2);
    dt_lua_unlock(has_lock);
    return 0;
}
Exemplo n.º 29
0
Arquivo: call.c Projeto: rgo/darktable
static gboolean string_job_dispatch (GSource* source, GSourceFunc callback, gpointer user_data)
{
  gpointer message;
  message = g_async_queue_try_pop (darktable.lua_state.string_job_queue);
  if (message == NULL)
  {
    return TRUE;
  }
  string_call_data* data = (string_call_data*)message;

  dt_lua_lock();
  lua_State* L= darktable.lua_state.state;
  lua_State *new_thread = lua_newthread(L);
  int reference = save_thread(L);
  lua_pushlightuserdata(new_thread,data->cb);
  lua_pushlightuserdata(new_thread,data->cb_data);
  lua_pushinteger(new_thread,data->nresults);

  int load_result = luaL_loadstring(new_thread, data->function);
  if(load_result != LUA_OK)
  {
    if(data->cb) {
      data->cb(new_thread,load_result,data->cb_data);
    } else {
      dt_lua_check_print_error(new_thread,load_result);
    }
    drop_thread(L,reference);
    dt_lua_unlock();
    string_data_destroy(data);
    return G_SOURCE_CONTINUE;
  }

  run_async_thread(L,reference);
  dt_lua_unlock();
  string_data_destroy(data);
  return G_SOURCE_CONTINUE;
}
Exemplo n.º 30
0
void dt_lua_finalize_early()
{
  darktable.lua_state.ending = true;
  dt_lua_lock();
  dt_lua_event_trigger(darktable.lua_state.state,"exit",0);
  dt_lua_unlock();
  int i = 10;
  while(i && darktable.lua_state.pending_threads){
    dt_print(DT_DEBUG_LUA, "LUA : waiting for %d threads to finish...\n", darktable.lua_state.pending_threads);
    sleep(1);// give them a little time to finish
    i--;
  }
  if(darktable.lua_state.pending_threads)
    dt_print(DT_DEBUG_LUA, "LUA : all threads did not finish properly.\n");
}