fix for missing change to fluidsim from last commit and name jobs a more useful name...
authorCampbell Barton <ideasman42@gmail.com>
Wed, 15 Aug 2012 10:03:29 +0000 (10:03 +0000)
committerCampbell Barton <ideasman42@gmail.com>
Wed, 15 Aug 2012 10:03:29 +0000 (10:03 +0000)
13 files changed:
source/blender/editors/object/object_bake.c
source/blender/editors/object/object_modifier.c
source/blender/editors/physics/physics_fluid.c
source/blender/editors/render/render_internal.c
source/blender/editors/render/render_preview.c
source/blender/editors/screen/screendump.c
source/blender/editors/space_clip/clip_ops.c
source/blender/editors/space_clip/tracking_ops.c
source/blender/editors/space_file/filelist.c
source/blender/editors/space_node/node_edit.c
source/blender/editors/space_sequencer/sequencer_edit.c
source/blender/windowmanager/WM_api.h
source/blender/windowmanager/intern/wm_jobs.c

index be0d9e67779ae586572276f8c3edb50bdd70d751..13681407d542508d2cc4e206743afc89f304c8db 100644 (file)
@@ -1241,7 +1241,7 @@ static int multiresbake_image_exec(bContext *C, wmOperator *op)
 {
        Scene *scene = CTX_data_scene(C);
        MultiresBakeJob *bkr;
-       wmJob *steve;
+       wmJob *wm_job;
 
        if (!multiresbake_check(C, op))
                return OPERATOR_CANCELLED;
@@ -1255,15 +1255,15 @@ static int multiresbake_image_exec(bContext *C, wmOperator *op)
        }
 
        /* setup job */
-       steve = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, "Multires Bake",
-                           WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS, WM_JOB_TYPE_OBJECT_BAKE_TEXTURE);
-       WM_jobs_customdata_set(steve, bkr, multiresbake_freejob);
-       WM_jobs_timer(steve, 0.2, NC_IMAGE, 0); /* TODO - only draw bake image, can we enforce this */
-       WM_jobs_callbacks(steve, multiresbake_startjob, NULL, NULL, NULL);
+       wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, "Multires Bake",
+                            WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS, WM_JOB_TYPE_OBJECT_BAKE_TEXTURE);
+       WM_jobs_customdata_set(wm_job, bkr, multiresbake_freejob);
+       WM_jobs_timer(wm_job, 0.2, NC_IMAGE, 0); /* TODO - only draw bake image, can we enforce this */
+       WM_jobs_callbacks(wm_job, multiresbake_startjob, NULL, NULL, NULL);
 
        G.is_break = FALSE;
 
-       WM_jobs_start(CTX_wm_manager(C), steve);
+       WM_jobs_start(CTX_wm_manager(C), wm_job);
        WM_cursor_wait(0);
 
        /* add modal handler for ESC */
@@ -1477,22 +1477,22 @@ static int objects_bake_render_invoke(bContext *C, wmOperator *op, wmEvent *UNUS
                }
                else {
                        BakeRender *bkr = MEM_callocN(sizeof(BakeRender), "render bake");
-                       wmJob *steve;
+                       wmJob *wm_job;
 
                        init_bake_internal(bkr, C);
                        bkr->reports = op->reports;
 
                        /* setup job */
-                       steve = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, "Texture Bake",
-                                           WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS, WM_JOB_TYPE_OBJECT_BAKE_TEXTURE);
-                       WM_jobs_customdata_set(steve, bkr, bake_freejob);
-                       WM_jobs_timer(steve, 0.2, NC_IMAGE, 0); /* TODO - only draw bake image, can we enforce this */
-                       WM_jobs_callbacks(steve, bake_startjob, NULL, bake_update, NULL);
+                       wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, "Texture Bake",
+                                            WM_JOB_EXCL_RENDER | WM_JOB_PRIORITY | WM_JOB_PROGRESS, WM_JOB_TYPE_OBJECT_BAKE_TEXTURE);
+                       WM_jobs_customdata_set(wm_job, bkr, bake_freejob);
+                       WM_jobs_timer(wm_job, 0.2, NC_IMAGE, 0); /* TODO - only draw bake image, can we enforce this */
+                       WM_jobs_callbacks(wm_job, bake_startjob, NULL, bake_update, NULL);
 
                        G.is_break = FALSE;
                        G.is_rendering = TRUE;
 
-                       WM_jobs_start(CTX_wm_manager(C), steve);
+                       WM_jobs_start(CTX_wm_manager(C), wm_job);
 
                        WM_cursor_wait(0);
 
index 556ed44520cb71b4f2f44a49f3e3387f78427e05..47f5a28537471614857ceef2e468756d10cea329 100644 (file)
@@ -2114,7 +2114,7 @@ static int ocean_bake_exec(bContext *C, wmOperator *op)
        int f, cfra, i = 0;
        int free = RNA_boolean_get(op->ptr, "free");
        
-       wmJob *steve;
+       wmJob *wm_job;
        OceanBakeJob *oj;
        
        if (!omd)
@@ -2181,18 +2181,18 @@ static int ocean_bake_exec(bContext *C, wmOperator *op)
        scene->r.cfra = cfra;
        
        /* setup job */
-       steve = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, "Ocean Simulation",
-                           WM_JOB_PROGRESS, WM_JOB_TYPE_OBJECT_SIM_OCEAN);
+       wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, "Ocean Simulation",
+                            WM_JOB_PROGRESS, WM_JOB_TYPE_OBJECT_SIM_OCEAN);
        oj = MEM_callocN(sizeof(OceanBakeJob), "ocean bake job");
        oj->ocean = ocean;
        oj->och = och;
        oj->omd = omd;
        
-       WM_jobs_customdata_set(steve, oj, oceanbake_free);
-       WM_jobs_timer(steve, 0.1, NC_OBJECT | ND_MODIFIER, NC_OBJECT | ND_MODIFIER);
-       WM_jobs_callbacks(steve, oceanbake_startjob, NULL, NULL, oceanbake_endjob);
+       WM_jobs_customdata_set(wm_job, oj, oceanbake_free);
+       WM_jobs_timer(wm_job, 0.1, NC_OBJECT | ND_MODIFIER, NC_OBJECT | ND_MODIFIER);
+       WM_jobs_callbacks(wm_job, oceanbake_startjob, NULL, NULL, oceanbake_endjob);
        
-       WM_jobs_start(CTX_wm_manager(C), steve);
+       WM_jobs_start(CTX_wm_manager(C), wm_job);
        
        
        
