// This sourcefile is created by Peter Jodda / peter@jodda.de
// It is under the Peter Jodda license:
// Everyboy may use it on his own risk. This header must stay in the file!
// If you expand this file, please contact me, that I can integrate the
// enhancemants in the original file.
//
// main kamera application window class

#include <qapplication.h>

#include <qvbox.h>
#include <qpushbutton.h>
#include <qlabel.h>
#include <qlayout.h>
#include <qframe.h>
#include <qgrid.h>
#include <qpopupmenu.h>
#include <qmenubar.h>

#include <stdio.h>
#include <stdlib.h>

#include "kamera.h"
#include "settingsbox.h"
#include "aboutbox.h"
#include "malbox.h"
#include "controlbox.h"
#include "texte.h"
#include "camera_basis.h"




/*---------------------------------------------------------------*/



Kamera::Kamera(QWidget *parent,
               CameraApplicationClass *mainCameraApplication)
   		: QMainWindow(parent,
   		              "KCamedia",
   		              WType_TopLevel )
{
   QPushButton *loadAllButton,*reloadThumbsButton;
   QPopupMenu  *fileMenu,*workMenu,*deleteMenu;
   QBoxLayout  *topLayout,*buttonsLayout,*graphicsLayout; 
   QWidget     *mittelWidget;

   setCaption(TextGet(TEXT_MAIN_TITEL));

   // initialisierung der variablen
   cameraApplication = mainCameraApplication;
   progressBox       = NULL;   
   
     
   //  menus erzeugen
   fileMenu = new QPopupMenu( this );
   fileMenu->insertItem(TextGet(TEXT_MENU_ABOUT), this, SLOT( DoAboutBox() ) );
   fileMenu->insertItem(TextGet(TEXT_MENU_SETTINGS), this, SLOT( DoSettingsBox() ) );
   fileMenu->insertItem(TextGet(TEXT_MENU_QUIT) , this, SLOT( Beenden() ) );

   workMenu = new QPopupMenu(this);
   workMenu->insertItem(TextGet(TEXT_MENU_RELOAD_THUMBS), this, SLOT( LadeThumbnails() ));
   workMenu->insertItem(TextGet(TEXT_MENU_LOAD_ALL), this, SLOT( LadeAlleBilder() ));
   workMenu->insertItem(TextGet(TEXT_MENU_LOAD_SELECTED), this, SLOT( LadeSelektierteBilder() ));
   workMenu->insertItem(TextGet(TEXT_MENU_CONTROL),this, SLOT( DoControlBox() ));

   deleteMenu = new QPopupMenu(this);
   deleteMenu->insertItem(TextGet(TEXT_MENU_DELETE_ALL) ,this, SLOT( LoescheAlleBilder() ));
   deleteMenu->insertItem(TextGet(TEXT_MENU_DELETE_SELECTED),this, SLOT( LoescheSelektierteBilder() ));

   menuBar()->insertItem(TextGet(TEXT_MENU_FILE), fileMenu );
   menuBar()->insertItem(TextGet(TEXT_MENU_WORK), workMenu );
   menuBar()->insertItem(TextGet(TEXT_MENU_DELETE), deleteMenu );
   
   // mittelwidgets erzeugen
   mittelWidget = new QWidget(this);
      
   topLayout = new QVBoxLayout( mittelWidget, 2 );

   malBox = new ScrollMalBox(mittelWidget);
   topLayout->addWidget(malBox);

   buttonsLayout = new QHBoxLayout( topLayout);
   reloadThumbsButton  = new QPushButton(TextGet(TEXT_MENU_RELOAD_THUMBS),mittelWidget);
   loadAllButton       = new QPushButton(TextGet(TEXT_MENU_LOAD_ALL),mittelWidget);
   buttonsLayout->addWidget (reloadThumbsButton);
   buttonsLayout->addWidget (loadAllButton);
   
   setCentralWidget(mittelWidget);
 
   
   // statusbar erzeugen
   dieStatusBar = statusBar();
   
   dieStatusBar->message(TextGet(TEXT_READY));

   // connecte den reload Button
   connect(reloadThumbsButton,
           SIGNAL(clicked()),
           this,
           SLOT(LadeThumbnails()) );
   // connecte den alles laden Button
   connect(loadAllButton,
           SIGNAL(clicked()),
           this,
           SLOT(LadeAlleBilder()) );
   
}

//=============================================================================

void Kamera::LadeThumbnails()
{
   buffer2d *geladenesThumbnail;
   char     loadingMessage[80];
   int      anzahlBilder;
   int      i;
   
   // wartecursor einschalten
   cameraApplication->setWait(true);

   malBox->loescheAlleBilder();
   
   cameraApplication->cameraReal->GetNumberOfImages(&anzahlBilder);

   for( i=0; i<anzahlBilder; i++)
   {
      char bildname[CAMERA_STRING_MAX +10];
      
      // meldung in der statusbar ausgeben
      sprintf(loadingMessage,
              TextGet(TEXT_LOAD_THUMBNAIL),
              i+1, 
              anzahlBilder);
      dieStatusBar->message(loadingMessage);
      // anzeigen erzwingen
      cameraApplication->mainApplication->processEvents();
      
      // thumb jetzt laden
      cameraApplication->cameraReal->LoadThumbNail(i,
                                                   &geladenesThumbnail);
                                                   
      // thumbnail in die malbox setzen
      sprintf(bildname,"%s%03d",
              cameraApplication->LoadPrefix,i);
      //sleep(1);              
              
      malBox->addImage(geladenesThumbnail,bildname);
      
   }

   dieStatusBar->message(TextGet(TEXT_READY));
   // wartecursor ausschalten
   cameraApplication->setWait(false);
}

