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)
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)
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)
IF (BUILD_SHARED_LIBS)

191
rtgui/editorpanel.cc
View File

@ -26,7 +26,7 @@
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->epanel = this;
@ -206,8 +206,6 @@ EditorPanel::EditorPanel (Thumbnail* tmb, rtengine::InitialImage* isrc) : parent
queueimg->signal_pressed().connect( sigc::mem_fun(*this, &EditorPanel::queueImgPressed) );
sendtogimp->signal_pressed().connect( sigc::mem_fun(*this, &EditorPanel::sendToGimpPressed) );
// open image
open (tmb, isrc);
}
bool EditorPanel::beforeClosing () {
@ -255,24 +253,6 @@ void EditorPanel::on_realize () {
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) {
// initialize everything
@ -528,18 +508,23 @@ void EditorPanel::procParamsChanged (Thumbnail* thm, int whoChangedIt) {
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;
ipc->getParams (&pparams);
rtengine::ProcessingJob* job = rtengine::ProcessingJob::create (ipc->getInitialImage(), pparams);
int err = 0;
ProgressDialog<rtengine::IImage16*>* pdproc = new ProgressDialog<rtengine::IImage16*> (M("PROGRESSDLG_PROCESSING"));
rtengine::IImage16* img;
pdproc->setFunc (sigc::bind(sigc::ptr_fun(&rtengine::processImage), job, err, pdproc->getProgressListener()), &img);
pdproc->start ();
delete pdproc;
return img;
saveimgas->set_sensitive(true);
sendtogimp->set_sensitive(true);
}
return false;
}
BatchQueueEntry* EditorPanel::createBatchQueueEntry () {
@ -565,22 +550,43 @@ int EditorPanel::saveImage (rtengine::IImage16* img, Glib::ustring& fname, SaveF
if (tries==1000)
return -1000;
}
ProgressDialog<int>* pdsave = new ProgressDialog<int> (M("PROGRESSDLG_SAVING"));
img->setSaveProgressListener (pdsave->getProgressListener());
int err;
ProgressConnector<int> *ld = new ProgressConnector<int>();
img->setSaveProgressListener (parent->getProgressListener());
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")
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")
pdsave->setFunc (sigc::bind(sigc::mem_fun(img, &rtengine::IImage16::saveAsJPEG), fileName, sf.jpegQuality), &err);
pdsave->start ();
delete pdsave;
fname = fileName;
return err;
ld->startFunc (sigc::bind(sigc::mem_fun(img, &rtengine::IImage16::saveAsJPEG), fileName, sf.jpegQuality),
sigc::bind(sigc::mem_fun(*this,&EditorPanel::idle_imageSaved), ld, img, fileName,sf));
return 0;
}
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 () {
@ -610,27 +616,15 @@ void EditorPanel::saveAsPressed () {
return;
}
// save image
rtengine::IImage16* img = processImage ();
int err = 0;
if (img) {
fname = removeExtension (fname);
err = saveImage (img, fname, sf, false);
img->free ();
if (!err) {
openThm->imageDeveloped ();
// save processing parameters, if needed
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 ();
}
rtengine::procparams::ProcParams pparams;
ipc->getParams (&pparams);
rtengine::ProcessingJob* job = rtengine::ProcessingJob::create (ipc->getInitialImage(), pparams);
fname = removeExtension (fname);
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_saveImage ),ld,fname,sf,false ));
saveimgas->set_sensitive(false);
sendtogimp->set_sensitive(false);
}
else {
BatchQueueEntry* bqe = createBatchQueueEntry ();
@ -649,21 +643,68 @@ void EditorPanel::queueImgPressed () {
}
void EditorPanel::sendToGimpPressed () {
// 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) {
// get file name base
Glib::ustring shortname = removeExtension (Glib::path_get_basename (openThm->getFileName()));
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;
sf.format = "tif";
sf.tiffBits = 16;
int err = saveImage (img, filename, sf, true);
img->free ();
if (!err) {
Glib::ustring fileName = Glib::ustring::compose ("%1.%2", fname, sf.format);
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;
Glib::ustring cmdLine;
// start gimp
@ -709,14 +750,18 @@ void EditorPanel::sendToGimpPressed () {
}
if (!success) {
gdk_threads_enter ();
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_title (M("MAIN_BUTTON_SENDTOEDITOR"));
msgd->run ();
delete msgd;
gdk_threads_leave ();
}
}
}
return false;
}
void EditorPanel::saveOptions () {

14
rtgui/editorpanel.h
View File

@ -31,6 +31,7 @@
#include <batchqueueentry.h>
#include <thumbnaillistener.h>
#include <navigator.h>
#include <ProgressDialog.h>
class EditorPanel;
struct EditorPanelIdleHelper {
@ -88,20 +89,21 @@ class EditorPanel : public Gtk::VBox,
EditorPanelIdleHelper* epih;
void open (Thumbnail* tmb, rtengine::InitialImage* isrc);
void close ();
rtengine::IImage16* processImage ();
BatchQueueEntry* createBatchQueueEntry ();
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:
static rtengine::InitialImage* loadImage (Thumbnail* tmb);
EditorPanel (Thumbnail* tmb, rtengine::InitialImage* isrc);
EditorPanel ();
virtual ~EditorPanel ();
void open (Thumbnail* tmb, rtengine::InitialImage* isrc);
bool beforeClosing ();
void on_realize ();

38
rtgui/filepanel.cc
View File

@ -138,21 +138,31 @@ bool FilePanel::fileSelected (Thumbnail* thm) {
return false;
// try to open the file
bool succ = false;
fileCatalog->setEnabled (false);
rtengine::InitialImage* isrc = EditorPanel::loadImage (thm);
if (isrc) {
EditorPanel* epanel = Gtk::manage (new EditorPanel (thm, isrc));
parent->addEditorPanel (epanel);
succ = true;
}
else {
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 ();
}
fileCatalog->setEnabled (true);
return succ;
ProgressConnector<rtengine::InitialImage*> *ld = new ProgressConnector<rtengine::InitialImage*>();
ld->startFunc (sigc::bind(sigc::ptr_fun(&rtengine::InitialImage::load), thm->getFileName (), thm->getType()==FT_Raw, &error, parent->getProgressListener()),
sigc::bind(sigc::mem_fun(*this,&FilePanel::imageLoaded), thm, ld) );
return true;
}
bool FilePanel::imageLoaded( Thumbnail* thm, ProgressConnector<rtengine::InitialImage*> *pc ){
if (pc->returnValue() && thm) {
EditorPanel* epanel = Gtk::manage (new EditorPanel ());
parent->addEditorPanel (epanel,Glib::path_get_basename (thm->getFileName()));
epanel->open(thm, pc->returnValue() );
}else {
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 () {

4
rtgui/filepanel.h
View File

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

69
rtgui/progressdialog.h
View File

@ -27,15 +27,14 @@
class PLDBridge : public rtengine::ProgressListener {
Gtk::Dialog* dialog;
Gtk::Label* label;
Gtk::ProgressBar* progBar;
public:
PLDBridge (Gtk::Dialog* d, Gtk::Label* l, Gtk::ProgressBar* pb)
: dialog(d), label(l), progBar(pb) {}
PLDBridge ( Gtk::Label* l, Gtk::ProgressBar* pb)
: label(l), progBar(pb) {}
// progresslistener interface
// ProgressListener interface
void setProgress (double p) {
gdk_threads_enter ();
progBar->set_fraction (p);
@ -72,57 +71,39 @@ class PLDBridge : public rtengine::ProgressListener {
label->set_text (progrstr);
gdk_threads_leave ();
}
void setProgressState (int state) {}
void error (Glib::ustring descr) {}
};
template<class T>
class ProgressDialog : public Gtk::Dialog {
class ProgressConnector {
sigc::signal0<T> operation;
T* retval;
Gtk::Label prLabel;
Gtk::ProgressBar prProgBar;
PLDBridge* pldBridge;
sigc::slot0<T> slotStart;
sigc::slot0<bool> slotEnd;
T retval;
Glib::Thread *workThread;
void workingThread () {
*retval = operation.emit ();
gdk_threads_enter ();
response (1);
gdk_threads_leave ();
sigc::signal0<T> op;
sigc::connection conn= op.connect(slotStart);
retval = op.emit ();
conn.disconnect();
Glib::signal_idle().connect(slotEnd);
workThread = 0;
}
public:
ProgressDialog (Glib::ustring label) : Gtk::Dialog (label, true) {
pldBridge = new PLDBridge (this, &prLabel, &prProgBar);
get_vbox()->pack_start (prLabel, Gtk::PACK_SHRINK, 4);
get_vbox()->pack_start (prProgBar, Gtk::PACK_SHRINK, 4);
set_size_request (300, -1);
show_all_children ();
ProgressConnector ():workThread( 0 ) { }
void startFunc (const sigc::slot0<T>& startHandler, const sigc::slot0<bool>& endHandler ) {
if( !workThread ){
slotStart = startHandler;
slotEnd = endHandler;
workThread = Glib::Thread::create(sigc::mem_fun(*this, &ProgressConnector<T>::workingThread), 0, true, true, Glib::THREAD_PRIORITY_NORMAL);
}
}
~ProgressDialog () {
delete pldBridge;
}
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 ();
}
T returnValue(){
return retval;
}
};
#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_relief (Gtk::RELIEF_NONE);
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->signal_clicked().connect( sigc::mem_fun(*this, &RTWindow::toggle_fullscreen) );
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_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 ();
style->set_xthickness (0);
@ -102,14 +107,14 @@ void RTWindow::on_realize () {
cursorManager.init (get_window());
}
void RTWindow::addEditorPanel (EditorPanel* ep) {
void RTWindow::addEditorPanel (EditorPanel* ep, const std::string &name) {
ep->setParent (this);
// construct closeable tab for the image
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::Label (ep->getShortName ())));
hb->pack_start (*Gtk::manage (new Gtk::Label (name)));
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_relief (Gtk::RELIEF_NONE);
@ -128,8 +133,8 @@ void RTWindow::addEditorPanel (EditorPanel* ep) {
mainNB->set_current_page (mainNB->page_num (*ep));
mainNB->set_tab_reorderable (*ep, true);
epanels[ep->getFileName()] = ep;
filesEdited.insert (ep->getFileName ());
epanels[ name ] = ep;
filesEdited.insert ( name );
fpanel->refreshEditedState (filesEdited);
}
@ -230,7 +235,22 @@ void RTWindow::showPreferences () {
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 () {
if(is_fullscreen){
unfullscreen();
@ -243,3 +263,7 @@ void RTWindow::toggle_fullscreen () {
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 <batchqueuepanel.h>
#include <set>
#include <Progressdialog.h>
class RTWindow : public Gtk::Window {
class RTWindow : public Gtk::Window, public rtengine::ProgressListener{
private:
Gtk::Notebook* mainNB;
@ -33,14 +34,18 @@ class RTWindow : public Gtk::Window {
BatchQueuePanel* bpanel;
std::set<Glib::ustring> filesEdited;
std::map<Glib::ustring, EditorPanel*> epanels;
Gtk::Label prLabel;
Gtk::ProgressBar prProgBar;
PLDBridge* pldBridge;
bool is_fullscreen;
Gtk::Button * btn_fullscreen;
public:
RTWindow ();
void addEditorPanel (EditorPanel* ep);
void addEditorPanel (EditorPanel* ep,const std::string &name);
void remEditorPanel (EditorPanel* ep);
void addBatchQueueJob (BatchQueueEntry* bqe, bool head=false);
@ -52,6 +57,11 @@ class RTWindow : public Gtk::Window {
void showPreferences ();
void on_realize ();
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