index 60907e8cefaaf72bb5de84f5ae3f5c1acc597598..5b0a58b394a9c0303386870a14c4e4ca25944ff0 100644 (file)
@@ -1068,14 +1068,15 @@ static int fluidsimBake(bContext *C, ReportList *reports, Object *fsDomain, shor
        fb->settings = fsset;
        
        if (do_job) {
-               wmJob *steve= WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, "Fluid Simulation", WM_JOB_PROGRESS);
+               wmJob *wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, "Fluid Simulation",
+                                           WM_JOB_PROGRESS, WM_JOB_TYPE_OBJECT_SIM_FLUID);
 
                /* setup job */
-               WM_jobs_customdata_set(steve, fb, fluidbake_free);
-               WM_jobs_timer(steve, 0.1, NC_SCENE|ND_FRAME, NC_SCENE|ND_FRAME);
-               WM_jobs_callbacks(steve, fluidbake_startjob, NULL, NULL, fluidbake_endjob);
+               WM_jobs_customdata_set(wm_job, fb, fluidbake_free);
+               WM_jobs_timer(wm_job, 0.1, NC_SCENE|ND_FRAME, NC_SCENE|ND_FRAME);
+               WM_jobs_callbacks(wm_job, fluidbake_startjob, NULL, NULL, fluidbake_endjob);
 
-               WM_jobs_start(CTX_wm_manager(C), steve);
+               WM_jobs_start(CTX_wm_manager(C), wm_job);
        }
        else {
                short dummy_stop, dummy_do_update;
index c5467051bb2738557225817a85b55ef5e9aa4170..ecab47cf67d62fd9d5bb7cc62aebafe69c52b4e0 100644 (file)
@@ -479,7 +479,7 @@ static int screen_render_invoke(bContext *C, wmOperator *op, wmEvent *event)
        SceneRenderLayer *srl = NULL;
        View3D *v3d = CTX_wm_view3d(C);
        Render *re;
-       wmJob *steve;
+       wmJob *wm_job;
        RenderJob *rj;
        Image *ima;
        int jobflag;
@@ -564,10 +564,10 @@ static int screen_render_invoke(bContext *C, wmOperator *op, wmEvent *event)
        if (RE_seq_render_active(scene, &scene->r)) name = "Sequence Render";
        else name = "Render";
 
-       steve = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, name, jobflag, WM_JOB_TYPE_RENDER);
-       WM_jobs_customdata_set(steve, rj, render_freejob);
-       WM_jobs_timer(steve, 0.2, NC_SCENE | ND_RENDER_RESULT, 0);
-       WM_jobs_callbacks(steve, render_startjob, NULL, NULL, render_endjob);
+       wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene, name, jobflag, WM_JOB_TYPE_RENDER);
+       WM_jobs_customdata_set(wm_job, rj, render_freejob);
+       WM_jobs_timer(wm_job, 0.2, NC_SCENE | ND_RENDER_RESULT, 0);
+       WM_jobs_callbacks(wm_job, render_startjob, NULL, NULL, render_endjob);
 
        /* get a render result image, and make sure it is empty */
        ima = BKE_image_verify_viewer(IMA_TYPE_R_RESULT, "Render Result");
@@ -592,7 +592,7 @@ static int screen_render_invoke(bContext *C, wmOperator *op, wmEvent *event)
         */
        op->customdata = scene;
 
-       WM_jobs_start(CTX_wm_manager(C), steve);
+       WM_jobs_start(CTX_wm_manager(C), wm_job);
 
        WM_cursor_wait(0);
        WM_event_add_notifier(C, NC_SCENE | ND_RENDER_RESULT, scene);
index bdc44af76c8ad9d07e2acda26254aa972077a5d5..4f62974a3e1806cb3b87bfc9ffdf21259a6cabf2 100644 (file)
@@ -1022,17 +1022,17 @@ static void icon_preview_free(void *customdata)
 
 void ED_preview_icon_job(const bContext *C, void *owner, ID *id, unsigned int *rect, int sizex, int sizey)
 {
-       wmJob *steve;
+       wmJob *wm_job;
        IconPreview *ip, *old_ip;
        
        /* suspended start means it starts after 1 timer step, see WM_jobs_timer below */
-       steve = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), owner, "Icon Preview",
-                           WM_JOB_EXCL_RENDER | WM_JOB_SUSPEND, WM_JOB_TYPE_RENDER_PREVIEW);
+       wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), owner, "Icon Preview",
+                            WM_JOB_EXCL_RENDER | WM_JOB_SUSPEND, WM_JOB_TYPE_RENDER_PREVIEW);
 
        ip = MEM_callocN(sizeof(IconPreview), "icon preview");
 
        /* render all resolutions from suspended job too */
-       old_ip = WM_jobs_customdata_get(steve);
+       old_ip = WM_jobs_customdata_get(wm_job);
        if (old_ip)
                BLI_movelisttolist(&ip->sizes, &old_ip->sizes);
 
@@ -1044,20 +1044,20 @@ void ED_preview_icon_job(const bContext *C, void *owner, ID *id, unsigned int *r
        icon_preview_add_size(ip, rect, sizex, sizey);
 
        /* setup job */
-       WM_jobs_customdata_set(steve, ip, icon_preview_free);
-       WM_jobs_timer(steve, 0.25, NC_MATERIAL, NC_MATERIAL);
-       WM_jobs_callbacks(steve, icon_preview_startjob_all_sizes, NULL, NULL, icon_preview_endjob);
+       WM_jobs_customdata_set(wm_job, ip, icon_preview_free);
+       WM_jobs_timer(wm_job, 0.25, NC_MATERIAL, NC_MATERIAL);
+       WM_jobs_callbacks(wm_job, icon_preview_startjob_all_sizes, NULL, NULL, icon_preview_endjob);
 
-       WM_jobs_start(CTX_wm_manager(C), steve);
+       WM_jobs_start(CTX_wm_manager(C), wm_job);
 }
 
 void ED_preview_shader_job(const bContext *C, void *owner, ID *id, ID *parent, MTex *slot, int sizex, int sizey, int method)
 {
        Object *ob = CTX_data_active_object(C);
-       wmJob *steve;
+       wmJob *wm_job;
        ShaderPreview *sp;
 
-       steve = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), owner, "Shader Preview",
+       wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), owner, "Shader Preview",
                            WM_JOB_EXCL_RENDER, WM_JOB_TYPE_RENDER_PREVIEW);
        sp = MEM_callocN(sizeof(ShaderPreview), "shader preview");
 
