liz/rawTherapee
liz/rawTherapee
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Progress Dialog "moved" to bottom bar

Browse Source
This commit is contained in:
ffsup2 2010-05-04 23:07:03 +02:00
parent 72bad14a86
commit dee3878de2
8 changed files with 224 additions and 148 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
rtexif/CMakeLists.txt
View File

@ -3,9 +3,9 @@ add_library (rtexif rtexif.cc stdattribs.cc nikonattribs.cc canonattribs.cc
pentaxattribs.cc fujiattribs.cc sonyminoltaattribs.cc olympusattribs.cc) pentaxattribs.cc fujiattribs.cc sonyminoltaattribs.cc olympusattribs.cc)
IF (WIN32) IF (WIN32)
set_target_properties (rtexif PROPERTIES COMPILE_FLAGS "-O3 -ffast-math -fexpensive-optimizations") set_target_properties (rtexif PROPERTIES COMPILE_FLAGS " -ffast-math -fexpensive-optimizations")
ELSE (WIN32) ELSE (WIN32)
set_target_properties (rtexif PROPERTIES COMPILE_FLAGS "-O3 -ffast-math -fexpensive-optimizations -fPIC") set_target_properties (rtexif PROPERTIES COMPILE_FLAGS " -ffast-math -fexpensive-optimizations -fPIC")
ENDIF (WIN32) ENDIF (WIN32)
IF (BUILD_SHARED_LIBS) IF (BUILD_SHARED_LIBS)

191
rtgui/editorpanel.cc
View File