//=============================================================================

void Kamera::closeEvent(QCloseEvent *theCloseEvent)
{
   // fprintf(stderr,"in Close Event\n");
   Beenden();

}
//=============================================================================

void Kamera::Beenden()
{
   // hier noch das schreiben der basisdaten vornehmen
   basisDatenSchreiben(cameraApplication);

   exit(0);
}

//=============================================================================

void Kamera::DoSettingsBox()
{
   SettingsBox * settingsBox;
 
   settingsBox = new SettingsBox(this,cameraApplication);
   
   settingsBox->exec();
   
   delete settingsBox;
}

//=============================================================================

void Kamera::DoControlBox()
{
   ControlBox * controlBox;
 
   controlBox = new ControlBox(this,cameraApplication);
   
   controlBox->exec();
   
   delete controlBox;
}

//=============================================================================

void Kamera::DoAboutBox()
{
   AboutBox * aboutBox;
 
   aboutBox = new AboutBox(this);
   
   aboutBox->exec();
   
   delete aboutBox;
}

//=============================================================================

void Kamera::bildname(int nummer,int *selektiertListe,char *zielname,int * zielIndex)
{
   int zielnummer;
   
   if(selektiertListe ==NULL)
      zielnummer = nummer;
   else
      zielnummer = selektiertListe[nummer];
    
   *zielIndex = zielnummer; 
      
   if(zielname != NULL)
   {
      sprintf(zielname,
              "%s%03d",
              cameraApplication->LoadPrefix,
              zielnummer);
   }
}

//=============================================================================

void Kamera::laden(int nummer,int *selektiertListe)
{
   int i, anzahlBilder;
   int returnWert;
   
   if (selektiertListe == NULL)
   {
      cameraApplication->cameraReal->GetNumberOfImages(&anzahlBilder);

   }
   else
      anzahlBilder = nummer;
   

   progressBox =new ProgressBox(this,cameraApplication);
   progressBox-> show();

   cameraApplication->mainApplication->processEvents();
   // callback für den progress eintragen
   cameraApplication->cameraReal->SetProgressCallback(LoadProgressCallback,
                            (void *) this );
   
   progressBox->update(NULL,-1,anzahlBilder,0);

   returnWert = RC_OK;
   for(i=0; i< anzahlBilder && returnWert == RC_OK; i++)
   {
      char zielName[CAMERA_STRING_MAX];
      char pfadName[CAMERA_STRING_MAX];
      int  zielIndex;
      
      progressBox->update(NULL,-1,anzahlBilder,0);

      bildname(i,selektiertListe,zielName,&zielIndex);
      
      progressBox->update(zielName,i,-1,0);

      // load directory vor den bildnamen setzen
      sprintf(pfadName,
              "%s/%s.jpg",
              cameraApplication->LoadDirectory,
              zielName);
      returnWert = cameraApplication->cameraReal->LoadImage(zielIndex,pfadName);
      
   }

   // progressbox wieder loeschen
   if(progressBox != NULL)
   {
      delete progressBox;
      progressBox = NULL;
   }
}

//=============================================================================

void Kamera::LadeAlleBilder()
{
   // alles laden
   laden(0,NULL);
}

//=============================================================================

void Kamera::LadeSelektierteBilder()
{
   int anzahlSelektiert,*selektiertListe;
   
   malBox->holSelektiertListe(&anzahlSelektiert,&selektiertListe);

   // nichts selektiert, dann beenden
   if(anzahlSelektiert <= 0)
      return;

   // nur selektiertes laden
   laden(anzahlSelektiert,selektiertListe);


   // liste wieder freigeben
   delete selektiertListe;
}

//=============================================================================

void Kamera::LoescheAlleBilder()
{
   int returnCode;

   cameraApplication->setWait(true);

   returnCode = cameraApplication->cameraReal->DeleteAllImages();

   cameraApplication->setWait(false);
   
   
   if(returnCode == RC_OK)
      malBox->loescheAlleBilder();
}

//=============================================================================

void Kamera::LoescheSelektierteBilder()
{

   char textstring[100];
   int  anzahlGewaehlt,bereitsGeladen;
   int  i;
   int  anzahl,*bilder;
   int  returnCode; 
   int  letzter;  
   

   int anzahlSelektiert,*selektiertListe;
   
   malBox->holSelektiertListe(&anzahlSelektiert,&selektiertListe);

   // nichts selektiert, dann beenden
   if(anzahlSelektiert <= 0)
      return;



   cameraApplication->setWait(true);
   returnCode = cameraApplication->cameraReal->DeleteSingleImage(selektiertListe,
                                                                 anzahlSelektiert);

   // liste wieder freigeben
   delete selektiertListe;
   
   LadeThumbnails();
   cameraApplication->setWait(false);
   
   
}

//=============================================================================
//
// callback, just calls the member function

bool Kamera::LoadProgressCallback(void *klassenPointer, float fortschritt)
{
   Kamera * thisPointer = (Kamera *) klassenPointer;
   return thisPointer->loadProgress(fortschritt);
}

//----------------------------------------------------
  
bool Kamera::loadProgress(float fortschritt)
{
   bool abbruchGedrueckt;


   // prozent slider neu setzen
   if(progressBox != NULL)
      abbruchGedrueckt = progressBox->update(NULL,
                                             -1,
                                             -1,
                                             (int) (fortschritt*100.0));

   // events processieren
   cameraApplication->mainApplication->processEvents();

   return abbruchGedrueckt;
}