@@ -1074,11 +1074,11 @@ void ED_preview_shader_job(const bContext *C, void *owner, ID *id, ID *parent, M
        else sp->col[0] = sp->col[1] = sp->col[2] = sp->col[3] = 1.0f;
        
        /* setup job */
-       WM_jobs_customdata_set(steve, sp, shader_preview_free);
-       WM_jobs_timer(steve, 0.1, NC_MATERIAL, NC_MATERIAL);
-       WM_jobs_callbacks(steve, common_preview_startjob, NULL, shader_preview_updatejob, NULL);
+       WM_jobs_customdata_set(wm_job, sp, shader_preview_free);
+       WM_jobs_timer(wm_job, 0.1, NC_MATERIAL, NC_MATERIAL);
+       WM_jobs_callbacks(wm_job, common_preview_startjob, NULL, shader_preview_updatejob, NULL);
        
-       WM_jobs_start(CTX_wm_manager(C), steve);
+       WM_jobs_start(CTX_wm_manager(C), wm_job);
 }
 
 void ED_preview_kill_jobs(const struct bContext *C)
index 3dd3a28a7e5986eafcc8c4afda5e057c4ea2671b..41e2f0b16a437d15c06d5b0a654de5b2636946d2 100644 (file)
@@ -396,7 +396,7 @@ static void screenshot_startjob(void *sjv, short *stop, short *do_update, float
 static int screencast_exec(bContext *C, wmOperator *op)
 {
        bScreen *screen = CTX_wm_screen(C);
-       wmJob *steve = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), screen, "Screencast", 0, WM_JOB_TYPE_SCREENCAST);
+       wmJob *wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), screen, "Screencast", 0, WM_JOB_TYPE_SCREENCAST);
        ScreenshotJob *sj = MEM_callocN(sizeof(ScreenshotJob), "screenshot job");
 
        /* setup sj */
@@ -420,11 +420,11 @@ static int screencast_exec(bContext *C, wmOperator *op)
        BKE_reports_init(&sj->reports, RPT_PRINT);
 
        /* setup job */
-       WM_jobs_customdata_set(steve, sj, screenshot_freejob);
-       WM_jobs_timer(steve, 0.1, 0, NC_SCREEN | ND_SCREENCAST);
-       WM_jobs_callbacks(steve, screenshot_startjob, NULL, screenshot_updatejob, NULL);
+       WM_jobs_customdata_set(wm_job, sj, screenshot_freejob);
+       WM_jobs_timer(wm_job, 0.1, 0, NC_SCREEN | ND_SCREENCAST);
+       WM_jobs_callbacks(wm_job, screenshot_startjob, NULL, screenshot_updatejob, NULL);
        
-       WM_jobs_start(CTX_wm_manager(C), steve);
+       WM_jobs_start(CTX_wm_manager(C), wm_job);
        
        WM_event_add_notifier(C, NC_SCREEN | ND_SCREENCAST, screen);
        
index c88ab095b2e648759e637a13f227bde6fb686927..36199b1908d48b4675383d70fd906db7ddb56470 100644 (file)
@@ -1031,7 +1031,7 @@ static void proxy_endjob(void *pjv)
 
 static int clip_rebuild_proxy_exec(bContext *C, wmOperator *UNUSED(op))
 {
-       wmJob * steve;
+       wmJob *wm_job;
        ProxyJob *pj;
        Scene *scene = CTX_data_scene(C);
        ScrArea *sa = CTX_wm_area(C);
@@ -1041,8 +1041,8 @@ static int clip_rebuild_proxy_exec(bContext *C, wmOperator *UNUSED(op))
        if ((clip->flag & MCLIP_USE_PROXY) == 0)
                return OPERATOR_CANCELLED;
 
-       steve = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), sa, "Building Proxies",
-                           WM_JOB_PROGRESS, WM_JOB_TYPE_CLIP_BUILD_PROXY);
+       wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), sa, "Building Proxies",
+                            WM_JOB_PROGRESS, WM_JOB_TYPE_CLIP_BUILD_PROXY);
 
        pj = MEM_callocN(sizeof(ProxyJob), "proxy rebuild job");
        pj->scene = scene;
@@ -1055,12 +1055,12 @@ static int clip_rebuild_proxy_exec(bContext *C, wmOperator *UNUSED(op))
                                        clip->proxy.build_size_flag, clip->proxy.quality);
        }
 
-       WM_jobs_customdata_set(steve, pj, proxy_freejob);
-       WM_jobs_timer(steve, 0.2, NC_MOVIECLIP | ND_DISPLAY, 0);
-       WM_jobs_callbacks(steve, proxy_startjob, NULL, NULL, proxy_endjob);
+       WM_jobs_customdata_set(wm_job, pj, proxy_freejob);
+       WM_jobs_timer(wm_job, 0.2, NC_MOVIECLIP | ND_DISPLAY, 0);
+       WM_jobs_callbacks(wm_job, proxy_startjob, NULL, NULL, proxy_endjob);
 
        G.is_break = FALSE;
-       WM_jobs_start(CTX_wm_manager(C), steve);
+       WM_jobs_start(CTX_wm_manager(C), wm_job);
 
        ED_area_tag_redraw(CTX_wm_area(C));
 
index 580b23486e81700a4bb3f47ff6eb12a64f977669..cbf050261521c7d28fc2c5bfe941fb6710c99e9e 100644 (file)
@@ -1235,7 +1235,7 @@ static int track_markers_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(eve
        ScrArea *sa = CTX_wm_area(C);
        SpaceClip *sc = CTX_wm_space_clip(C);
        MovieClip *clip = ED_space_clip_get_clip(sc);
-       wmJob *steve;
+       wmJob *wm_job;
        int backwards = RNA_boolean_get(op->ptr, "backwards");
        int sequence = RNA_boolean_get(op->ptr, "sequence");
 
@@ -1261,24 +1261,24 @@ static int track_markers_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(eve
        }
 
        /* setup job */
-       steve = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), sa, "Track Markers",
-                           WM_JOB_PROGRESS, WM_JOB_TYPE_CLIP_TRACK_MARKERS);
-       WM_jobs_customdata_set(steve, tmj, track_markers_freejob);
+       wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), sa, "Track Markers",
+                            WM_JOB_PROGRESS, WM_JOB_TYPE_CLIP_TRACK_MARKERS);
+       WM_jobs_customdata_set(wm_job, tmj, track_markers_freejob);
 
        /* if there's delay set in tracking job, tracking should happen
         * with fixed FPS. To deal with editor refresh we have to synchronize
         * tracks from job and tracks in clip. Do this in timer callback
         * to prevent threading conflicts. */
        if (tmj->delay > 0)
