#define OBRAZ_PLANSZY_ABS
/*
     Plik ten zawiera deklaracje klasy ObrazPlanszyAbs i klas pomocniczych:
  PowierzchniaPlanszy, RozaWiatrow, Obraz.
      
  !!! ObrazPlanszyAbs jest klasa abstrakcyjna !!!
  Odwoluje sie do klasy Plansza i ObrazTerenu.

  Jest odpowiedzialna za wizualizacje planszy wirtualnej, a dokladnie
  tylko terenow w niej opisanych (tworzy ich rysunki). 
  Klasy dziedziczace maga na bierzaco sledzic i uaktualniac rysunek terenow.
  Znajduja sie tu odpowiednie narzedzia. Nalezy jedynie zdefiniowac 
  metode odbierzImpuls (obecnie w pelni wirtualna).

  Obiekt z podklasy dzidziczcej z tej klasy to widget posiadajacy scroollbary,
   bedace RozaWiatrow (klasa zdeklarowana ponizej).
  Mozna w nim sledzic myszke.
  
  Autor: Michal Wiktor Zmijewski (grupa nr 5).
*/   

#include "qwmatrix.h"
#include "qevent.h"
#include "libSprite/QwSpriteField.h"
#include <stl.h>
#include "naglowki/typy.h"
#include "naglowki/stale_ElementySwiata.h"
#include "naglowki/parametry.h"
#include "naglowki/Plansza.h"
#include "naglowki/stale_ObrazPlanszy.h"

class Obraz;
#include "naglowki/ObrazTerenu.h"

/* powierzchnia na ktorej beda rysowane elementy swiata - sprity */
/* konstruktor dostaje nazwe pliku bedacego tlem obrazu planszy
   pozostale parametry sa domyslne (wewnetrze w biblitece QwSprite),
   ich opis znajduje sie w dokumentacji biblioteki QwSprite 
   UWAGA: domyslnie wczytywany jako tlo jest plik TLO_PLANSZY (patrz stale_ObrazPlanszy)
*/
class PowierzchniaPlanszy : public QwImageSpriteField {
public:
    PowierzchniaPlanszy(QPoint rozmiar,int chunksize=16,int maxclusters=100);
    PowierzchniaPlanszy(const char*,QPoint rozmiar,int chunksize=16,int maxclusters=100);
    void resize(int width, int height);
    ~PowierzchniaPlanszy(){};
};

/* definicje typow do ObrazuPlanszyAbs*/ 
typedef   map<typ_teren,QwSpritePixmapSequence*>    typ_anim_terenow;
typedef   map<Para,ObrazTerenu*>                    typ_mapa_terenu;
typedef   map<typ_teren,QPixmap*>                   typ_mapa_masek;

/* deklaracja klasy ObrazPlanszyAbs */
class ObrazPlanszyAbs : public QWidget {
    Q_OBJECT

public:
     ObrazPlanszyAbs(const char*,Plansza&,QWidget* parent=0,const char* name=0,WFlags f=0);
     ObrazPlanszyAbs(char*,char*,char*,Plansza&,QWidget* parent=0,const char* name=0,WFlags f=0);
    ~ObrazPlanszyAbs();
                                                      
    QwSpritePixmapSequence* animacja(typ_teren rodz);/* udostepnia animacje terenu rodz */
    QPoint wspNaObrazie(QPoint);/* przeksztalca wzgledne wspolrzedne punktu na bezwzgledne */
private:
     void inicjacja(char*,char*);/* inicjator do konstruktorow */
    
signals:
     void wyswietlTeren();
     void vScroll(int);
     void hScroll(int);

public slots:
    virtual void odbierzImpuls()=0;
    virtual void odbierzImpulsPauza(){};
    virtual void nieMaMyszki(){};/* gdy myszka jest poza widgetem */
    void zdjecie();/* zapisuje rysunek calej planszy w pliku ../obrazki/plansza.png*/
    void zdjecie(const char*);/* zapisuje rysunek calej planszy w zadanym pliku */

protected slots:
    void resizeEvent(QResizeEvent* event);
    void mouseMoveEvent(QMouseEvent*){};
    void mousePressEvent(QMouseEvent*){};
    void mouseReleaseEvent(QMouseEvent*){};
protected:
    Plansza&                 plansza;     /* plansza wirtualna */
    PowierzchniaPlanszy      powierzchnia;
    Obraz                   *obraz;       /* windget z rysunkiem planszy */

