Put the mutex code back as it was originally. We can still use it when single threaded.

[synfig.git] / synfig-studio / trunk / src / gtkmm / asyncrenderer.cpp

diff --git a/synfig-studio/trunk/src/gtkmm/asyncrenderer.cpp b/synfig-studio/trunk/src/gtkmm/asyncrenderer.cpp
index 745409c..70051dc 100644 (file)
--- a/synfig-studio/trunk/src/gtkmm/asyncrenderer.cpp
+++ b/synfig-studio/trunk/src/gtkmm/asyncrenderer.cpp
@@ -30,6 +30,7 @@
 #endif
 
 #include "asyncrenderer.h"
+#include "app.h"
 #include <glibmm/thread.h>
 #include <glibmm/dispatcher.h>
 
@@ -200,16 +201,19 @@ public:
 
        virtual void end_frame()
        {
-               while(alive_flag)
+               if (!single_threaded())
                {
-                       Glib::Mutex::Lock lock(mutex);
-                       if(!tile_queue.empty() && alive_flag)
+                       while(alive_flag)
                        {
-                               if(cond_tile_queue_empty.timed_wait(mutex,Glib::TimeVal(0,BOREDOM_TIMEOUT)))
+                               Glib::Mutex::Lock lock(mutex);
+                               if(!tile_queue.empty() && alive_flag)
+                               {
+                                       if(cond_tile_queue_empty.timed_wait(mutex,Glib::TimeVal(0,BOREDOM_TIMEOUT)))
+                                               break;
+                               }
+                               else
                                        break;
                        }
-                       else
-                               break;
                }
                Glib::Mutex::Lock lock(mutex);
                if(!alive_flag)
@@ -275,7 +279,7 @@ public:
                alive_flag=false;
        }
 
-       virtual bool start_frame(synfig::ProgressCallback *cb=0)
+       virtual bool start_frame(synfig::ProgressCallback */*cb*/=0)
        {
                return alive_flag;
        }
@@ -300,14 +304,15 @@ public:
 #else
                        frame_ready_signal();
 #endif
-                       }
-
-               while(alive_flag && !ready_next)
-               {
-                       Glib::Mutex::Lock lock(mutex);
-                       if(cond_frame_queue_empty.timed_wait(mutex,Glib::TimeVal(0,BOREDOM_TIMEOUT)))
-                               break;
                }
+
+               if (!single_threaded())
+                       while(alive_flag && !ready_next)
+                       {
+                               Glib::Mutex::Lock lock(mutex);
+                               if(cond_frame_queue_empty.timed_wait(mutex,Glib::TimeVal(0,BOREDOM_TIMEOUT)))
+                                       break;
+                       }
        }
 
 
@@ -328,7 +333,7 @@ public:
                Glib::Mutex::Lock lock(mutex);
                if(alive_flag)
                        alive_flag=warm_target->add_frame(&surface);
-               cond_frame_queue_empty.signal();
+               if (!single_threaded()) cond_frame_queue_empty.signal();
                ready_next=true;
        }
 };
@@ -342,7 +347,8 @@ public:
 AsyncRenderer::AsyncRenderer(etl::handle<synfig::Target> target_,synfig::ProgressCallback *cb):
        error(false),
        success(false),
-       cb(cb)
+       cb(cb),
+       updating(false)
 {
        render_thread=0;
        if(etl::handle<synfig::Target_Tile>::cast_dynamic(target_))
@@ -387,7 +393,7 @@ AsyncRenderer::stop()
                        signal_stop_();
 
 #if REJOIN_ON_STOP
-                       render_thread->join();
+                       if (!single_threaded()) render_thread->join();
 #endif
 
                        // Make sure all the dispatch crap is cleared out
@@ -427,6 +433,14 @@ AsyncRenderer::start()
 }
 
 void
+AsyncRenderer::rendering_progress()
+{
+       updating = true;
+       while(studio::App::events_pending()) studio::App::iteration(false);
+       updating = false;
+}
+
+void
 AsyncRenderer::start_()
 {
        error=false;success=false;
@@ -436,15 +450,25 @@ AsyncRenderer::start_()
                done_connection=signal_done_.connect(mem_fun(*this,&AsyncRenderer::stop));
 #endif
 
-               render_thread=Glib::Thread::create(
-                       sigc::mem_fun(*this,&AsyncRenderer::render_target),
+               if (single_threaded())
+               {
+                       synfig::info("%s:%d rendering in the same thread", __FILE__, __LINE__);
+                       target->signal_progress().connect(sigc::mem_fun(this,&AsyncRenderer::rendering_progress));
+                       render_thread = (Glib::Thread*)1;
+                       render_target();
+               }
+               else
+               {
+                       render_thread=Glib::Thread::create(
+                               sigc::mem_fun(*this,&AsyncRenderer::render_target),
 #if REJOIN_ON_STOP
-                       true
+                               true
 #else
-                       false
+                               false
 #endif
-               );
-               assert(render_thread);
+                               );
+                       assert(render_thread);
+               }
        }
        else
        {