-               WM_jobs_timer(steve, tmj->delay / 1000.0f, NC_MOVIECLIP | NA_EVALUATED, 0);
+               WM_jobs_timer(wm_job, tmj->delay / 1000.0f, NC_MOVIECLIP | NA_EVALUATED, 0);
        else
-               WM_jobs_timer(steve, 0.2, NC_MOVIECLIP | NA_EVALUATED, 0);
+               WM_jobs_timer(wm_job, 0.2, NC_MOVIECLIP | NA_EVALUATED, 0);
 
-       WM_jobs_callbacks(steve, track_markers_startjob, NULL, track_markers_updatejob, NULL);
+       WM_jobs_callbacks(wm_job, track_markers_startjob, NULL, track_markers_updatejob, NULL);
 
        G.is_break = FALSE;
 
-       WM_jobs_start(CTX_wm_manager(C), steve);
+       WM_jobs_start(CTX_wm_manager(C), wm_job);
        WM_cursor_wait(0);
 
        /* add modal handler for ESC */
@@ -1468,7 +1468,7 @@ static int solve_camera_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(even
        MovieClip *clip = ED_space_clip_get_clip(sc);
        MovieTracking *tracking = &clip->tracking;
        MovieTrackingReconstruction *reconstruction = BKE_tracking_get_active_reconstruction(tracking);
-       wmJob *steve;
+       wmJob *wm_job;
        char error_msg[256] = "\0";
 
        if (WM_jobs_test(CTX_wm_manager(C), CTX_wm_area(C), WM_JOB_TYPE_ANY)) {
@@ -1493,15 +1493,15 @@ static int solve_camera_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(even
        WM_event_add_notifier(C, NC_MOVIECLIP | NA_EVALUATED, clip);
 
        /* setup job */
-       steve = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), sa, "Solve Camera",
-                           WM_JOB_PROGRESS, WM_JOB_TYPE_CLIP_SOLVE_CAMERA);
-       WM_jobs_customdata_set(steve, scj, solve_camera_freejob);
-       WM_jobs_timer(steve, 0.1, NC_MOVIECLIP | NA_EVALUATED, 0);
-       WM_jobs_callbacks(steve, solve_camera_startjob, NULL, solve_camera_updatejob, NULL);
+       wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), sa, "Solve Camera",
+                            WM_JOB_PROGRESS, WM_JOB_TYPE_CLIP_SOLVE_CAMERA);
+       WM_jobs_customdata_set(wm_job, scj, solve_camera_freejob);
+       WM_jobs_timer(wm_job, 0.1, NC_MOVIECLIP | NA_EVALUATED, 0);
+       WM_jobs_callbacks(wm_job, solve_camera_startjob, NULL, solve_camera_updatejob, NULL);
 
        G.is_break = FALSE;
 
-       WM_jobs_start(CTX_wm_manager(C), steve);
+       WM_jobs_start(CTX_wm_manager(C), wm_job);
        WM_cursor_wait(0);
 
        /* add modal handler for ESC */
index 83ddead92dcd1c033b13539da3ca69c26e6032a1..eeef6c7908bf662a90fbbf3e0cdfb5e235ec718d 100644 (file)
@@ -1346,7 +1346,7 @@ static void thumbnails_free(void *tjv)
 
 void thumbnails_start(struct FileList *filelist, const struct bContext *C)
 {
-       wmJob *steve;
+       wmJob *wm_job;
        ThumbnailJob *tj;
        int idx;
        
@@ -1368,14 +1368,14 @@ void thumbnails_start(struct FileList *filelist, const struct bContext *C)
        BKE_reports_init(&tj->reports, RPT_PRINT);
 
        /* setup job */
-       steve = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), filelist, "Thumbnails",
-                           0, WM_JOB_TYPE_FILESEL_THUMBNAIL);
-       WM_jobs_customdata_set(steve, tj, thumbnails_free);
-       WM_jobs_timer(steve, 0.5, NC_WINDOW, NC_WINDOW);
-       WM_jobs_callbacks(steve, thumbnails_startjob, NULL, thumbnails_update, NULL);
+       wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), filelist, "Thumbnails",
+                            0, WM_JOB_TYPE_FILESEL_THUMBNAIL);
+       WM_jobs_customdata_set(wm_job, tj, thumbnails_free);
+       WM_jobs_timer(wm_job, 0.5, NC_WINDOW, NC_WINDOW);
+       WM_jobs_callbacks(wm_job, thumbnails_startjob, NULL, thumbnails_update, NULL);
 
        /* start the job */
-       WM_jobs_start(CTX_wm_manager(C), steve);
+       WM_jobs_start(CTX_wm_manager(C), wm_job);
 }
 
 void thumbnails_stop(struct FileList *filelist, const struct bContext *C)
index 6ef466ba1c342f04eab1f9ee0a727dc2440ca6b9..d34c5f16afaae2f17d427bd546b74cc8aabcf671 100644 (file)
@@ -173,7 +173,7 @@ static void compo_startjob(void *cjv, short *stop, short *do_update, float *prog
  */
 void ED_node_composite_job(const bContext *C, struct bNodeTree *nodetree, Scene *scene_owner)
 {
-       wmJob *steve;
+       wmJob *wm_job;
        CompoJob *cj;
 
        /* to fix bug: [#32272] */
@@ -181,8 +181,8 @@ void ED_node_composite_job(const bContext *C, struct bNodeTree *nodetree, Scene
                return;
        }
 
-       steve = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene_owner, "Compositing",
-                           WM_JOB_EXCL_RENDER | WM_JOB_PROGRESS, WM_JOB_TYPE_COMPOSITE);
+       wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), scene_owner, "Compositing",
+                            WM_JOB_EXCL_RENDER | WM_JOB_PROGRESS, WM_JOB_TYPE_COMPOSITE);
        cj = MEM_callocN(sizeof(CompoJob), "compo job");
 
        /* customdata for preview thread */