    QPixmap                 *pixmapaPlanszy;/* ewentualny wczytany rysunek planszy */			       
    typ_mapa_masek           maska; /* kolekcja masek mask do terenow wczytanych z pixmapy */

    typ_anim_terenow         anim_terenow;/* kolekcja standardowych animacji terenow */
    typ_mapa_terenu          mapa_terenu;/* kolekcja obrazow terenu */    

    QPoint                   mpos;/* wspolrzedne myszki na obrazie */
    
    void pobierzAnimacjeTerenow(QWMatrix macierzSkali,QWMatrix macierzOdbicia);
           /* pobiera animacje terenow i przeksztalca je wedlug macierzy */
    void pobierzMaskiDlaTerenowZPixmapy(QWMatrix macierzSkali,QWMatrix macierzOdbicia);
           /* pobiera maski mask dla terenow z pixmapy i je przeksztalca */

    QwSpritePixmapSequence* przeksztalcAnimacje(QwSpritePixmapSequence *anim,
                               QWMatrix macierz,int liczba_klatek,int wektorX=0,int wektorY=0);
           /* przeksztalca sekwencje (liczba_klatek) klatek anim */			       
    void zrobMapeTerenu(int CzyZPixmapy=0);
           /* tworzy kolekcje obrazow terenow */
    void tworzObrazTerenu(typ_teren,Para,int CzyZPixmapy=0,int typ=1);
           /* tworzy obraz terenu (albo tlo terenu), jesli CzyZPixmapy=0
	      to tworzy obrazy domyslne terenu, wpp obrazy z pixmapy,
	      jesli typ=1 to teren, wpp tlo terenu */
    void tworzTeren(Para,int CzyZPizmapy=0);
            /* tworzy obraz terenu albo domyslny albo z pixmapy */
    void tworzTloTerenu(Para,int CzyZPizmapy=0);
            /* tworzy obraz tla terenu albo domyslny albo z pixmapy */
    void sprawdzTeren();
            /* sprawdza czy zaszla jakas zmiana w terenie lub w tle terenu 
              jesli tak to aktualizuje rysunek planszy (modyfikuje mape terenu)*/
};/* ObrazPlanszyAbs */

/* klasa RozaWiatrow - klasa pomocnicza wewnetrza klasy Obraz
   jest to windget zawierajacy "scrollbary" obrazu */
class RozaWiatrow : public QWidget {
    Q_OBJECT
public:
    RozaWiatrow(QWidget* parent=0,const char* name=0, WFlags f=0);
};/* RozaWiatrow */

/* klasa Obraz - wewnetrzy widget ObrazuPlanszyAbs zawierajacy powierzchnie planszy
 */     
class Obraz : public QWidget, public QwAbsSpriteFieldView
{
    Q_OBJECT
public:
    Obraz(QwSpriteField* viewing=0, QWidget* parent=0, const char* name=0, WFlags f=0);
    ~Obraz();

    virtual QRect viewArea() const;
    virtual bool preferDoubleBuffering() const;
    virtual void beginPainter(QPainter&);
    virtual void flush(const QRect& area);
    virtual void updateGeometries();
          QPoint wspNaObrazie(QPoint);/* zwraca wspolrzedne bezwzgledne na rysunku planszy */
	  void save(); /* zapisuje rysunek calej planszy do pliku ../obrazki/plansza.png*/
	  void save(const char*);/*  ---- || --- do zadanego pliku */
signals:
    void mousePress(QMouseEvent*);
    void mouseMove(QMouseEvent*);
    void mouseRelease(QMouseEvent*);
	  
protected:
    virtual void paintEvent(QPaintEvent *);
    virtual void resizeEvent(QResizeEvent *);
    void mousePressEvent(QMouseEvent*);
    void mouseReleaseEvent(QMouseEvent*);
    void mouseMoveEvent(QMouseEvent*);
    virtual int hSteps() const;
    virtual int vSteps() const;

protected slots:
    void vScroll(int);
    void hScroll(int);
    void _vScroll(int);  /* przesuwa w pionie wyswietlany fragment o zadana ilosc */
    void _hScroll(int);  /* przesuwa w poziomie wyswietlany fragment */


private:
    QPixmap offscr;
    
    RozaWiatrow *roza;
    
    QScrollBar hscroll;
    QScrollBar vscroll;
    int vscrpv;
    int hscrpv;
};/* Obraz */