Added my "Copyright (c) 2007" notices, for files I edited in 2007.

[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 3651b75..ca7de13 100644 (file)
--- a/synfig-studio/trunk/src/gtkmm/asyncrenderer.cpp
+++ b/synfig-studio/trunk/src/gtkmm/asyncrenderer.cpp
@@ -6,6 +6,7 @@
 **
 **     \legal
 **     Copyright (c) 2002-2005 Robert B. Quattlebaum Jr., Adrian Bentley
+**     Copyright (c) 2007 Chris Moore
 **
 **     This package is free software; you can redistribute it and/or
 **     modify it under the terms of the GNU General Public License as
@@ -53,6 +54,8 @@
 #include <synfig/general.h>
 #include <ETL/clock>
 
+#include "general.h"
+
 #endif
 
 /* === U S I N G =========================================================== */
@@ -88,9 +91,7 @@ public:
                }
        };
        std::list<tile_t> tile_queue;
-#ifndef SINGLE_THREADED
        Glib::Mutex mutex;
-#endif // SINGLE_THREADED
 
 #ifndef GLIB_DISPATCHER_BROKEN
        Glib::Dispatcher tile_ready_signal;
@@ -125,9 +126,7 @@ public:
        }
        void set_dead()
        {
-#ifndef SINGLE_THREADED
                Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
                alive_flag=false;
        }
 
@@ -163,9 +162,7 @@ public:
                assert(surface);
                if(!alive_flag)
                        return false;
-#ifndef SINGLE_THREADED
                Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
                tile_queue.push_back(tile_t(surface,gx,gy));
                if(tile_queue.size()==1)
                {
@@ -187,9 +184,7 @@ public:
 
        void tile_ready()
        {
-#ifndef SINGLE_THREADED
                Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
                if(!alive_flag)
                {
                        tile_queue.clear();
@@ -200,6 +195,13 @@ public:
                {
                        tile_t& tile(tile_queue.front());
 
+                       if (getenv("SYNFIG_SHOW_TILE_OUTLINES"))
+                       {
+                               Color red(1,0,0);
+                               tile.surface.fill(red, 0, 0, 1, tile.surface.get_h());
+                               tile.surface.fill(red, 0, 0, tile.surface.get_w(), 1);
+                       }
+
                        alive_flag=warm_target->add_tile(tile.surface,tile.x,tile.y);
 
                        tile_queue.pop_front();
@@ -209,20 +211,21 @@ public:
 
        virtual void end_frame()
        {
-#ifndef SINGLE_THREADED
-               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);
-#endif // SINGLE_THREADED
                if(!alive_flag)
                        return;
                return warm_target->end_frame();
@@ -239,9 +242,7 @@ public:
        int scanline_;
        Surface surface;
 
-#ifndef SINGLE_THREADED
        Glib::Mutex mutex;
-#endif // SINGLE_THREADED
 
 #ifndef GLIB_DISPATCHER_BROKEN
        Glib::Dispatcher frame_ready_signal;
@@ -284,9 +285,7 @@ public:
 
        void set_dead()
        {
-#ifndef SINGLE_THREADED
                Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
                alive_flag=false;
        }
 
@@ -298,9 +297,7 @@ public:
        virtual void end_frame()
        {
                {
-#ifndef SINGLE_THREADED
                        Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
 
                        if(!alive_flag)
                                return;
@@ -317,24 +314,23 @@ public:
 #else
                        frame_ready_signal();
 #endif
-                       }
-
-#ifndef 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;
                }
-#endif // SINGLE_THREADED
+
+               if (single_threaded())
+                       signal_progress()();
+               else
+                       while(alive_flag && !ready_next)
+                       {
+                               Glib::Mutex::Lock lock(mutex);
+                               if(cond_frame_queue_empty.timed_wait(mutex,Glib::TimeVal(0,BOREDOM_TIMEOUT)))
+                                       break;
+                       }
        }
 
 
        virtual Color * start_scanline(int scanline)
        {
-#ifndef SINGLE_THREADED
                Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
 
                return surface[scanline];
        }
@@ -346,12 +342,10 @@ public:
 
        void frame_ready()
        {
-#ifndef SINGLE_THREADED
                Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
                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;
        }
 };
@@ -365,10 +359,8 @@ public:
 AsyncRenderer::AsyncRenderer(etl::handle<synfig::Target> target_,synfig::ProgressCallback *cb):
        error(false),
        success(false),
-       cb(cb)
-#ifdef SINGLE_THREADED
-       , updating(false)
-#endif // SINGLE_THREADED
+       cb(cb),
+       updating(false)
 {
        render_thread=0;
        if(etl::handle<synfig::Target_Tile>::cast_dynamic(target_))
@@ -405,19 +397,15 @@ AsyncRenderer::stop()
 {
        if(target)
        {
-#ifndef SINGLE_THREADED
                Glib::Mutex::Lock lock(mutex);
-#endif // SINGLE_THREADED
                done_connection.disconnect();
 
                if(render_thread)
                {
                        signal_stop_();
 
-#ifndef SINGLE_THREADED
 #if REJOIN_ON_STOP
-                       render_thread->join();
-#endif
+                       if (!single_threaded()) render_thread->join();
 #endif
 
                        // Make sure all the dispatch crap is cleared out
@@ -456,7 +444,6 @@ AsyncRenderer::start()
        );
 }
 
-#ifdef SINGLE_THREADED
 void
 AsyncRenderer::rendering_progress()
 {
@@ -464,7 +451,6 @@ AsyncRenderer::rendering_progress()
        while(studio::App::events_pending()) studio::App::iteration(false);
        updating = false;
 }
-#endif // SINGLE_THREADED
 
 void
 AsyncRenderer::start_()
@@ -476,22 +462,25 @@ AsyncRenderer::start_()
                done_connection=signal_done_.connect(mem_fun(*this,&AsyncRenderer::stop));
 #endif
 
-#ifdef 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 // SINGLE_THREADED
-               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);
-#endif // SINGLE_THREADED
+                               );
+                       assert(render_thread);
+               }
        }
        else
        {
@@ -516,9 +505,7 @@ AsyncRenderer::render_target()
 #endif
        }
 
-#ifndef SINGLE_THREADED
        if(mutex.trylock())
-#endif // SINGLE_THREADED
        {
 #ifdef GLIB_DISPATCHER_BROKEN
                done_connection=Glib::signal_timeout().connect(
@@ -531,8 +518,6 @@ AsyncRenderer::render_target()
 #else
                signal_done_.emit();
 #endif
-#ifndef SINGLE_THREADED
                mutex.unlock();
-#endif // SINGLE_THREADED
        }
 }