@@ -190,11 +190,11 @@ void ED_node_composite_job(const bContext *C, struct bNodeTree *nodetree, Scene
        cj->ntree = nodetree;
 
        /* setup job */
-       WM_jobs_customdata_set(steve, cj, compo_freejob);
-       WM_jobs_timer(steve, 0.1, NC_SCENE, NC_SCENE | ND_COMPO_RESULT);
-       WM_jobs_callbacks(steve, compo_startjob, compo_initjob, compo_updatejob, NULL);
+       WM_jobs_customdata_set(wm_job, cj, compo_freejob);
+       WM_jobs_timer(wm_job, 0.1, NC_SCENE, NC_SCENE | ND_COMPO_RESULT);
+       WM_jobs_callbacks(wm_job, compo_startjob, compo_initjob, compo_updatejob, NULL);
 
-       WM_jobs_start(CTX_wm_manager(C), steve);
+       WM_jobs_start(CTX_wm_manager(C), wm_job);
 }
 
 /* ***************************************** */
index 66739f83597ac3d9d329be6a66f8d057524a36f0..5bb3f71013324465389679c75dc5ce72f2eaa731 100644 (file)
@@ -177,7 +177,7 @@ static void proxy_endjob(void *pjv)
 
 static void seq_proxy_build_job(const bContext *C)
 {
-       wmJob *steve;
+       wmJob *wm_job;
        ProxyJob *pj;
        Scene *scene = CTX_data_scene(C);
        Editing *ed = BKE_sequencer_editing_get(scene, FALSE);
@@ -186,10 +186,10 @@ static void seq_proxy_build_job(const bContext *C)
        LinkData *link;
        Sequence *seq;
 
-       steve = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), sa, "Building Proxies",
-                           WM_JOB_PROGRESS, WM_JOB_TYPE_SEQ_BUILD_PROXY);
+       wm_job = WM_jobs_get(CTX_wm_manager(C), CTX_wm_window(C), sa, "Building Proxies",
+                            WM_JOB_PROGRESS, WM_JOB_TYPE_SEQ_BUILD_PROXY);
 
-       pj = WM_jobs_customdata_get(steve);
+       pj = WM_jobs_customdata_get(wm_job);
 
        if (!pj) {
                pj = MEM_callocN(sizeof(ProxyJob), "proxy rebuild job");
@@ -197,9 +197,9 @@ static void seq_proxy_build_job(const bContext *C)
                pj->scene = scene;
                pj->main = CTX_data_main(C);
 
-               WM_jobs_customdata_set(steve, pj, proxy_freejob);
-               WM_jobs_timer(steve, 0.1, NC_SCENE | ND_SEQUENCER, NC_SCENE | ND_SEQUENCER);
-               WM_jobs_callbacks(steve, proxy_startjob, NULL, NULL, proxy_endjob);
+               WM_jobs_customdata_set(wm_job, pj, proxy_freejob);
+               WM_jobs_timer(wm_job, 0.1, NC_SCENE | ND_SEQUENCER, NC_SCENE | ND_SEQUENCER);
+               WM_jobs_callbacks(wm_job, proxy_startjob, NULL, NULL, proxy_endjob);
        }
 
        SEQP_BEGIN (ed, seq)
@@ -212,9 +212,9 @@ static void seq_proxy_build_job(const bContext *C)
        }
        SEQ_END
 