@ -26,7 +26,7 @@
using namespace rtengine::procparams; using namespace rtengine::procparams;
EditorPanel::EditorPanel (Thumbnail* tmb, rtengine::InitialImage* isrc) : parent(NULL), beforeIarea(NULL), beforePreviewHandler(NULL), beforeIpc(NULL) { EditorPanel::EditorPanel () : parent(NULL), beforeIarea(NULL), beforePreviewHandler(NULL), beforeIpc(NULL) {
epih = new EditorPanelIdleHelper; epih = new EditorPanelIdleHelper;
epih->epanel = this; epih->epanel = this;
@ -206,8 +206,6 @@ EditorPanel::EditorPanel (Thumbnail* tmb, rtengine::InitialImage* isrc) : parent
queueimg->signal_pressed().connect( sigc::mem_fun(*this, &EditorPanel::queueImgPressed) ); queueimg->signal_pressed().connect( sigc::mem_fun(*this, &EditorPanel::queueImgPressed) );
sendtogimp->signal_pressed().connect( sigc::mem_fun(*this, &EditorPanel::sendToGimpPressed) ); sendtogimp->signal_pressed().connect( sigc::mem_fun(*this, &EditorPanel::sendToGimpPressed) );
// open image
open (tmb, isrc);
} }
bool EditorPanel::beforeClosing () { bool EditorPanel::beforeClosing () {
@ -255,24 +253,6 @@ void EditorPanel::on_realize () {
vboxright->set_size_request (options.toolPanelWidth, -1); vboxright->set_size_request (options.toolPanelWidth, -1);
} }
rtengine::InitialImage* EditorPanel::loadImage (Thumbnail* tmb) {
// try to load the image
Glib::ustring filename = tmb->getFileName ();
int error;
// InitialImage* isrc = InitialImage::load (filename, tmb->getType()==FT_Raw, error, this);
ProgressDialog<rtengine::InitialImage*>* pdload = new ProgressDialog<rtengine::InitialImage*> (M("PROGRESSDLG_LOADING"));
rtengine::InitialImage* isrc;
pdload->setFunc (sigc::bind(sigc::ptr_fun(&rtengine::InitialImage::load), filename, tmb->getType()==FT_Raw, &error, pdload->getProgressListener()), &isrc);
pdload->start ();
delete pdload;
if (error)
return NULL;
else
return isrc;
}
void EditorPanel::open (Thumbnail* tmb, rtengine::InitialImage* isrc) { void EditorPanel::open (Thumbnail* tmb, rtengine::InitialImage* isrc) {
// initialize everything // initialize everything
@ -528,18 +508,23 @@ void EditorPanel::procParamsChanged (Thumbnail* thm, int whoChangedIt) {
tpc->profileChange (&openThm->getProcParams(), rtengine::EvProfileChangeNotification, M("PROGRESSDLG_PROFILECHANGEDINBROWSER")); tpc->profileChange (&openThm->getProcParams(), rtengine::EvProfileChangeNotification, M("PROGRESSDLG_PROFILECHANGEDINBROWSER"));
} }
rtengine::IImage16* EditorPanel::processImage () { bool EditorPanel::idle_saveImage (ProgressConnector<rtengine::IImage16*> *pc, Glib::ustring fname, SaveFormat sf, bool findNewNameIfNeeded){
rtengine::IImage16* img = pc->returnValue();
delete pc;
if( img )
saveImage( img, fname, sf, findNewNameIfNeeded);
else{
gdk_threads_enter ();
Glib::ustring msg_ = Glib::ustring("<b>") + fname + ": Error during image processing\n</b>";
Gtk::MessageDialog msgd (*parent, msg_, true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
msgd.run ();
gdk_threads_leave ();
rtengine::procparams::ProcParams pparams; saveimgas->set_sensitive(true);
ipc->getParams (&pparams); sendtogimp->set_sensitive(true);
rtengine::ProcessingJob* job = rtengine::ProcessingJob::create (ipc->getInitialImage(), pparams);
int err = 0; }
ProgressDialog<rtengine::IImage16*>* pdproc = new ProgressDialog<rtengine::IImage16*> (M("PROGRESSDLG_PROCESSING")); return false;
rtengine::IImage16* img;
pdproc->setFunc (sigc::bind(sigc::ptr_fun(&rtengine::processImage), job, err, pdproc->getProgressListener()), &img);
pdproc->start ();
delete pdproc;
return img;
} }
BatchQueueEntry* EditorPanel::createBatchQueueEntry () { BatchQueueEntry* EditorPanel::createBatchQueueEntry () {
@ -565,22 +550,43 @@ int EditorPanel::saveImage (rtengine::IImage16* img, Glib::ustring& fname, SaveF
if (tries==1000) if (tries==1000)
return -1000; return -1000;
} }
ProgressConnector<int> *ld = new ProgressConnector<int>();
ProgressDialog<int>* pdsave = new ProgressDialog<int> (M("PROGRESSDLG_SAVING")); img->setSaveProgressListener (parent->getProgressListener());
img->setSaveProgressListener (pdsave->getProgressListener());
int err;
if (sf.format=="tif") if (sf.format=="tif")
pdsave->setFunc (sigc::bind(sigc::mem_fun(img, &rtengine::IImage16::saveAsTIFF), fileName, sf.tiffBits), &err); ld->startFunc (sigc::bind(sigc::mem_fun(img, &rtengine::IImage16::saveAsTIFF), fileName, sf.tiffBits),
sigc::bind(sigc::mem_fun(*this,&EditorPanel::idle_imageSaved), ld, img, fileName,sf));
else if (sf.format=="png") else if (sf.format=="png")
pdsave->setFunc (sigc::bind(sigc::mem_fun(img, &rtengine::IImage16::saveAsPNG), fileName, sf.pngCompression, sf.pngBits), &err); ld->startFunc (sigc::bind(sigc::mem_fun(img, &rtengine::IImage16::saveAsPNG), fileName, sf.pngCompression, sf.pngBits),
sigc::bind(sigc::mem_fun(*this,&EditorPanel::idle_imageSaved), ld, img, fileName,sf));
else if (sf.format=="jpg") else if (sf.format=="jpg")
pdsave->setFunc (sigc::bind(sigc::mem_fun(img, &rtengine::IImage16::saveAsJPEG), fileName, sf.jpegQuality), &err); ld->startFunc (sigc::bind(sigc::mem_fun(img, &rtengine::IImage16::saveAsJPEG), fileName, sf.jpegQuality),
pdsave->start (); sigc::bind(sigc::mem_fun(*this,&EditorPanel::idle_imageSaved), ld, img, fileName,sf));
delete pdsave; return 0;
}
fname = fileName;
return err; bool EditorPanel::idle_imageSaved(ProgressConnector<int> *pc,rtengine::IImage16* img,Glib::ustring fname, SaveFormat sf){
img->free ();
if (! pc->returnValue() ) {
openThm->imageDeveloped ();
// save processing parameters, if needed
if (sf.saveParams) {
rtengine::procparams::ProcParams pparams;
ipc->getParams (&pparams);
pparams.save (removeExtension (fname) + ".out.pp2");
}
}else{
gdk_threads_enter ();
Glib::ustring msg_ = Glib::ustring("<b>") + fname + ": Error during image saving\n</b>";
Gtk::MessageDialog msgd (*parent, msg_, true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
msgd.run ();
gdk_threads_leave ();
}
saveimgas->set_sensitive(true);
sendtogimp->set_sensitive(true);
parent->setProgressStr("");
parent->setProgress(0.);
delete pc;
return false;
} }
void EditorPanel::saveAsPressed () { void EditorPanel::saveAsPressed () {
@ -610,27 +616,15 @@ void EditorPanel::saveAsPressed () {
return; return;
} }
// save image // save image
rtengine::IImage16* img = processImage (); rtengine::procparams::ProcParams pparams;
int err = 0; ipc->getParams (&pparams);
if (img) { rtengine::ProcessingJob* job = rtengine::ProcessingJob::create (ipc->getInitialImage(), pparams);
fname = removeExtension (fname); fname = removeExtension (fname);
err = saveImage (img, fname, sf, false); ProgressConnector<rtengine::IImage16*> *ld = new ProgressConnector<rtengine::IImage16*>();
img->free (); ld->startFunc(sigc::bind(sigc::ptr_fun(&rtengine::processImage), job, err, parent->getProgressListener() ),
if (!err) { sigc::bind(sigc::mem_fun( *this,&EditorPanel::idle_saveImage ),ld,fname,sf,false ));
openThm->imageDeveloped (); saveimgas->set_sensitive(false);
// save processing parameters, if needed sendtogimp->set_sensitive(false);
if (sf.saveParams) {
rtengine::procparams::ProcParams pparams;
ipc->getParams (&pparams);
pparams.save (removeExtension (fname) + ".out.pp2");
}
}
}
if (!img || err) {
Glib::ustring msg_ = Glib::ustring("<b>") + fname + ": " + M("MAIN_MSG_ERRORDURINGIMAGESAVING") + "\n</b>";
Gtk::MessageDialog msgd (*parent, msg_, true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
msgd.run ();
}
} }
else { else {
BatchQueueEntry* bqe = createBatchQueueEntry (); BatchQueueEntry* bqe = createBatchQueueEntry ();
@ -649,21 +643,68 @@ void EditorPanel::queueImgPressed () {
} }
void EditorPanel::sendToGimpPressed () { void EditorPanel::sendToGimpPressed () {
// develop image // develop image
rtengine::IImage16* img = processImage (); rtengine::procparams::ProcParams pparams;
ipc->getParams (&pparams);
rtengine::ProcessingJob* job = rtengine::ProcessingJob::create (ipc->getInitialImage(), pparams);
ProgressConnector<rtengine::IImage16*> *ld = new ProgressConnector<rtengine::IImage16*>();
ld->startFunc(sigc::bind(sigc::ptr_fun(&rtengine::processImage), job, err, parent->getProgressListener() ),
sigc::bind(sigc::mem_fun( *this,&EditorPanel::idle_sendToGimp ),ld ));
saveimgas->set_sensitive(false);
sendtogimp->set_sensitive(false);
}
bool EditorPanel::idle_sendToGimp( ProgressConnector<rtengine::IImage16*> *pc){
rtengine::IImage16* img = pc->returnValue();
delete pc;
if (img) { if (img) {
// get file name base // get file name base
Glib::ustring shortname = removeExtension (Glib::path_get_basename (openThm->getFileName())); Glib::ustring shortname = removeExtension (Glib::path_get_basename (openThm->getFileName()));
Glib::ustring dirname = Glib::get_tmp_dir (); Glib::ustring dirname = Glib::get_tmp_dir ();
Glib::ustring filename = Glib::build_filename (dirname, shortname); Glib::ustring fname = Glib::build_filename (dirname, shortname);
SaveFormat sf; SaveFormat sf;
sf.format = "tif"; sf.format = "tif";
sf.tiffBits = 16; sf.tiffBits = 16;
int err = saveImage (img, filename, sf, true);
img->free (); Glib::ustring fileName = Glib::ustring::compose ("%1.%2", fname, sf.format);
if (!err) {
int tries = 1;
while (Glib::file_test (fileName, Glib::FILE_TEST_EXISTS) && tries<1000) {
fileName = Glib::ustring::compose("%1-%2.%3", fname, tries, sf.format);
tries++;
}
if (tries==1000){
img->free ();
return false;
}
ProgressConnector<int> *ld = new ProgressConnector<int>();
img->setSaveProgressListener (parent->getProgressListener());
ld->startFunc (sigc::bind(sigc::mem_fun(img, &rtengine::IImage16::saveAsTIFF), fileName, sf.tiffBits),
sigc::bind(sigc::mem_fun(*this,&EditorPanel::idle_sentToGimp), ld, img, fileName));
}else{
gdk_threads_enter();
Glib::ustring msg_ = Glib::ustring("<b> Error during image processing\n</b>");
Gtk::MessageDialog msgd (*parent, msg_, true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
msgd.run ();
gdk_threads_leave ();
saveimgas->set_sensitive(true);
sendtogimp->set_sensitive(true);
}
return false;
}
bool EditorPanel::idle_sentToGimp(ProgressConnector<int> *pc,rtengine::IImage16* img,Glib::ustring filename){
img->free ();
int errore = pc->returnValue();
delete pc;
if (!errore) {
saveimgas->set_sensitive(true);
sendtogimp->set_sensitive(true);
parent->setProgressStr("");
parent->setProgress(0.);
bool success=false; bool success=false;
Glib::ustring cmdLine; Glib::ustring cmdLine;
// start gimp // start gimp
@ -709,14 +750,18 @@ void EditorPanel::sendToGimpPressed () {
} }
if (!success) { if (!success) {
gdk_threads_enter ();
Gtk::MessageDialog* msgd = new Gtk::MessageDialog (*parent, M("MAIN_MSG_CANNOTSTARTEDITOR"), false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); Gtk::MessageDialog* msgd = new Gtk::MessageDialog (*parent, M("MAIN_MSG_CANNOTSTARTEDITOR"), false, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
msgd->set_secondary_text (M("MAIN_MSG_CANNOTSTARTEDITOR_SECONDARY")); msgd->set_secondary_text (M("MAIN_MSG_CANNOTSTARTEDITOR_SECONDARY"));
msgd->set_title (M("MAIN_BUTTON_SENDTOEDITOR")); msgd->set_title (M("MAIN_BUTTON_SENDTOEDITOR"));
msgd->run (); msgd->run ();
delete msgd; delete msgd;
gdk_threads_leave ();
} }
}
} }
return false;
} }
void EditorPanel::saveOptions () { void EditorPanel::saveOptions () {

14
rtgui/editorpanel.h
View File

@ -31,6 +31,7 @@
#include <batchqueueentry.h> #include <batchqueueentry.h>
#include <thumbnaillistener.h> #include <thumbnaillistener.h>
#include <navigator.h> #include <navigator.h>
#include <ProgressDialog.h>
class EditorPanel; class EditorPanel;
struct EditorPanelIdleHelper { struct EditorPanelIdleHelper {
@ -88,20 +89,21 @@ class EditorPanel : public Gtk::VBox,
EditorPanelIdleHelper* epih; EditorPanelIdleHelper* epih;
void open (Thumbnail* tmb, rtengine::InitialImage* isrc);
void close (); void close ();
rtengine::IImage16* processImage ();
BatchQueueEntry* createBatchQueueEntry (); BatchQueueEntry* createBatchQueueEntry ();
int saveImage (rtengine::IImage16* img, Glib::ustring& fname, SaveFormat sf, bool findNewNameIfNeeded); int saveImage (rtengine::IImage16* img, Glib::ustring& fname, SaveFormat sf, bool findNewNameIfNeeded);
bool idle_imageSaved(ProgressConnector<int> *pc,rtengine::IImage16* img,Glib::ustring fname, SaveFormat sf);
bool idle_saveImage(ProgressConnector<rtengine::IImage16*> *pc,Glib::ustring fname, SaveFormat sf,bool findNewNameIfNeeded);
bool idle_sendToGimp( ProgressConnector<rtengine::IImage16*> *pc);
bool idle_sentToGimp(ProgressConnector<int> *pc,rtengine::IImage16* img,Glib::ustring filename);
int err;
public: public:
static rtengine::InitialImage* loadImage (Thumbnail* tmb);
EditorPanel (Thumbnail* tmb, rtengine::InitialImage* isrc); EditorPanel ();
virtual ~EditorPanel (); virtual ~EditorPanel ();
void open (Thumbnail* tmb, rtengine::InitialImage* isrc);
bool beforeClosing (); bool beforeClosing ();
void on_realize (); void on_realize ();

38
rtgui/filepanel.cc
View File

@ -138,21 +138,31 @@ bool FilePanel::fileSelected (Thumbnail* thm) {
return false; return false;
// try to open the file // try to open the file
bool succ = false;
fileCatalog->setEnabled (false); fileCatalog->setEnabled (false);
rtengine::InitialImage* isrc = EditorPanel::loadImage (thm); ProgressConnector<rtengine::InitialImage*> *ld = new ProgressConnector<rtengine::InitialImage*>();
if (isrc) { ld->startFunc (sigc::bind(sigc::ptr_fun(&rtengine::InitialImage::load), thm->getFileName (), thm->getType()==FT_Raw, &error, parent->getProgressListener()),
EditorPanel* epanel = Gtk::manage (new EditorPanel (thm, isrc)); sigc::bind(sigc::mem_fun(*this,&FilePanel::imageLoaded), thm, ld) );
parent->addEditorPanel (epanel); return true;
succ = true; }
} bool FilePanel::imageLoaded( Thumbnail* thm, ProgressConnector<rtengine::InitialImage*> *pc ){
else {
Glib::ustring msg_ = Glib::ustring("<b>") + M("MAIN_MSG_CANNOTLOAD") + " \"" + thm->getFileName() + "\" .\n</b>"; if (pc->returnValue() && thm) {
Gtk::MessageDialog msgd (msg_, true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true); EditorPanel* epanel = Gtk::manage (new EditorPanel ());
msgd.run (); parent->addEditorPanel (epanel,Glib::path_get_basename (thm->getFileName()));
} epanel->open(thm, pc->returnValue() );
fileCatalog->setEnabled (true); }else {
return succ; gdk_threads_enter ();
Glib::ustring msg_ = Glib::ustring("<b>") + M("MAIN_MSG_CANNOTLOAD") + " \"" + thm->getFileName() + "\" .\n</b>";
Gtk::MessageDialog msgd (msg_, true, Gtk::MESSAGE_ERROR, Gtk::BUTTONS_OK, true);
msgd.run ();
gdk_threads_leave ();
}
delete pc;
parent->setProgress(0.);
parent->setProgressStr("");
fileCatalog->setEnabled (true);
return false; // MUST return false from idle function
} }
void FilePanel::saveOptions () { void FilePanel::saveOptions () {

4
rtgui/filepanel.h
View File

@ -29,6 +29,7 @@
#include <pparamschangelistener.h> #include <pparamschangelistener.h>
#include <history.h> #include <history.h>
#include <filterpanel.h> #include <filterpanel.h>
#include <progressdialog.h>
class RTWindow; class RTWindow;
class FilePanel : public Gtk::HPaned, class FilePanel : public Gtk::HPaned,
@ -50,6 +51,8 @@ class FilePanel : public Gtk::HPaned,
RTWindow* parent; RTWindow* parent;
Gtk::Notebook* rightNotebook; Gtk::Notebook* rightNotebook;
int error;
public: public:
FilePanel (); FilePanel ();
@ -68,6 +71,7 @@ class FilePanel : public Gtk::HPaned,
bool addBatchQueueJob (BatchQueueEntry* bqe); bool addBatchQueueJob (BatchQueueEntry* bqe);
void optionsChanged (); void optionsChanged ();
bool imageLoaded( Thumbnail* thm, ProgressConnector<rtengine::InitialImage*> * );
}; };
#endif #endif

69
rtgui/progressdialog.h
View File

@ -27,15 +27,14 @@
class PLDBridge : public rtengine::ProgressListener { class PLDBridge : public rtengine::ProgressListener {
Gtk::Dialog* dialog;
Gtk::Label* label; Gtk::Label* label;
Gtk::ProgressBar* progBar; Gtk::ProgressBar* progBar;
public: public:
PLDBridge (Gtk::Dialog* d, Gtk::Label* l, Gtk::ProgressBar* pb) PLDBridge ( Gtk::Label* l, Gtk::ProgressBar* pb)
: dialog(d), label(l), progBar(pb) {} : label(l), progBar(pb) {}
// progresslistener interface // ProgressListener interface
void setProgress (double p) { void setProgress (double p) {
gdk_threads_enter (); gdk_threads_enter ();
progBar->set_fraction (p); progBar->set_fraction (p);
@ -72,57 +71,39 @@ class PLDBridge : public rtengine::ProgressListener {
label->set_text (progrstr); label->set_text (progrstr);
gdk_threads_leave (); gdk_threads_leave ();
} }
void setProgressState (int state) {}
void error (Glib::ustring descr) {}
}; };
template<class T> template<class T>
class ProgressDialog : public Gtk::Dialog { class ProgressConnector {
sigc::signal0<T> operation; sigc::slot0<T> slotStart;
T* retval; sigc::slot0<bool> slotEnd;
Gtk::Label prLabel; T retval;
Gtk::ProgressBar prProgBar; Glib::Thread *workThread;
PLDBridge* pldBridge;
void workingThread () { void workingThread () {
*retval = operation.emit (); sigc::signal0<T> op;
gdk_threads_enter (); sigc::connection conn= op.connect(slotStart);
response (1); retval = op.emit ();
gdk_threads_leave (); conn.disconnect();
Glib::signal_idle().connect(slotEnd);
workThread = 0;
} }
public: public:
ProgressDialog (Glib::ustring label) : Gtk::Dialog (label, true) { ProgressConnector ():workThread( 0 ) { }
pldBridge = new PLDBridge (this, &prLabel, &prProgBar);
get_vbox()->pack_start (prLabel, Gtk::PACK_SHRINK, 4); void startFunc (const sigc::slot0<T>& startHandler, const sigc::slot0<bool>& endHandler ) {
get_vbox()->pack_start (prProgBar, Gtk::PACK_SHRINK, 4); if( !workThread ){
set_size_request (300, -1); slotStart = startHandler;
show_all_children (); slotEnd = endHandler;
workThread = Glib::Thread::create(sigc::mem_fun(*this, &ProgressConnector<T>::workingThread), 0, true, true, Glib::THREAD_PRIORITY_NORMAL);
}
} }
~ProgressDialog () { T returnValue(){
delete pldBridge; return retval;
}
rtengine::ProgressListener* getProgressListener () { return pldBridge; }
void setFunc (const sigc::slot0<T>& slot, T* rv) {
retval = rv;
operation.connect (slot);
}
void start () {
Glib::Thread *thread = Glib::Thread::create(sigc::mem_fun(*this, &ProgressDialog<T>::workingThread), 0, true, true, Glib::THREAD_PRIORITY_NORMAL);
int x = run ();
if (x<0) {
gdk_threads_leave ();
thread->join ();
gdk_threads_enter ();
}
} }
}; };
#endif #endif

36
rtgui/rtwindow.cc
View File

@ -79,11 +79,16 @@ RTWindow::RTWindow () {
preferences->set_image (*Gtk::manage(new Gtk::Image (Gtk::StockID("gtk-preferences"), Gtk::ICON_SIZE_BUTTON))); preferences->set_image (*Gtk::manage(new Gtk::Image (Gtk::StockID("gtk-preferences"), Gtk::ICON_SIZE_BUTTON)));
preferences->set_relief (Gtk::RELIEF_NONE); preferences->set_relief (Gtk::RELIEF_NONE);
preferences->signal_clicked().connect( sigc::mem_fun(*this, &RTWindow::showPreferences) ); preferences->signal_clicked().connect( sigc::mem_fun(*this, &RTWindow::showPreferences) );
is_fullscreen = false;
btn_fullscreen = Gtk::manage( new Gtk::Button(M("MAIN_BUTTON_FULLSCREEN"))); btn_fullscreen = Gtk::manage( new Gtk::Button(M("MAIN_BUTTON_FULLSCREEN")));
btn_fullscreen->signal_clicked().connect( sigc::mem_fun(*this, &RTWindow::toggle_fullscreen) ); btn_fullscreen->signal_clicked().connect( sigc::mem_fun(*this, &RTWindow::toggle_fullscreen) );
bottomBox->pack_start (*preferences, Gtk::PACK_SHRINK, 0); bottomBox->pack_start (*preferences, Gtk::PACK_SHRINK, 0);
bottomBox->pack_start (*rtWeb, Gtk::PACK_SHRINK, 4);
bottomBox->pack_end (*btn_fullscreen, Gtk::PACK_SHRINK, 4); bottomBox->pack_end (*btn_fullscreen, Gtk::PACK_SHRINK, 4);
bottomBox->pack_start (*rtWeb, Gtk::PACK_SHRINK, 4);
bottomBox->pack_start (prLabel );
prLabel.set_alignment(Gtk::ALIGN_RIGHT);
bottomBox->pack_start (prProgBar, Gtk::PACK_SHRINK, 4);
pldBridge = new PLDBridge(&prLabel,&prProgBar);
Glib::RefPtr<Gtk::RcStyle> style = Gtk::RcStyle::create (); Glib::RefPtr<Gtk::RcStyle> style = Gtk::RcStyle::create ();
style->set_xthickness (0); style->set_xthickness (0);
@ -102,14 +107,14 @@ void RTWindow::on_realize () {
cursorManager.init (get_window()); cursorManager.init (get_window());
} }
void RTWindow::addEditorPanel (EditorPanel* ep) { void RTWindow::addEditorPanel (EditorPanel* ep, const std::string &name) {
ep->setParent (this); ep->setParent (this);
// construct closeable tab for the image // construct closeable tab for the image
Gtk::HBox* hb = Gtk::manage (new Gtk::HBox ()); Gtk::HBox* hb = Gtk::manage (new Gtk::HBox ());
hb->pack_start (*Gtk::manage (new Gtk::Image (Gtk::Stock::FILE, Gtk::ICON_SIZE_MENU))); hb->pack_start (*Gtk::manage (new Gtk::Image (Gtk::Stock::FILE, Gtk::ICON_SIZE_MENU)));
hb->pack_start (*Gtk::manage (new Gtk::Label (ep->getShortName ()))); hb->pack_start (*Gtk::manage (new Gtk::Label (name)));
Gtk::Button* closeb = Gtk::manage (new Gtk::Button ()); Gtk::Button* closeb = Gtk::manage (new Gtk::Button ());
closeb->set_image (*Gtk::manage(new Gtk::Image (Gtk::Stock::CLOSE, Gtk::ICON_SIZE_MENU))); closeb->set_image (*Gtk::manage(new Gtk::Image (Gtk::Stock::CLOSE, Gtk::ICON_SIZE_MENU)));
closeb->set_relief (Gtk::RELIEF_NONE); closeb->set_relief (Gtk::RELIEF_NONE);
@ -128,8 +133,8 @@ void RTWindow::addEditorPanel (EditorPanel* ep) {
mainNB->set_current_page (mainNB->page_num (*ep)); mainNB->set_current_page (mainNB->page_num (*ep));
mainNB->set_tab_reorderable (*ep, true); mainNB->set_tab_reorderable (*ep, true);
epanels[ep->getFileName()] = ep; epanels[ name ] = ep;
filesEdited.insert (ep->getFileName ()); filesEdited.insert ( name );
fpanel->refreshEditedState (filesEdited); fpanel->refreshEditedState (filesEdited);
} }
@ -230,7 +235,22 @@ void RTWindow::showPreferences () {
fpanel->optionsChanged (); fpanel->optionsChanged ();
} }
void RTWindow::setProgress (double p){
prProgBar.set_fraction (p);
}
void RTWindow::setProgressStr (Glib::ustring str){
prLabel.set_text ( str );
}
void RTWindow::setProgressState (int state){
if(state){
prProgBar.show();
prLabel.show();
}else{
prProgBar.hide();
prLabel.hide();
}
}
void RTWindow::toggle_fullscreen () { void RTWindow::toggle_fullscreen () {
if(is_fullscreen){ if(is_fullscreen){
unfullscreen(); unfullscreen();
@ -243,3 +263,7 @@ void RTWindow::toggle_fullscreen () {
btn_fullscreen->set_label(M("MAIN_BUTTON_UNFULLSCREEN")); btn_fullscreen->set_label(M("MAIN_BUTTON_UNFULLSCREEN"));
} }
} }
void RTWindow::error (Glib::ustring descr){
prLabel.set_text ( descr );
}

16
rtgui/rtwindow.h
View File

@ -24,8 +24,9 @@
#include <editorpanel.h> #include <editorpanel.h>
#include <batchqueuepanel.h> #include <batchqueuepanel.h>
#include <set> #include <set>
#include <Progressdialog.h>
class RTWindow : public Gtk::Window { class RTWindow : public Gtk::Window, public rtengine::ProgressListener{
private: private:
Gtk::Notebook* mainNB; Gtk::Notebook* mainNB;
@ -33,14 +34,18 @@ class RTWindow : public Gtk::Window {
BatchQueuePanel* bpanel; BatchQueuePanel* bpanel;
std::set<Glib::ustring> filesEdited; std::set<Glib::ustring> filesEdited;
std::map<Glib::ustring, EditorPanel*> epanels; std::map<Glib::ustring, EditorPanel*> epanels;
Gtk::Label prLabel;
Gtk::ProgressBar prProgBar;
PLDBridge* pldBridge;
bool is_fullscreen; bool is_fullscreen;
Gtk::Button * btn_fullscreen; Gtk::Button * btn_fullscreen;
public: public:
RTWindow (); RTWindow ();
void addEditorPanel (EditorPanel* ep); void addEditorPanel (EditorPanel* ep,const std::string &name);
void remEditorPanel (EditorPanel* ep); void remEditorPanel (EditorPanel* ep);
void addBatchQueueJob (BatchQueueEntry* bqe, bool head=false); void addBatchQueueJob (BatchQueueEntry* bqe, bool head=false);
@ -52,6 +57,11 @@ class RTWindow : public Gtk::Window {
void showPreferences (); void showPreferences ();
void on_realize (); void on_realize ();
void toggle_fullscreen (); void toggle_fullscreen ();
void setProgress (double p);
void setProgressStr (Glib::ustring str);
void setProgressState (int state);
void error (Glib::ustring descr);
rtengine::ProgressListener* getProgressListener () { return pldBridge; }
}; };
#endif #endif