-       if (!WM_jobs_is_running(steve)) {
+       if (!WM_jobs_is_running(wm_job)) {
                G.is_break = FALSE;
-               WM_jobs_start(CTX_wm_manager(C), steve);
+               WM_jobs_start(CTX_wm_manager(C), wm_job);
        }
 
        ED_area_tag_redraw(CTX_wm_area(C));
index 27507640bdcb3f1c7054295df103bf823f8b9276..588be336afaf97928bdb61702fb2d4ddd93f5dc3 100644 (file)
@@ -316,6 +316,7 @@ enum {
        WM_JOB_TYPE_RENDER_PREVIEW,  /* UI preview */
        WM_JOB_TYPE_SCREENCAST,
        WM_JOB_TYPE_OBJECT_SIM_OCEAN,
+       WM_JOB_TYPE_OBJECT_SIM_FLUID,
        WM_JOB_TYPE_OBJECT_BAKE_TEXTURE,
        WM_JOB_TYPE_FILESEL_THUMBNAIL,
        WM_JOB_TYPE_CLIP_BUILD_PROXY,
index feca042d2a667234c44d64bb796db5b13b671ad1..c9fe561e6b0dabff119f9fd85c4bd0315bc80280 100644 (file)
@@ -136,13 +136,13 @@ struct wmJob {
  */
 static wmJob *wm_job_find(wmWindowManager *wm, void *owner, const char *name)
 {
-       wmJob *steve, *found = NULL;
+       wmJob *wm_job, *found = NULL;
        
-       for (steve = wm->jobs.first; steve; steve = steve->next)
-               if (steve->owner == owner) {
-                       found = steve;
-                       if (name && strcmp(steve->name, name) == 0)
-                               return steve;
+       for (wm_job = wm->jobs.first; wm_job; wm_job = wm_job->next)
+               if (wm_job->owner == owner) {
+                       found = wm_job;
+                       if (name && strcmp(wm_job->name, name) == 0)
+                               return wm_job;
                }
        
        return found;
@@ -155,32 +155,32 @@ static wmJob *wm_job_find(wmWindowManager *wm, void *owner, const char *name)
  * when stopped it starts the new one */
 wmJob *WM_jobs_get(wmWindowManager *wm, wmWindow *win, void *owner, const char *name, int flag, int job_type)
 {
-       wmJob *steve = wm_job_find(wm, owner, name);
+       wmJob *wm_job = wm_job_find(wm, owner, name);
        
-       if (steve == NULL) {
-               steve = MEM_callocN(sizeof(wmJob), "new job");
+       if (wm_job == NULL) {
+               wm_job = MEM_callocN(sizeof(wmJob), "new job");
        
-               BLI_addtail(&wm->jobs, steve);
-               steve->win = win;
-               steve->owner = owner;
-               steve->flag = flag;
-               steve->job_type = job_type;
-               BLI_strncpy(steve->name, name, sizeof(steve->name));
+               BLI_addtail(&wm->jobs, wm_job);
+               wm_job->win = win;
+               wm_job->owner = owner;
+               wm_job->flag = flag;
+               wm_job->job_type = job_type;
+               BLI_strncpy(wm_job->name, name, sizeof(wm_job->name));
        }
        
-       return steve;
+       return wm_job;
 }
 
 /* returns true if job runs, for UI (progress) indicators */
 int WM_jobs_test(wmWindowManager *wm, void *owner, int job_type)
 {
-       wmJob *steve;
+       wmJob *wm_job;
        
        /* job can be running or about to run (suspended) */
-       for (steve = wm->jobs.first; steve; steve = steve->next) {
-               if (steve->owner == owner) {
-                       if (job_type == WM_JOB_TYPE_ANY || (steve->job_type == job_type)) {
-                               if (steve->running || steve->suspended) {
+       for (wm_job = wm->jobs.first; wm_job; wm_job = wm_job->next) {
+               if (wm_job->owner == owner) {
+                       if (job_type == WM_JOB_TYPE_ANY || (wm_job->job_type == job_type)) {
+                               if (wm_job->running || wm_job->suspended) {
                                        return TRUE;
                                }
                        }
@@ -192,79 +192,79 @@ int WM_jobs_test(wmWindowManager *wm, void *owner, int job_type)
 
 float WM_jobs_progress(wmWindowManager *wm, void *owner)
 {
-       wmJob *steve = wm_job_find(wm, owner, NULL);
+       wmJob *wm_job = wm_job_find(wm, owner, NULL);
        
-       if (steve && steve->flag & WM_JOB_PROGRESS)
-               return steve->progress;
+       if (wm_job && wm_job->flag & WM_JOB_PROGRESS)
+               return wm_job->progress;
        
        return 0.0;
 }
 
 char *WM_jobs_name(wmWindowManager *wm, void *owner)
 {
-       wmJob *steve = wm_job_find(wm, owner, NULL);
+       wmJob *wm_job = wm_job_find(wm, owner, NULL);
        
-       if (steve)
-               return steve->name;
+       if (wm_job)
+               return wm_job->name;
        
        return NULL;
 }
 
-int WM_jobs_is_running(wmJob *steve)
+int WM_jobs_is_running(wmJob *wm_job)
 {
-       return steve->running;
+       return wm_job->running;
 }
 
-void *WM_jobs_customdata_get(wmJob *steve)
+void *WM_jobs_customdata_get(wmJob *wm_job)
 {
-       if (!steve->customdata) {
-               return steve->run_customdata;
+       if (!wm_job->customdata) {
+               return wm_job->run_customdata;
        }
        else {
-               return steve->customdata;
+               return wm_job->customdata;
        }
 }
 
-void WM_jobs_customdata_set(wmJob *steve, void *customdata, void (*free)(void *))
+void WM_jobs_customdata_set(wmJob *wm_job, void *customdata, void (*free)(void *))
 {
        /* pending job? just free */
-       if (steve->customdata)
-               steve->free(steve->customdata);
+       if (wm_job->customdata)
+               wm_job->free(wm_job->customdata);
        
-       steve->customdata = customdata;
-       steve->free = free;
+       wm_job->customdata = customdata;
+       wm_job->free = free;
 
-       if (steve->running) {
+       if (wm_job->running) {
                /* signal job to end */
-               steve->stop = 1;
+               wm_job->stop = 1;
        }
 }
 
-void WM_jobs_timer(wmJob *steve, double timestep, unsigned int note, unsigned int endnote)
+void WM_jobs_timer(wmJob *wm_job, double timestep, unsigned int note, unsigned int endnote)
 {
-       steve->timestep = timestep;
-       steve->note = note;
-       steve->endnote = endnote;
+       wm_job->timestep = timestep;
+       wm_job->note = note;
+       wm_job->endnote = endnote;
 }
 
-void WM_jobs_callbacks(wmJob *steve, 
+void WM_jobs_callbacks(wmJob *wm_job,
                        void (*startjob)(void *, short *, short *, float *),
                        void (*initjob)(void *),
                        void (*update)(void *),
                        void (*endjob)(void *))
 {
-       steve->startjob = startjob;
-       steve->initjob = initjob;
-       steve->update = update;
-       steve->endjob = endjob;
+       wm_job->startjob = startjob;
+       wm_job->initjob = initjob;
+       wm_job->update = update;
+       wm_job->endjob = endjob;
 }
 
 static void *do_job_thread(void *job_v)
 {
-       wmJob *steve = job_v;
+       wmJob *wm_job = job_v;
        
-       steve->startjob(steve->run_customdata, &steve->stop, &steve->do_update, &steve->progress);
-       steve->ready = 1;
+       wm_job->startjob(wm_job->run_customdata, &wm_job->stop, &wm_job->do_update, &wm_job->progress);
+       wm_job->ready = 1;
        
        return NULL;
 }
@@ -272,7 +272,7 @@ static void *do_job_thread(void *job_v)
 /* don't allow same startjob to be executed twice */
 static void wm_jobs_test_suspend_stop(wmWindowManager *wm, wmJob *test)
 {
-       wmJob *steve;
+       wmJob *wm_job;
        int suspend = 0;
        
        /* job added with suspend flag, we wait 1 timer step before activating it */
@@ -282,26 +282,26 @@ static void wm_jobs_test_suspend_stop(wmWindowManager *wm, wmJob *test)
        }
        else {
                /* check other jobs */
-               for (steve = wm->jobs.first; steve; steve = steve->next) {
+               for (wm_job = wm->jobs.first; wm_job; wm_job = wm_job->next) {
                        /* obvious case, no test needed */
-                       if (steve == test || !steve->running) continue;
+                       if (wm_job == test || !wm_job->running) continue;
                        
                        /* if new job is not render, then check for same startjob */
                        if (0 == (test->flag & WM_JOB_EXCL_RENDER))
-                               if (steve->startjob != test->startjob)
+                               if (wm_job->startjob != test->startjob)
                                        continue;
                        
                        /* if new job is render, any render job should be stopped */
                        if (test->flag & WM_JOB_EXCL_RENDER)
-                               if (0 == (steve->flag & WM_JOB_EXCL_RENDER))
+                               if (0 == (wm_job->flag & WM_JOB_EXCL_RENDER))
                                        continue;
 
                        suspend = 1;
 
                        /* if this job has higher priority, stop others */
                        if (test->flag & WM_JOB_PRIORITY) {
-                               steve->stop = 1;
-                               // printf("job stopped: %s\n", steve->name);
+                               wm_job->stop = 1;
+                               // printf("job stopped: %s\n", wm_job->name);
                        }
                }
        }
@@ -313,110 +313,113 @@ static void wm_jobs_test_suspend_stop(wmWindowManager *wm, wmJob *test)
 
 /* if job running, the same owner gave it a new job */
 /* if different owner starts existing startjob, it suspends itself */
-void WM_jobs_start(wmWindowManager *wm, wmJob *steve)
+void WM_jobs_start(wmWindowManager *wm, wmJob *wm_job)
 {
-       if (steve->running) {
+       if (wm_job->running) {
                /* signal job to end and restart */
-               steve->stop = 1;
-               // printf("job started a running job, ending... %s\n", steve->name);
+               wm_job->stop = 1;
+               // printf("job started a running job, ending... %s\n", wm_job->name);
        }
        else {
                
-               if (steve->customdata && steve->startjob) {
+               if (wm_job->customdata && wm_job->startjob) {
                        
-                       wm_jobs_test_suspend_stop(wm, steve);
+                       wm_jobs_test_suspend_stop(wm, wm_job);
                        
-                       if (steve->suspended == 0) {
+                       if (wm_job->suspended == 0) {
                                /* copy to ensure proper free in end */
-                               steve->run_customdata = steve->customdata;
-                               steve->run_free = steve->free;
-                               steve->free = NULL;
-                               steve->customdata = NULL;
-                               steve->running = 1;
+                               wm_job->run_customdata = wm_job->customdata;
+                               wm_job->run_free = wm_job->free;
+                               wm_job->free = NULL;
+                               wm_job->customdata = NULL;
+                               wm_job->running = 1;
                                
-                               if (steve->initjob)
-                                       steve->initjob(steve->run_customdata);
+                               if (wm_job->initjob)
+                                       wm_job->initjob(wm_job->run_customdata);
                                
-                               steve->stop = 0;
-                               steve->ready = 0;
-                               steve->progress = 0.0;
+                               wm_job->stop = 0;
+                               wm_job->ready = 0;
+                               wm_job->progress = 0.0;
 
-                               // printf("job started: %s\n", steve->name);
+                               // printf("job started: %s\n", wm_job->name);
                                
-                               BLI_init_threads(&steve->threads, do_job_thread, 1);
-                               BLI_insert_thread(&steve->threads, steve);
+                               BLI_init_threads(&wm_job->threads, do_job_thread, 1);
+                               BLI_insert_thread(&wm_job->threads, wm_job);
                        }
                        
                        /* restarted job has timer already */
-                       if (steve->wt == NULL)
-                               steve->wt = WM_event_add_timer(wm, steve->win, TIMERJOBS, steve->timestep);
+                       if (wm_job->wt == NULL)
+                               wm_job->wt = WM_event_add_timer(wm, wm_job->win, TIMERJOBS, wm_job->timestep);
 
                        if (G.debug & G_DEBUG_JOBS)
-                               steve->start_time = PIL_check_seconds_timer();
+                               wm_job->start_time = PIL_check_seconds_timer();
                }
                else printf("job fails, not initialized\n");
        }
 }
 
 /* stop job, free data completely */
-static void wm_jobs_kill_job(wmWindowManager *wm, wmJob *steve)
+static void wm_jobs_kill_job(wmWindowManager *wm, wmJob *wm_job)
 {
-       if (steve->running) {
+       if (wm_job->running) {
                /* signal job to end */
-               steve->stop = 1;
-               BLI_end_threads(&steve->threads);
+               wm_job->stop = 1;
+               BLI_end_threads(&wm_job->threads);
 
-               if (steve->endjob)
-                       steve->endjob(steve->run_customdata);
+               if (wm_job->endjob)
+                       wm_job->endjob(wm_job->run_customdata);
        }
        
-       if (steve->wt)
-               WM_event_remove_timer(wm, steve->win, steve->wt);
-       if (steve->customdata)
-               steve->free(steve->customdata);
-       if (steve->run_customdata)
-               steve->run_free(steve->run_customdata);
+       if (wm_job->wt)
+               WM_event_remove_timer(wm, wm_job->win, wm_job->wt);
+       if (wm_job->customdata)
+               wm_job->free(wm_job->customdata);
+       if (wm_job->run_customdata)
+               wm_job->run_free(wm_job->run_customdata);
        
-       /* remove steve */
-       BLI_remlink(&wm->jobs, steve);
-       MEM_freeN(steve);
+       /* remove wm_job */
+       BLI_remlink(&wm->jobs, wm_job);
+       MEM_freeN(wm_job);
        
 }
 
 void WM_jobs_stop_all(wmWindowManager *wm)
 {
-       wmJob *steve;
+       wmJob *wm_job;
        
-       while ((steve = wm->jobs.first))
-               wm_jobs_kill_job(wm, steve);
+       while ((wm_job = wm->jobs.first))
+               wm_jobs_kill_job(wm, wm_job);
        
 }
 
 /* signal job(s) from this owner or callback to stop, timer is required to get handled */
 void WM_jobs_stop(wmWindowManager *wm, void *owner, void *startjob)
 {
-       wmJob *steve;
+       wmJob *wm_job;
        
-       for (steve = wm->jobs.first; steve; steve = steve->next)
-               if (steve->owner == owner || steve->startjob == startjob)
-                       if (steve->running)
-                               steve->stop = 1;
+       for (wm_job = wm->jobs.first; wm_job; wm_job = wm_job->next) {
+               if (wm_job->owner == owner || wm_job->startjob == startjob) {
+                       if (wm_job->running) {
+                               wm_job->stop = 1;
+                       }
+               }
+       }
 }
 
 /* actually terminate thread and job timer */
 void WM_jobs_kill(wmWindowManager *wm, void *owner, void (*startjob)(void *, short int *, short int *, float *))
 {
-       wmJob *steve;
+       wmJob *wm_job;
        
-       steve = wm->jobs.first;
-       while (steve) {
-               if (steve->owner == owner || steve->startjob == startjob) {
-                       wmJob *bill = steve;
-                       steve = steve->next;
+       wm_job = wm->jobs.first;
+       while (wm_job) {
+               if (wm_job->owner == owner || wm_job->startjob == startjob) {
+                       wmJob *bill = wm_job;
+                       wm_job = wm_job->next;
                        wm_jobs_kill_job(wm, bill);
                }
                else {
-                       steve = steve->next;
+                       wm_job = wm_job->next;
                }
        }
 }
@@ -425,11 +428,11 @@ void WM_jobs_kill(wmWindowManager *wm, void *owner, void (*startjob)(void *, sho
 /* kill job entirely, also removes timer itself */
 void wm_jobs_timer_ended(wmWindowManager *wm, wmTimer *wt)
 {
-       wmJob *steve;
+       wmJob *wm_job;
        
-       for (steve = wm->jobs.first; steve; steve = steve->next) {
-               if (steve->wt == wt) {
-                       wm_jobs_kill_job(wm, steve);
+       for (wm_job = wm->jobs.first; wm_job; wm_job = wm_job->next) {
+               if (wm_job->wt == wt) {
+                       wm_jobs_kill_job(wm, wm_job);
                        return;
                }
        }
@@ -438,85 +441,85 @@ void wm_jobs_timer_ended(wmWindowManager *wm, wmTimer *wt)
 /* hardcoded to event TIMERJOBS */
 void wm_jobs_timer(const bContext *C, wmWindowManager *wm, wmTimer *wt)
 {
-       wmJob *steve = wm->jobs.first, *stevenext;
+       wmJob *wm_job, *wm_jobnext;
        float total_progress = 0.f;
        float jobs_progress = 0;
        
        
-       for (; steve; steve = stevenext) {
-               stevenext = steve->next;
+       for (wm_job = wm->jobs.first; wm_job; wm_job = wm_jobnext) {
+               wm_jobnext = wm_job->next;
                
-               if (steve->wt == wt) {
+               if (wm_job->wt == wt) {
                        
                        /* running threads */
-                       if (steve->threads.first) {
+                       if (wm_job->threads.first) {
                                
                                /* always call note and update when ready */
-                               if (steve->do_update || steve->ready) {
-                                       if (steve->update)
-                                               steve->update(steve->run_customdata);
-                                       if (steve->note)
-                                               WM_event_add_notifier(C, steve->note, NULL);
+                               if (wm_job->do_update || wm_job->ready) {
+                                       if (wm_job->update)
+                                               wm_job->update(wm_job->run_customdata);
+                                       if (wm_job->note)
+                                               WM_event_add_notifier(C, wm_job->note, NULL);
 
-                                       if (steve->flag & WM_JOB_PROGRESS)
+                                       if (wm_job->flag & WM_JOB_PROGRESS)
                                                WM_event_add_notifier(C, NC_WM | ND_JOB, NULL);
-                                       steve->do_update = FALSE;
+                                       wm_job->do_update = FALSE;
                                }       
                                
-                               if (steve->ready) {
-                                       if (steve->endjob)
-                                               steve->endjob(steve->run_customdata);
+                               if (wm_job->ready) {
+                                       if (wm_job->endjob)
+                                               wm_job->endjob(wm_job->run_customdata);
 
                                        /* free own data */
-                                       steve->run_free(steve->run_customdata);
-                                       steve->run_customdata = NULL;
-                                       steve->run_free = NULL;
+                                       wm_job->run_free(wm_job->run_customdata);
+                                       wm_job->run_customdata = NULL;
+                                       wm_job->run_free = NULL;
                                        
-                                       // if (steve->stop) printf("job ready but stopped %s\n", steve->name);
-                                       // else printf("job finished %s\n", steve->name);
+                                       // if (wm_job->stop) printf("job ready but stopped %s\n", wm_job->name);
+                                       // else printf("job finished %s\n", wm_job->name);
 
                                        if (G.debug & G_DEBUG_JOBS) {
-                                               printf("Job '%s' finished in %f seconds\n", steve->name,
-                                                      PIL_check_seconds_timer() - steve->start_time);
+                                               printf("Job '%s' finished in %f seconds\n", wm_job->name,
+                                                      PIL_check_seconds_timer() - wm_job->start_time);
                                        }
 
-                                       steve->running = 0;
-                                       BLI_end_threads(&steve->threads);
+                                       wm_job->running = 0;
+                                       BLI_end_threads(&wm_job->threads);
                                        
-                                       if (steve->endnote)
-                                               WM_event_add_notifier(C, steve->endnote, NULL);
+                                       if (wm_job->endnote)
+                                               WM_event_add_notifier(C, wm_job->endnote, NULL);
                                        
                                        WM_event_add_notifier(C, NC_WM | ND_JOB, NULL);
                                        
-                                       /* new job added for steve? */
-                                       if (steve->customdata) {
-                                               // printf("job restarted with new data %s\n", steve->name);
-                                               WM_jobs_start(wm, steve);
+                                       /* new job added for wm_job? */
+                                       if (wm_job->customdata) {
+                                               // printf("job restarted with new data %s\n", wm_job->name);
+                                               WM_jobs_start(wm, wm_job);
                                        }
                                        else {
-                                               WM_event_remove_timer(wm, steve->win, steve->wt);
-                                               steve->wt = NULL;
+                                               WM_event_remove_timer(wm, wm_job->win, wm_job->wt);
+                                               wm_job->wt = NULL;
                                                
-                                               /* remove steve */
-                                               BLI_remlink(&wm->jobs, steve);
-                                               MEM_freeN(steve);
+                                               /* remove wm_job */
+                                               BLI_remlink(&wm->jobs, wm_job);
+                                               MEM_freeN(wm_job);
                                        }
                                }
-                               else if (steve->flag & WM_JOB_PROGRESS) {
+                               else if (wm_job->flag & WM_JOB_PROGRESS) {
                                        /* accumulate global progress for running jobs */
                                        jobs_progress++;
-                                       total_progress += steve->progress;
+                                       total_progress += wm_job->progress;
                                }
                        }
-                       else if (steve->suspended) {
-                               WM_jobs_start(wm, steve);
+                       else if (wm_job->suspended) {
+                               WM_jobs_start(wm, wm_job);
                        }
                }
-               else if (steve->threads.first && !steve->ready) {
-                       if (steve->flag & WM_JOB_PROGRESS) {
+               else if (wm_job->threads.first && !wm_job->ready) {
+                       if (wm_job->flag & WM_JOB_PROGRESS) {
                                /* accumulate global progress for running jobs */
                                jobs_progress++;
-                               total_progress += steve->progress;
+                               total_progress += wm_job->progress;
                        }
                }
        }
@@ -536,11 +539,13 @@ void wm_jobs_timer(const bContext *C, wmWindowManager *wm, wmTimer *wt)
 
 int WM_jobs_has_running(wmWindowManager *wm)
 {
-       wmJob *steve;
+       wmJob *wm_job;
 
-       for (steve = wm->jobs.first; steve; steve = steve->next)
-               if (steve->running)
+       for (wm_job = wm->jobs.first; wm_job; wm_job = wm_job->next) {
+               if (wm_job->running) {
                        return 1;
+               }
+       }
 
        return 0;
 }