<file_sep>using System;
using System.Collections.Generic;
using System.Text;

namespace Photo
{
    class Wyszukiwanie : IWyszukiwanie
    {
        private List<string> wynik = new List<string>();

        #region IWyszukiwanie Members

        public void And(IWyszukiwanie W)
        {
            wynik.AddRange(((Wyszukiwanie)W).wynik);
        }

        public void Or(IWyszukiwanie W)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void And(string Tabela, string Wartosc)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void Or(string Tabela, string Wartosc)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void And(string WyrazenieSQL)
        {
            wynik.Add(WyrazenieSQL);
        }

        public void Or(string WyrazenieSQL)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public IZdjecie[] PodajWynik()
        {
            List<MiniaturaControl> wynik = new List<MiniaturaControl>();
            foreach (string plik in this.wynik)
            {
                MiniaturaControl mini = new MiniaturaControl();
                mini.ImageLocation = plik;
                wynik.Add(mini);
            }
            return wynik.ToArray();
        }

        #endregion
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Text;
using System.Data.SQLite;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;
using System.ComponentModel;
using System.Drawing;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.IO;
using System.Collections;

namespace Photo
{
    /// <summary>
    /// Klasa do korzystania z bazy danych SQLite. Zawiera wszystkie metody potrzebne do obsługi bazy danych
    /// </summary>
    class Db
    {
        private string DBfile;
        private SQLiteConnection conn;

        /// <summary>
        /// Konstrunktor. Jeżeli baza jeszcze nie jest stworzona to jest tworzona
        /// </summary>
        public Db()
        {
            DBfile = Config.katalogAplikacji + "\\" + Config.plikBazy;

            if (System.IO.File.Exists(DBfile) == false)
            {
                SQLiteConnection.CreateFile(DBfile);
                this.Polacz();
                this.UtworzTabele();
                this.Rozlacz();
            }
        }

        /// <summary>
        /// Metoda tworząca wszystkie tabele bazy potrzebne w aplikacji
        /// </summary>
        private void UtworzTabele()
        {
            try
            {
                //SQLiteTransaction dd = conn.BeginTransaction()
                //MessageBox.Show("przed utworzono cd");

                using (SQLiteTransaction dbTrans = conn.BeginTransaction())
                {
                    WykonajQuery("create table CD" +
                                 "(" +
                                      "serial varchar(50) primary key," +
                                      "nazwa varchar(100)" +
                                 ");");

                    WykonajQuery("create table Zdjecie" +
                                 "(" +
                                      "id_zdjecia integer primary key autoincrement," +
                                      "sciezka varchar(200)," +
                                      "data_dodania date," +
                                      "data_wykonania date," +
                                      "komentarz varchar(250)," +
                                      "autor varchar(30)," +
                                      "nazwa_pliku varchar(50)," +
                                      "orientacja integer," +
                                      "cd varchar(50) references CD(serial) on delete cascade on update cascade" +
                                 ");");


                    WykonajQuery("create table Tag" +
                                 "(" +
                                      "id_tagu integer primary key autoincrement," +
                                      "nazwa varchar(100)," +
                                      "album integer," +
                                      "unique(nazwa,album)" +
                                 ");");

                    WykonajQuery("create table TagZdjecia" +
                                 "(" +
                                      "id_zdjecia integer references Zdjecie(id_zdjecia)," +
                                      "id_tagu integer references Tag(id_tagu)" +
                                 ");");

                    //*/
                    //MessageBox.Show("utworzono baze");

                    dbTrans.Commit();

                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message);
            }
        }
        /// <summary>
        /// Metoda która zestawia połaczenie z plikiem bazy
        /// </summary>
        public void Polacz()
        {
            this.conn = new SQLiteConnection("Data Source=" + DBfile + ";Version=3;");    
            conn.Open();
        }

        /// <summary>
        /// Metoda kończąca połączenie z plikiem bazy
        /// </summary>
        public void Rozlacz()
        {
            conn.Close();
        }

        /// <summary>
        /// Metoda do szybkiego wstawiania dużej ilości danych
        /// </summary>
        /// <param name="fields">tablica dwu-wymiarowa z polami tworzącymi kolejne rekordy</param>
        /// <param name="parameters">string z parametrami jakie wpisujemy do tabeli</param>
        /// <param name="tableName">nazwa tabeli</param>
        public void SzybkieInserty(string tableName, string parameters, string[,] fields)
        {
            using (SQLiteTransaction dbTrans = conn.BeginTransaction())
            {
                using (SQLiteCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = "insert into " + tableName + " values(" + parameters + ");";

                    SQLiteParameter[] sqlparams = new SQLiteParameter[fields.GetLength(1)];

                    for (int i = 0; i < fields.GetLength(1); i++)
                    {
                        sqlparams[i] = cmd.CreateParameter();
                        cmd.Parameters.Add(sqlparams[i]);
                    }

                    for (int i = 0; i < fields.GetLength(0); i++)
                    {
                        for (int j = 0; j < fields.GetLength(1); j++)
                        {
                            sqlparams[j].Value = fields[i, j];
                        }
                        cmd.ExecuteNonQuery();
                    }
                    dbTrans.Commit();
                }
            }
        }

        /// <summary>
        /// Metoda która wykonuje zapytanie sql i zwraca adapter z którego użytkownik będzie mógł wyłuskać dane jakie potrzebuje
        /// </summary>
        /// <param name="forEdit">pole określające czy ma być edytowalne czy nie</param>
        /// <param name="query">zapytanie sql</param>
        /// <returns>zwraca SQLiteDataAdapter</returns>
        public SQLiteDataAdapter PobierzAdapter(string query, bool forEdit)
        {
            SQLiteDataAdapter sqladapt = new SQLiteDataAdapter(query, conn);
            DataSet dataSet = new DataSet("Dane");
            if (forEdit)
            {
                new SQLiteCommandBuilder(sqladapt);
            }
            return sqladapt;
        }

        /// <summary>
        /// Metoda zwracająca DataSet. Pobiera dane z SQLiteDataAdapter-a
        /// </summary>
        /// <param name="ad">SQLiteDataAdapter</param>
        /// <returns>zwraca DataSet</returns>
        public DataSet PobierzDane(SQLiteDataAdapter ad)
        {
            DataSet dataSet = new DataSet("Dane");
            ad.Fill(dataSet);
            return dataSet;
        }

        /// <summary>
        /// Metoda wykonująca zapytanie typu 'select' i zwracająca dane w obiekcie DataSet
        /// </summary>
        /// <param name="select">zapytanie sql typu 'select'</param>
        /// <returns>zwraca wynik w DataSet</returns>
        public DataSet Select(string select)
        {
            SQLiteDataAdapter sqladapt = new SQLiteDataAdapter(select, conn);
            DataSet dataSet = new DataSet("Dane");
            //MessageBox.Show(select);
            sqladapt.Fill(dataSet);
            return dataSet;
        }

        /// <summary>
        /// Metoda wykonująca zapytanie sql
        /// </summary>
        /// <param name="query">zapytanie sql</param>
        public int WykonajQuery(string query)
        {
            SQLiteCommand cmd = conn.CreateCommand();
            cmd.CommandText = query;
            return cmd.ExecuteNonQuery();
        }

        /// <summary>
        /// Metoda wstawiająca rekord do tabeli
        /// </summary>
        /// <param name="parameters">string z parametrami</param>
        /// <param name="tableName">nazwa tabeli</param>
        public void Insert(string tableName, string parameters)
        {
            using (SQLiteTransaction dbTrans = conn.BeginTransaction())
            {
                using (SQLiteCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = "insert into " + tableName + " values(" + parameters + ");";

                    cmd.ExecuteNonQuery();

                    dbTrans.Commit();
                }
            }
        }

        /// <summary>
        /// Metoda wstawiająca rekord ale nie trzeba podawać wszystkich parametrów
        /// </summary>
        /// <param name="parameters">string z parametrami</param>
        /// <param name="pola">string z polami</param>
        /// <param name="tableName">nazwa tabeli</param>
        public void Insert_czesci(string tableName, string pola, string parameters)
        {
            using (SQLiteTransaction dbTrans = conn.BeginTransaction())
            {
                using (SQLiteCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = "insert into " + tableName + "(" + pola + ") values(" + parameters + ");";

                    //MessageBox.Show("insert into " + tableName + "(" + pola + ") values(" + parameters + ");");

                    cmd.ExecuteNonQuery();

                    dbTrans.Commit();
                }
            }
        }

        /// <summary>
        /// Metoda usuwająca zawartość tabeli
        /// </summary>
        /// <param name="tableName">nazwa tabeli</param>
        public void Delete_zawartosci_tabeli(string tableName)
        {
            using (SQLiteTransaction dbTrans = conn.BeginTransaction())
            {
                using (SQLiteCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = "delete from " + tableName + ";";

                    cmd.ExecuteNonQuery();

                    dbTrans.Commit();
                }
            }
        }

        /// <summary>
        /// Metoda usuwająca rekordy o spełniejących warunkach
        /// </summary>
        /// <param name="po_where">warunki jakie muszą być spełnione aby rekord został usunięty</param>
        /// <param name="tableName">nazwa tabeli</param>
        public void Delete(string tableName, string po_where)
        {
            using (SQLiteTransaction dbTrans = conn.BeginTransaction())
            {
                using (SQLiteCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = "delete from " + tableName + " where " + po_where + ";";

                    //MessageBox.Show("delete from " + tableName + " where " + po_where + ";");

                    cmd.ExecuteNonQuery();

                    dbTrans.Commit();
                }
            }
        }

        /// <summary>
        /// Metoda uaktualniająca rekordy 
        /// </summary>
        /// <param name="parameters">parametry jakie występuja po 'set'</param>
        /// <param name="tableName">nazwa tabeli</param>
        public void Update(string tableName, string parameters)
        {
            using (SQLiteTransaction dbTrans = conn.BeginTransaction())
            {
                using (SQLiteCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = "update " + tableName + " set " + parameters + " ;";
                    //Console.WriteLine(cmd.CommandText);
                    cmd.ExecuteNonQuery();

                    dbTrans.Commit();
                }
            }
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    public partial class IIPhoto : Form
    {
        private Operacje operacje;

        public IIPhoto()
        {
            InitializeComponent();

            fileTree1.Fill();

            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            SetStyle(ControlStyles.EnableNotifyMessage, true);

            operacje = new Operacje();
            operacje.WczytajWbudowane();
            operacje.WczytajPluginy();
            operacje.WrzucNaToolBar(toolStripOperacje);
            operacje.ZazadanieOperacji += new ZazadanieOperacjiDelegate(przegladarkaZdjec.DodajOperacje);

            wyszukiwarkaControl1.wyszukiwacz_albumow = listaAlbumowControl;
            // zdarzenia wyszukiwania
            listaAlbumowControl.ZakonczonoWyszukiwanie +=
                new ZakonczonoWyszukiwanieDelegate(przegladarkaZdjec.Wypelnij);
            wyszukiwarkaControl1.ZakonczonoWyszukiwanie +=
                new ZakonczonoWyszukiwanieDelegate(przegladarkaZdjec.Wypelnij);
            fileTree1.ZakonczonoWyszukiwanie +=
                new ZakonczonoWyszukiwanieDelegate(przegladarkaZdjec.Wypelnij);
            // zaznaczane zdjecia
            //listaOpakowanControl.WybranoZdjecie +=
                //new WybranoZdjecieDelegate(informacjeControl.Zaladuj);
        }

        private void Alfa_Click(object sender, EventArgs e)
        {
            przegladarkaZdjec.RozpocznijEdycje();
        }

        private void Omega_Click(object sender, EventArgs e)
        {
            przegladarkaZdjec.ZakonczEdycje();
        }

        private void toolStripButton1_Click(object sender, EventArgs e)
        {
            przegladarkaZdjec.SetThumbnailView();
        }

        private void button1_Click(object sender, EventArgs e)
        {

            fileTree1.Delete();
            fileTree1.Fill();
            
        }
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Data;
using System.Text;
using System.Windows.Forms;
using System.Drawing.Imaging;

namespace Listview2
{
    public partial class ImageView : UserControl
    {
        public ImageView()
        {
            InitializeComponent();
        }

        public void setImage(Bitmap b)
        {
            this.Image = b;
            this.rescueBitmap = b;
            this.checkImagePosition();
            this.lmStartingPoint = new Point();
            this.lmEndPoint = new Point();
            this.selectedRectangle = new Rectangle(0, 0, 0, 0);
            //this.clearRect = false;
        }

        private Bitmap Image
        {
            get
            {
                return (Bitmap)this.pictureBox1.Image;
            }
            set
            {
                this.pictureBox1.Image = value;
            }
        }

        private void checkImagePosition() {
            if (this.Image != null)
            {
                int x, y;
                if (this.Width < Image.Width)
                {
                    x = 0;
                }
                else
                {
                    x = ((this.Width - Image.Width) / 2) ;
                }
                if (this.Height < Image.Height)
                {
                    y = 0;
                }
                else
                {
                    y = ((this.Height - Image.Height) / 2) ;
                }
                this.pictureBox1.Width = Image.Width;
                this.pictureBox1.Height = Image.Height;
                this.pictureBox1.Location = new Point(x+3, y+3);
            }
        }

        public void Zoom(double zoom) {
            this.Image = new Bitmap(this.rescueBitmap, (int)(rescueBitmap.Width * zoom), (int)(rescueBitmap.Height * zoom));
            this.checkImagePosition();
        }

        public void Crop()
        {
            if (selectedRectangle.Width != 0 && selectedRectangle.Height != 0)
            {
                this.DrawMyRectangle(selectedRectangle);
                if (selectedRectangle.Width < 0)
                {
                    selectedRectangle.X +=  selectedRectangle.Width;
                    selectedRectangle.Width *= -1;
                }
                if (selectedRectangle.Height < 0)
                {
                    selectedRectangle.Y += selectedRectangle.Height;
                    selectedRectangle.Height *= -1;
                }
                Bitmap cropped = new Bitmap(Math.Abs(selectedRectangle.Width), Math.Abs(selectedRectangle.Height), this.Image.PixelFormat);
                Graphics g = Graphics.FromImage(cropped);
                g.DrawImage(this.Image, new Rectangle(0, 0, cropped.Width, cropped.Height), selectedRectangle, GraphicsUnit.Pixel);
                g.Dispose();
                this.setImage(cropped);
            }
        }

        public void Rotate(int x)
        {
            this.Image.RotateFlip(RotateFlipType.Rotate90FlipNone);
        }

        public void toGrayScale() {
            this.data = this.Image.LockBits(new Rectangle(0, 0, this.Image.Width, this.Image.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            unsafe
            {
                byte tempC;
                byte* imgPtr = ( byte* )( data.Scan0 );
                for( int i = 0 ; i < data.Height ; i ++ )
                {
                      for( int j = 0 ;  j < data.Width ;  j ++ )
                      {
                          tempC = (byte)(((int)*(imgPtr) + (int)*(imgPtr + 1) + (int)*(imgPtr + 2))/3); 
                          *(imgPtr++) = tempC;
                          *(imgPtr++) = tempC;
                          *(imgPtr++) = tempC; 
                      }
                }
            }
            this.Image.UnlockBits(data);
			this.Refresh();
		}

        private Color MyGetPixel(int x, int y)
        {
            unsafe
            {
                byte* imgPtr = (byte*)(data.Scan0);
                imgPtr += y * data.Stride + x * 3;
                return Color.FromArgb(*(imgPtr++), *(imgPtr++), *imgPtr);
            }
        }

        private void MySetPixel(int x, int y, Color c)
        {
            unsafe
            {
                byte* imgPtr = (byte*)(data.Scan0);
                imgPtr += y * data.Stride + x * 3;
                *(imgPtr++) = c.R;
                *(imgPtr++) = c.G;
                *(imgPtr) = c.B;
            }
        }

        private void XorPixel(int x, int y, Color color) 
        {
            
            Color srcPixel = this.MyGetPixel(x, y);
            this.MySetPixel(x, y, Color.FromArgb(color.R ^ srcPixel.R, srcPixel.G ^ color.G, srcPixel.B ^ color.B));

        }

        private void DrawMyLine(Point srcPoint, Point destPoint)
        {
            int d, delta_A, delta_B, x, y;
            int dx = destPoint.X - srcPoint.X;
            int dy = destPoint.Y - srcPoint.Y;

            int inc_x = (dx >= 0) ? 1 : -1;
            int inc_y = (dy >= 0) ? 1 : -1;

            dx = Math.Abs(dx);
            dy = Math.Abs(dy);

            x = 0; y = 0;

            if (dx >= dy)
            {
                d = 2 * dy - dx;
                delta_A = 2 * dy;
                delta_B = 2 * (dy - dx);

                for (int i = 0; i < dx; i++)
                {
                    XorPixel(srcPoint.X + x, srcPoint.Y + y, Color.Gray);
                    if (d > 0)
                    {
                        d += delta_B;
                        x += inc_x;
                        y += inc_y;
                    }
                    else
                    {
                        d += delta_A;
                        x += inc_x;
                    }
                }

            }
            else
            {
                d = 2 * dx - dy;
                delta_A = 2 * dx;
                delta_B = 2 * (dx - dy);

                for (int i = 0; i < dy; i++)
                {
                    XorPixel(srcPoint.X + y, srcPoint.Y + x, Color.Gray);
                    if (d > 0)
                    {
                        d += delta_B;
                        y += inc_x;
                        x += inc_y;
                    }
                    else
                    {
                        d += delta_A;
                        x += inc_y;
                    }
                }
            }
        }

        private void DrawMyRectangle(Rectangle r)
        {
            this.data = this.Image.LockBits(new Rectangle(0, 0, this.Image.Width, this.Image.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            DrawMyLine(new Point(r.X, r.Y), new Point(r.X + r.Width, r.Y));
            DrawMyLine(new Point(r.X, r.Y), new Point(r.X, r.Y + r.Height));
            DrawMyLine(new Point(r.X + r.Width, r.Y), new Point(r.X + r.Width, r.Y + r.Height));
            DrawMyLine(new Point(r.X, r.Y + r.Height), new Point(r.X + r.Width, r.Y + r.Height));
            XorPixel(r.X, r.Y, Color.Gray);
            XorPixel(r.X + r.Width, r.Y + r.Height, Color.Gray);
            this.Image.UnlockBits(data);
        }

        protected override void OnVisibleChanged(EventArgs e)
        {
            base.OnVisibleChanged(e);
            this.checkImagePosition();
        }

        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);
            this.checkImagePosition();
        }

        private void onMouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                /*if (clearRect)
                {
                    this.DrawMyRectangle(selectedRectangle);
                    clearRect = false;
                }*/
                isDrag = true;
                moving = false;
                this.lmStartingPoint = new Point(e.X, e.Y);
                this.Refresh();
            }
            else if (e.Button == MouseButtons.Right)
            {
                isDrag = true;
                this.rmStartingPoint = new Point(e.X, e.Y);
            }
        }

        private void onMouseUp(object sender, MouseEventArgs e)
        {
            
            isDrag = false;
            if (e.Button == MouseButtons.Left)
            {
                //this.lmEndPoint = new Point(e.X, e.Y);
                this.Refresh();
            }
            else if (e.Button == MouseButtons.Right)
            {
                this.rmEndPoint = new Point(e.X, e.Y);
                this.DrawMyRectangle(new Rectangle(rmStartingPoint.X, rmStartingPoint.Y, rmEndPoint.X - rmStartingPoint.X, rmEndPoint.Y - rmStartingPoint.Y));
                this.Refresh();
            }
        }

        private void onMouseMove(object sender, MouseEventArgs e)
        {
            if (isDrag)
            {
                if (e.Button == MouseButtons.Left)
                {
                    int maxX, maxY;

                    if (e.X >= this.pictureBox1.Width)
                        maxX = this.pictureBox1.Width - 1;
                    else if (e.X < 0)
                        maxX = 0;
                    else
                        maxX = e.X;
                    if (e.Y >= this.pictureBox1.Height)
                        maxY = this.pictureBox1.Height - 1;
                    else if (e.Y < 0)
                        maxY = 0;
                    else
                        maxY = e.Y;

                    //if (moving == true)
                        this.DrawMyRectangle(selectedRectangle);
                    //else
                    //    moving = true;

                    selectedRectangle = new Rectangle(lmStartingPoint.X, lmStartingPoint.Y, maxX - lmStartingPoint.X, maxY - lmStartingPoint.Y);

                    this.DrawMyRectangle(selectedRectangle);
                    this.Refresh();
                }
            }
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Drawing.Imaging;

namespace Photo
{
    /// <summary>
    /// Formatka wyswietlana, jesli zostanie zazadane wyswietlenie zdjecia z kolekcji,
    /// a nie zostanie odnaleziono one na dysku twardym. Formatka umozliwa odnalezienie 
    /// brakujacych zdjec.
    /// </summary>
    public partial class ZnajdzPliki : Form
    {
        private string plikSzukany;
        private string plikOdnaleziony;
        private long id;

        /// <summary>
        /// Propercja zwracajaca odnaleziony plik
        /// </summary>
        public string OdnalezionyPlik
        {
            get
            {
                return plikOdnaleziony;
            }
        }

        /// <summary>
        /// Konstruktor 
        /// </summary>
        /// <param name="kv">Para identyfikatora i lokalizacji szukanego zdjecia</param>
        public ZnajdzPliki(KeyValuePair<long, string> kv)
        {
            InitializeComponent();
            plikSzukany = kv.Value;
            id = kv.Key;
            Znajdz();
        }

        private void Znajdz()
        {
            textBox1.Text = "Plik '" + plikSzukany + "' nie został odnaleziony na dysku. Proszę podać lokalizację, w której wykonać jego poszukiwanie.";
        }

        private void OK_Button_Click(object sender, EventArgs e)
        {
            if (!textBox2.Text.Equals("")) {
                List<string> pliki = new List<string>();
                pliki.AddRange(Directory.GetFiles(textBox2.Text, "*.jpg"));
                pliki.AddRange(Directory.GetFiles(textBox2.Text, "*.jpeg"));

                PropertyItem[] items;
                string iiphotoTag;
                foreach (string plik in pliki)
                {
                    items = Zdjecie.PobierzDaneExif(plik);
                    foreach (PropertyItem item in items)
                    {
                        if (item.Id == PropertyTags.IIPhotoTag)
                        {
                            iiphotoTag = PropertyTags.ParseProp(item);
                            if (long.Parse(iiphotoTag) == id)
                            {
                                plikOdnaleziony = plik;
                                this.Close();
                                return;
                            }
                        }
                    }
                }

            }
            MessageBox.Show("Nie znaleziono szukanego pliku w podanej lokalizacji!");
            this.Close();
            return;
        }

        private void Pomin_Button_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        private void PominAll_Button_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            if (folderBrowserDialog1.ShowDialog() == DialogResult.OK)
            {
                textBox2.Text = folderBrowserDialog1.SelectedPath;
            }
        }

        internal bool czyOdnaleziono()
        {
            return (plikOdnaleziony != null);
        }

        private void Usun_Click(object sender, EventArgs e)
        {
            Zdjecie.UsunZAlbumu(id);
        }
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.Data;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    public partial class PrzegladarkaZdjec : UserControl
    {
        public PrzegladarkaZdjec()
        {
            InitializeComponent();
        }
        public void SetThumbnailView()
        {
            thumbnailView1.Visible = true;
            imageView1.Visible = false;
        }
        public void SetImageView()
        {
            imageView1.Visible = true;
            thumbnailView1.Visible = false;
        }
        public WidokMiniatur Thumbnailview
        {
            get
            {
                return thumbnailView1;
            }
        }
        public WidokZdjecia Imageview
        {
            get
            {
                return imageView1;
            }
        }

        /*public void Zoom(double zoom)
        {
            if (imageView1.Visible == true)
            {
                imageView1.Zoom(zoom);
            }
            else if (thumbnailView1.Visible == true)
            {
                thumbnailView1.ShowImages(zoom);
            }
        }*/

        /*public void Crop()
        {
            if (imageView1.Visible == true)
            {
                imageView1.Crop();
            }
        }*/

        /*public void toGrayScale()
        {
            if (imageView1.Visible == true)
            {
                imageView1.toGrayScale();
            }
        }*/

        private void mouseDoubleClick(object sender, MouseEventArgs e)
        {
            ListViewItem listViewItem = ((WidokMiniatur)sender).FocusedItem;
            Zdjecie z = (Zdjecie)thumbnailView1[listViewItem.ImageIndex];
            this.imageView1.setImage(z);
            this.SetImageView();
            if (WybranoZdjecie != null)
                WybranoZdjecie(z);
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    public partial class Photo : Form
    {
        private Operacje operacje;

        public Photo()
        {
            InitializeComponent();

            operacje = new Operacje();
            operacje.WczytajWbudowane();
            operacje.WczytajPluginy();
            operacje.WrzucNaToolBar(toolStripOperacje);
            operacje.ZazadanieOperacji += new ZazadanieOperacjiDelegate(listaOpakowanControl.DodajOperacje);

            wyszukiwarkaControl1.wyszukiwacz_albumow = listaAlbumowControl;
            // zdarzenia wyszukiwania
            listaAlbumowControl.ZakonczonoWyszukiwanie +=
                new ZakonczonoWyszukiwanieDelegate(listaOpakowanControl.WynikWyszukiwania);
            wyszukiwarkaControl1.ZakonczonoWyszukiwanie +=
                new ZakonczonoWyszukiwanieDelegate(listaOpakowanControl.WynikWyszukiwania);
            // zaznaczane zdjecia
            listaOpakowanControl.WybranoZdjecie +=
                new WybranoZdjecieDelegate(informacjeControl.Zaladuj);
        }

        private void Alfa_Click(object sender, EventArgs e)
        {
            listaOpakowanControl.RozpocznijEdycje();
        }

        private void Omega_Click(object sender, EventArgs e)
        {
            listaOpakowanControl.ZakonczEdycje();
        }
    }
}<file_sep>﻿using System;
using System.Collections.Generic;
using System.Drawing;
using System.Text;

namespace Photo
{
    public class Zdjecie : IZdjecie
    {
        Bitmap bitmap;
        List<PolecenieOperacji> operacje = new List<PolecenieOperacji>();

        public Bitmap Bitmap
        {
            set
            {
                bitmap.Tag = this;
                bitmap = Bitmap;
            }
            get
            {
                return bitmap;
            }
        }

        #region Zdjecie Members

        public void DodajOperacje(PolecenieOperacji polecenie)
        {
            operacje.Add(polecenie);
        }

        public void WykonajOperacje()
        {
            if (operacje.Count > 0)
            {
                foreach (PolecenieOperacji polecenie in operacje)
                {
                    polecenie.Wykonaj(bitmap);
                }
                if (ZmodyfikowanoZdjecie != null)
                    ZmodyfikowanoZdjecie(null, this, RodzajModyfikacjiZdjecia.Zawartosc);
            }
        }

        public void UsunWszystkieOperacje()
        {
            operacje.Clear();
        }

        public Image Miniatura
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public event ZmodyfikowanoZdjecieDelegate ZmodyfikowanoZdjecie;

        #endregion
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.Data;
using System.Text;
using System.Windows.Forms;
using System.Data.SQLite;
using System.Data.SqlClient;
using System.IO;

namespace Photo
{
    /// <summary>
    /// Kontrolka sluzaca do przegladania zdjec. Posiada dwa tryby wyswietlania - widok miniatur oraz widok zdjecia. 
    /// Implementuje interfejs IOpakowanieZdjec.
    /// </summary>
    public partial class PrzegladarkaZdjec : UserControl, IOpakowanieZdjec
    {
        /// <summary>
        /// Kontruktor bezparametryczny
        /// </summary>
        public PrzegladarkaZdjec()
        {
            InitializeComponent();
            Context = new ContextMenuStrip();
        }
        /// <summary>
        /// Ustawia jako aktywny widok miniatur
        /// </summary>
        public void SetThumbnailView()
        {
            panele.SelectedTab = miniatury1Tab;
        }
        /// <summary>
        /// Ustawia jako aktywny widok zdjecia
        /// </summary>
        public void SetImageView()
        {
            panele.SelectedTab = zdjecie1Tab;
        }

        /// <summary>
        /// Propercja zwracajaca obiekt bedacy widokiem miniatur
        /// </summary>
        public WidokMiniatur Thumbnailview
        {
            get
            {
                return widokMiniatur1;
            }
        }

        /// <summary>
        /// Propercja zwracajaca obiekt bedacy widokiem zdjecia
        /// </summary>
        public WidokZdjecia Imageview
        {
            get
            {
                return widokZdjecia1;
            }
        }

        /// <summary>
        /// Propercja zwracajaca aktywny widok
        /// </summary>
        public IOpakowanieZdjec AktywneOpakowanie
        {
            get
            {
                if (panele.SelectedTab == miniatury1Tab)
                {
                    return Thumbnailview;
                }
                else
                {
                    return Imageview;
                }
            }
        }

        #region IOpakowanieZdjec Members

        /// <summary>
        /// Propercja zwracajaca zdjecie o podanym indeksie z aktywnego widoku
        /// </summary>
        /// <param name="numer">Indeks zdjecia</param>
        /// <returns>Obiekt implementujacy interfejs IZdjecie</returns>
        public IZdjecie this[int numer]
        {
            get { return AktywneOpakowanie[numer]; }
        }

        /// <summary>
        /// Propercja zwracajaca ilosc zdjec z aktywnego widoku
        /// </summary>
        public int Ilosc
        {
            get { return AktywneOpakowanie.Ilosc; }
        }

        /// <summary>
        /// Metoda dodajaca zdjecie do widoku miniatur
        /// </summary>
        /// <param name="zdjecie"></param>
        public void Dodaj(IZdjecie zdjecie)
        {
            Thumbnailview.Dodaj(zdjecie);
            if (AktywneOpakowanie != Thumbnailview)
                SetThumbnailView();
        }

        /// <summary>
        /// Metoda uzuwajaca podane zdjecie z aktywnego widoku
        /// </summary>
        /// <param name="zdjecie">Obiekt do usuniecia</param>
        public void Usun(IZdjecie zdjecie)
        {
            AktywneOpakowanie.Usun(zdjecie);
        }

        /// <summary>
        /// Metoda oprozniajaca zawartosc aktywnego widoku
        /// </summary>
        public void Oproznij()
        {
            AktywneOpakowanie.Oproznij();
        }

        /// <summary>
        /// Propercja zwracajaca wybrane (zaznaczone) zdjecia z aktywnego widoku
        /// </summary>
        public IZdjecie[] WybraneZdjecia
        {
            get
            {
                return AktywneOpakowanie.WybraneZdjecia;
            }
        }


        /// <summary>
        /// Metoda ustawiacjaca aktywny widok w tryb szybkiej edycji
        /// </summary>
        public void RozpocznijEdycje()
        {
            AktywneOpakowanie.RozpocznijEdycje();
        }

        /// <summary>
        /// Metoda konczaca tryb szybkiej edycji na aktywnym widoku
        /// </summary>
        public void ZakonczEdycje()
        {
            AktywneOpakowanie.ZakonczEdycje();
        }

        /// <summary>
        /// Metoda dodajaca operacje do wykonania na zdjeciu/ach z aktywnego widoku
        /// </summary>
        /// <param name="operacja">Obiekt bedacy poleceniem operacji</param>
        public void DodajOperacje(PolecenieOperacji operacja)
        {
            AktywneOpakowanie.DodajOperacje(operacja);
        }

        /// <summary>
        /// Metoda usuwajaca wszystkie operacje na zdjeciu/ach z aktywnego widoku
        /// </summary>
        public void UsunWszystkieOperacje()
        {
            AktywneOpakowanie.UsunWszystkieOperacje();
        }

        /// <summary>
        /// Metoda wypelniajaca zdjeciami i katalogami widok miniatur.
        /// </summary>
        /// <param name="zdjecia">Tablica obiektow do wyswietlenia</param>
        /// <param name="katalogi">Tablica katalogow do wyswietlenia</param>
        /// <param name="CzyZDrzewa">Zmienna informujaca czy podane dane pochodza z drzewa katalogow czy nie</param>
        public void Wypelnij(IZdjecie[] zdjecia, Katalog[] katalogi, bool CzyZDrzewa)
        {
            if (AktywneOpakowanie != Thumbnailview)
                SetThumbnailView();
            Thumbnailview.Wypelnij(zdjecia, katalogi, CzyZDrzewa);
        }

        #endregion

        private void widokMiniatur_Click(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Right)
            {
                List<Zdjecie> lista = ZwrocZdjeciaZaznaczone();
                if (lista.Count != 0)
                {
                    Context.Items.Clear();
                    ToolStripItem toolStripItem;                

                    if (lista.Count == 1)
                    {                        
                        if (lista[0].CzyUstawioneId() == false)
                        {
                            toolStripItem = Context.Items.Add("Dodaj do kolekcji", Properties.Resources.dodaj_do_kolekcji);
                            toolStripItem.Click += new EventHandler(DodajZaznaczenieDoKolekcji);
                            toolStripItem = Context.Items.Add("Dodaj do Albumu",Properties.Resources.Contacts_d);
                            toolStripItem.Click += new EventHandler(DodajZaznaczoneDoAlbumu);
                        }
                        else
                        {
                            toolStripItem = Context.Items.Add("Uaktualizuj Tagi", Properties.Resources.new_tag);
                            toolStripItem.Click += new EventHandler(UaktualizujTagi);
                            toolStripItem = Context.Items.Add("Uaktualizuj Albumy", Properties.Resources.Contacts_d);
                            toolStripItem.Click += new EventHandler(DodajZaznaczoneDoAlbumu);
                            toolStripItem = Context.Items.Add("Aktualizuj w Bazie",Properties.Resources.aktualizacja_bazy);
                            toolStripItem.Click += new EventHandler(AktualizujBaze);
                            toolStripItem = Context.Items.Add("Usuń Tagi", Properties.Resources.delete_tag);
                            toolStripItem.Click += new EventHandler(UsunTagi);
                            toolStripItem = Context.Items.Add("Usuń Albumy",Properties.Resources.Recycle_Bin_Full_d);
                            toolStripItem.Click += new EventHandler(UsunAlbumy);
                            toolStripItem = Context.Items.Add("Usuń z kolekcji",Properties.Resources.usun_z_kolekcji);
                            toolStripItem.Click += new EventHandler(UsunZKolekcji);                            
                        }
                        toolStripItem = Context.Items.Add("Usuń zdjecie",Properties.Resources.Recycle_Bin_Empty_d);
                        toolStripItem.Click += new EventHandler(UsunZdjecie);
                    }
                    else
                    {
                        bool stan = false;

                        foreach (Zdjecie z in lista)
                        {
                            if (z.CzyUstawioneId() == true)
                            {
                                stan = true;
                                break;
                            }
                        }

                        if (stan == true)
                        {
                            toolStripItem = Context.Items.Add("Dodaj zaznaczenie do kolekcji", Properties.Resources.dodaj_do_kolekcji);
                            toolStripItem.Click += new EventHandler(DodajZaznaczenieDoKolekcji);
                            toolStripItem = Context.Items.Add("Dodaj Tagi", Properties.Resources.new_tag);
                            toolStripItem.Click += new EventHandler(UaktualizujTagi);
                            toolStripItem = Context.Items.Add("Dodaj zaznaczone do Albumów", Properties.Resources.Contacts_d);
                            toolStripItem.Click += new EventHandler(DodajZaznaczoneDoAlbumu);
                            toolStripItem = Context.Items.Add("Aktualizuj zaznaczone w Bazie",Properties.Resources.aktualizacja_bazy);
                            toolStripItem.Click += new EventHandler(AktualizujBaze);
                            toolStripItem = Context.Items.Add("Usuń Tagi z zaznaczenia", Properties.Resources.delete_tag);
                            toolStripItem.Click += new EventHandler(UsunTagi);
                            toolStripItem = Context.Items.Add("Usuń Albumy z zaznaczemia",Properties.Resources.Recycle_Bin_Full_d);
                            toolStripItem.Click += new EventHandler(UsunAlbumy);
                            toolStripItem = Context.Items.Add("Usuń zaznaczenie z kolekcji",Properties.Resources.usun_z_kolekcji);
                            toolStripItem.Click += new EventHandler(UsunZKolekcji);                            
                        }
                        else
                        {
                            toolStripItem = Context.Items.Add("Dodaj zaznaczenie do kolekcji", Properties.Resources.dodaj_do_kolekcji);
                            toolStripItem.Click += new EventHandler(DodajZaznaczenieDoKolekcji);
                            toolStripItem = Context.Items.Add("Dodaj zaznaczone do Albumów", Properties.Resources.Contacts_d);
                            toolStripItem.Click += new EventHandler(DodajZaznaczoneDoAlbumu);                            
                        }

                        toolStripItem = Context.Items.Add("Usuń zaznaczone zdjecia",Properties.Resources.Recycle_Bin_Empty_d);
                        toolStripItem.Click += new EventHandler(UsunZdjecie);
                    }                   
                    

                    Context.Show(this.Thumbnailview, new Point(e.X, e.Y));
                }
            }
        }

        private List<Zdjecie> ZwrocZdjeciaZaznaczone()
        {
            List<Zdjecie> lista = new List<Zdjecie>();
            Zdjecie[] zdjecia = (Zdjecie[])Thumbnailview.WybraneZdjecia;
            if (zdjecia.Length != 0)
            {
                for (int i = 0; i < zdjecia.Length; i++)
                {
                    lista.Add(zdjecia[i]);
                }
            }
            return lista;
        }

        private void UsunTagi(object sender, EventArgs e)
        {
            List<Zdjecie> lista = ZwrocZdjeciaZaznaczone();

            foreach (Zdjecie z in lista)
            {
                if (z.CzyUstawioneId() == true)
                {
                    z.UsunTagi();
                    z.WypelnijListeTagow();
                }
            }
            this.Thumbnailview.ZresetujTagi();
        }

        private void UsunAlbumy(object sender, EventArgs e)
        {
            List<Zdjecie> lista = ZwrocZdjeciaZaznaczone();

            foreach (Zdjecie z in lista)
            {
                if (z.CzyUstawioneId() == true)
                {
                    z.UsunAlbumy();                    
                }
            }
            this.Thumbnailview.ZresetujTagi();
        }

        private void UsunZKolekcji(object sender, EventArgs e)
        {
            List<Zdjecie> lista = ZwrocZdjeciaZaznaczone();

            if (Thumbnailview.MiniaturyZDrzewa == true)
            {
                foreach (Zdjecie z in lista)
                {
                    if (z.CzyUstawioneId() == true)
                    {
                        z.UsunZdjecieZBazy();
                        z.UsunId();
                        Thumbnailview.ZmodyfikowanoZdjecie(null, z, RodzajModyfikacjiZdjecia.Zawartosc);
                    }
                }
            }
            else
            {
                foreach (Zdjecie z in lista)
                {
                    
                    z.UsunZdjecieZBazy();
                    z.UsunId();
                    Thumbnailview.Usun(z);
                }
                Thumbnailview.Odswiez();
            }
        }
        

        private void DodajTagiDlaKilku(object sender, EventArgs e)
        {
            List<Zdjecie> lista = ZwrocZdjeciaZaznaczone();

            Dodaj_tagi_do_zdjecia dtdz = new Dodaj_tagi_do_zdjecia(lista,false);
            dtdz.Show();
        }

        private void UaktualizujTagi(object sender, EventArgs e)
        {
            List<Zdjecie> lista = ZwrocZdjeciaZaznaczone();

            Dodaj_tagi_do_zdjecia dtdz = new Dodaj_tagi_do_zdjecia(lista,false);
            dtdz.ShowDialog();
            Thumbnailview.Odswiez();            
        }

        private void AktualizujBaze(object sender, EventArgs e)
        {
            List<Zdjecie> lista = ZwrocZdjeciaZaznaczone();

            foreach (Zdjecie z in lista)
            {
                z.AktualizujBaze();
            }
        }

        private void DodajZaznaczenieDoKolekcji(object sender, EventArgs e)
        {
            List<Zdjecie> lista = ZwrocZdjeciaZaznaczone();

            if (lista.Count != 0)
            {
                dodaj_kolekcje_do_bazy(lista);
            }
        }

        private void DodajZaznaczoneDoAlbumu(object sender, EventArgs e)
        {
            List<Zdjecie> lista = ZwrocZdjeciaZaznaczone();

            if (lista.Count != 0)
            {
                Dodaj_albumy_do_zdjecia dadz = new Dodaj_albumy_do_zdjecia(lista, this, lista[0].Path);
                dadz.Show();
                //Dodaj_katalog_do_bazy ddk = new Dodaj_katalog_do_bazy(lista[0].Path, this);
                //ddk.Show();
            }

        }

        /// <summary>
        /// Metoda dodajaca zbior zdjec do bazy danych uzytkownika
        /// </summary>
        /// <param name="lista">Kolekcja Zdjec do dodania</param>
        public void dodaj_kolekcje_do_bazy(List<Zdjecie> lista)
        {
            StringBuilder sb = new StringBuilder("Nie udało się dodać do kolekcji nastepujących zdjęć:\n");
            bool nieUdaloSie = false;
            foreach (Zdjecie z in lista)
            {
                if (z.DodajDoKolekcji() == false)
                {
                    sb.Append(z.Path + "\n");
                    if (nieUdaloSie == false)
                    {
                        nieUdaloSie = true;
                    }
                }
                else
                {
                    Thumbnailview.ZmodyfikowanoZdjecie(null, z, RodzajModyfikacjiZdjecia.Zawartosc);                 
                }
            }
            if (nieUdaloSie)
                MessageBox.Show(sb.ToString());            
        }

        /// <summary>
        /// Metoda dodajaca zaznaczone zdjecia do bazy danych
        /// </summary>
        /// <returns>Lista lokalizacji zdjec dodanych do bazy</returns>
        public List<string> dodaj_kolekcje_do_bazy()
        {
            List<Zdjecie> lista = ZwrocZdjeciaZaznaczone();
            List<string> lista_sciezek = new List<string>();
            StringBuilder sb = new StringBuilder("Nie udało się dodać do kolekcji nastepujących zdjęć:\n");
            bool nieUdaloSie = false;

            foreach (Zdjecie z in lista)
            {
                if (z.DodajDoKolekcji() == false)
                {
                    sb.Append(z.Path + "\n");
                    if (nieUdaloSie == false)
                    {
                        nieUdaloSie = true;
                    }
                }
                else
                {
                    Thumbnailview.ZmodyfikowanoZdjecie(null, z, RodzajModyfikacjiZdjecia.Zawartosc);
                    lista_sciezek.Add(z.Path);
                }
            }
            if (nieUdaloSie)
                MessageBox.Show(sb.ToString());
            
            return lista_sciezek;
        }

        private void UsunZdjecie(object sender, EventArgs e)
        {
            bool usunieto = false;
            Zdjecie[] zdjecia = (Zdjecie[])Thumbnailview.WybraneZdjecia;
            if (zdjecia.Length != 0)
            {
                for (int i = 0; i < zdjecia.Length; i++)
                {
                    try
                    {
                        if (zdjecia[i].Usun())
                        {
                            if (usunieto == false)
                                usunieto = true;
                            Thumbnailview.Usun(zdjecia[i]);
                            zdjecia[i].Dispose();
                        }

                    }
                    catch (FileNotFoundException)
                    {
                        MessageBox.Show("Wybrane zdjęcie nie może zostać odnalezione!", "Błąd!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    }
                    catch (DirectoryNotFoundException)
                    {
                        MessageBox.Show("Katalog z wybranym zdjęciem nie może zostać odnaleziony!", "Błąd!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    }
                }
                if (usunieto)
                    Thumbnailview.Odswiez();
            }
        }

        private void widokMiniatur_selectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                Zdjecie[] zdjecia = (Zdjecie[])Thumbnailview.WybraneZdjecia;
                if (zdjecia != null & zdjecia.Length == 1)
                {
                    if (ZaznaczonoZdjecie != null)
                        ZaznaczonoZdjecie(zdjecia[0]);
                }
            }
            catch (FileNotFoundException)
            {
                MessageBox.Show("Wybrane zdjęcie nie może zostać odnalezione!", "Błąd!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
            catch (DirectoryNotFoundException)
            {
                MessageBox.Show("Katalog z wybranym zdjęciem nie może zostać odnaleziony!", "Błąd!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }

        private void panele_onSelectedIndexChanged(object sender, EventArgs e)
        {
            try
            {
                if (((TabControl)sender).SelectedTab == zdjecie1Tab && widokZdjecia1.czyZaladowaneZdjecie)
                {
                    if (ZaznaczonoZdjecie != null)
                        ZaznaczonoZdjecie(widokZdjecia1.Zdjecie);
                    Imageview.DrawMyRectangle(Imageview.selectedRectangle);
                }
                if (((TabControl)sender).SelectedTab == zdjecie1Tab)
                {
                    if (WlaczonoWidokZdjecia != null)
                        WlaczonoWidokZdjecia();
                }
                if (((TabControl)sender).SelectedTab == miniatury1Tab)
                {
                    if (WlaczonoWidokZdjecia != null)
                        WylaczonoWidokZdjecia();
                    if (widokZdjecia1.czyZaladowaneZdjecie)
                        Imageview.DrawMyRectangle(Imageview.selectedRectangle);
                }
            } catch (FileNotFoundException)
                {
                    MessageBox.Show("Wybrane zdjęcie nie może zostać odnalezione na dysku!", "Błąd!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
                catch (DirectoryNotFoundException)
                {
                    MessageBox.Show("Katalog z wybranym zdjęciem nie może zostać odnaleziony!", "Błąd!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
        }

        private void wybranoItem(ListViewItem listViewItem)
        {
            if ((WidokMiniatur.listViewTag)listViewItem.Tag == WidokMiniatur.listViewTag.zdjecie)
            {
                try
                {
                    Zdjecie[] z = new Zdjecie[] { (Zdjecie)Thumbnailview[listViewItem.ImageIndex - Thumbnailview.IloscKatalogow] };
                    this.widokZdjecia1.Wypelnij(z);
                    this.SetImageView();
                    if (WybranoZdjecie != null)
                        WybranoZdjecie(z[0]);
                }
                catch (FileNotFoundException)
                {
                    MessageBox.Show("Wybrane zdjęcie nie może zostać odnalezione na dysku!", "Błąd!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
                catch (DirectoryNotFoundException)
                {
                    MessageBox.Show("Katalog z wybranym zdjęciem nie może zostać odnaleziony!", "Błąd!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
            }
            else
            {
                try
                {
                    Katalog k = Thumbnailview.Katalogi[listViewItem.ImageIndex];
                    if (WybranoKatalog != null)
                        WybranoKatalog(k);
                    //MessageBox.Show("Wybrano katalog " + k.Path);
                }
                catch (DirectoryNotFoundException)
                {
                    MessageBox.Show("Wybrany katalog nie może zostać odnaleziony na dysku!", "Błąd!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
            }
        }

        private void widokMiniatur_DoubleClick(object sender, MouseEventArgs e)
        {
            ListViewItem listViewItem = ((WidokMiniatur)sender).FocusedItem;
            if (listViewItem != null)
                wybranoItem(listViewItem);
        }

        private void widokMiniatur1_keyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyData == Keys.Enter)
            {
                ListViewItem listViewItem = ((WidokMiniatur)sender).FocusedItem;
                if (listViewItem != null)
                    wybranoItem(listViewItem);
            }
            else if (e.KeyData == Keys.Back)
            {
                Katalog[] katalogi = Thumbnailview.Katalogi;
                for (int i = 0; i < katalogi.Length; i++) 
                {
                    if (katalogi[i].CzyDoGory == true)
                    {
                        if (WybranoKatalog != null)
                            WybranoKatalog(katalogi[i]);
                        break;
                    }
                }
            }
            else if (e.KeyData == Keys.R)
            {
                Rotate r = new Rotate(1);
                DodajOperacje(new PolecenieOperacji(r, r.PodajArgumenty().ToArray()));
            }
            else if (e.KeyData == Keys.L)
            {
                Rotate r = new Rotate(2);
                DodajOperacje(new PolecenieOperacji(r, r.PodajArgumenty().ToArray()));
            }
            else if (e.KeyData == (Keys.Control | Keys.F))
            {
                if (ZabierzFocus != null)
                    ZabierzFocus();
            }
            else if (e.KeyData == (Keys.Control | Keys.A))
            {
                for (int i = Thumbnailview.Katalogi.Length; i < Thumbnailview.Items.Count; i++)
                {
                    Thumbnailview.Items[i].Selected = true;
                }
            }
            else if (e.KeyData == (Keys.Control | Keys.S))
            {
                Thumbnailview.ZapiszWszystkiePliki();
            }
        }

        /// <summary>
        /// Metoda przeciagajaca Focus na widok miniatur
        /// </summary>
        /// <returns></returns>
        public bool WezFocus() {
            return widokMiniatur1.Focus();
        }

        private void widokZdjecia1_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyData == Keys.Space)
            {
                int nastepne = Imageview.Zdjecie.indeks + 1;
                if (nastepne >= Thumbnailview.Ilosc)
                {
                    nastepne = Thumbnailview.IloscKatalogow;
                    MessageBox.Show("Nie ma już więcej zdjęć w tym katalogu. Zostanie otwarte pierwsze.");
                }
                IZdjecie z = Thumbnailview.ZdjecieZIndeksem(nastepne);
                if (z != null)
                    Imageview.Wypelnij(new IZdjecie[1] { z });
            }
            else if (e.KeyData == Keys.Back)
            {
                int poprzednie = Imageview.Zdjecie.indeks - 1;
                if (poprzednie < Thumbnailview.IloscKatalogow)
                {
                    poprzednie = Thumbnailview.Ilosc - 1;
                    MessageBox.Show("To było pierwsze zdjęcie w katalogu. Zostanie otwarte ostatnie.");
                }
                IZdjecie z = Thumbnailview.ZdjecieZIndeksem(poprzednie);
                if (z != null)
                    Imageview.Wypelnij(new IZdjecie[1] { z });
            }
            else if (e.KeyData == Keys.R)
            {
                Rotate r = new Rotate(1);
                this.DodajOperacje(new PolecenieOperacji(r, r.PodajArgumenty().ToArray()));
            }
            else if (e.KeyData == Keys.L)
            {
                Rotate r = new Rotate(2);
                this.DodajOperacje(new PolecenieOperacji(r, r.PodajArgumenty().ToArray()));
            }
            else if (e.KeyData == (Keys.Control | Keys.S))
            {
                Imageview.ZapiszPlik();
            }
        }

        /// <summary>
        /// Metoda odrysowywujaca od nowa miniatury o nowym rozmiarze
        /// </summary>
        internal void ZmienionoRozmiarMiniatury()
        {
            widokMiniatur1.LargeImageList.ImageSize = new Size(Config.RozmiarMiniatury + 2, Config.RozmiarMiniatury + 2);
            IZdjecie[] zdjecia = widokMiniatur1.Zdjecia;
            foreach (Zdjecie z in zdjecia)
            {
                z.DisposeMini();
            }
            widokMiniatur1.Wypelnij(zdjecia, widokMiniatur1.Katalogi, Thumbnailview.MiniaturyZDrzewa);
            widokMiniatur1.Refresh();
        }
    }
}


<file_sep>using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Collections.Generic;
using System.Text;
using Photo;

namespace Wygladzanie
{
    /// <summary>
    /// Prykładowa implementacja operacji graficznej.
    /// Do referencji projektu należy dołączyć plik exe programu przeglądarki.
    /// Następnie należy zaimplementować interfejs GUI.IOperacja.
    /// </summary>
    public class Wygladzanie : Photo.IOperacja
    {
        private int kodOperacji;

        #region IOperacja Members

        public string NazwaOperacji
        {
            get { return "Wygladzanie"; }
        }

        int Photo.IOperacja.KodOperacji
        {
            get
            {
                return kodOperacji;
            }
            set
            {
                kodOperacji = value;
            }
        }

        public Image Ikona
        {
            get
            {
                return null;
            }
        }

        public string Autor
        {
            get { throw new System.Exception("The method or operation is not implemented."); }
        }

        public string Wersja
        {
            get { throw new System.Exception("The method or operation is not implemented."); }
        }

        public string Kontakt
        {
            get { throw new System.Exception("The method or operation is not implemented."); }
        }

        public void Wykonaj(Photo.Zdjecie z, System.Collections.Generic.Stack<object> Argumenty)
        {
            if (z.Zaznaczenie.IsEmpty)
            {
                Photo.BitmapFilter.GaussianBlur(z.Duze, 4);
            }
            else
            {
                if (z.Zaznaczenie.Width < 0)
                {
                    z.Zaznaczenie.X += z.Zaznaczenie.Width;
                    z.Zaznaczenie.Width *= -1;
                }
                if (z.Zaznaczenie.Height < 0)
                {
                    z.Zaznaczenie.Y += z.Zaznaczenie.Height;
                    z.Zaznaczenie.Height *= -1;
                }
                Bitmap blured = new Bitmap(Math.Abs(z.Zaznaczenie.Width), Math.Abs(z.Zaznaczenie.Height), z.Duze.PixelFormat);
                Graphics g = Graphics.FromImage(blured);
                g.DrawImage(z.Duze, new Rectangle(0, 0, blured.Width, blured.Height), z.Zaznaczenie, GraphicsUnit.Pixel);
                g.Dispose();
                Photo.BitmapFilter.GaussianBlur(blured, 4);
                g = Graphics.FromImage(z.Duze);
                g.DrawImage(blured, z.Zaznaczenie);
                g.Dispose();
            }
        }

        public Stack<object> PodajArgumenty()
        {
            return new Stack<object>();
        }

        public bool CzyNaToolbar()
        {
            return false;
        }

        #endregion
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.IO;
using System.Collections;
using System.Data.SQLite;
using System.Data.SqlClient;

namespace Photo
{
    /// <summary>
    /// Klasa implementująca interfejs IWyszukiwacz i drzewo wykorzystywana do tworzenia drzewa katalogów
    /// </summary>
    public class FileTree : TreeView, IWyszukiwacz
    {
        private const int Dysk = 0;
        private const int FOLDER = 1;
        private const int Dyskietka = 2;
        private const int Cdrom = 3;
        private const int Cdrom_z = 4;
        private const int Dyskietka_z = 5;
        private const int Pictures_2 = 6;
        private const int Cdrom_z_2 = 7;
        private const int Computer = 8;
        private const int Pulpit = 9;
        private const int User = 10;

        static bool czy_otwiera = false;

        private DirTreeNode kat_MKomputer, zaznaczony, ostatni;
        private string FullPath_zaznaczonego = "";

        private ContextMenuStrip Context;
        /// <summary>
        /// Konstruktor generuje liste ikon wykorzystywanych w drzewie katalogów
        /// </summary>
        public FileTree()
        {
            GenerateImage();
            this.BackColor = Color.Beige;
            Context = new ContextMenuStrip();
            czy_otwiera = false;
            
        }

        /// <summary>
        /// Metoda generująca i wypełniająca liste ikonami wykorzystywanymi w drzewie katalogów
        /// </summary>
        public void GenerateImage()
        {
            ImageList list = new ImageList();
            list.Images.Add(Properties.Resources.Dysk);
            list.Images.Add(Properties.Resources.folder);
            list.Images.Add(Properties.Resources.Dyskietka);
            list.Images.Add(Properties.Resources.Cdrom);
            list.Images.Add(Properties.Resources.Cdrom_z);
            list.Images.Add(Properties.Resources.Dyskietka_z);
            list.Images.Add(Properties.Resources.Pictures_2);
            list.Images.Add(Properties.Resources.Cdrom_z_2);
            list.Images.Add(Properties.Resources.Computer);
            list.Images.Add(Properties.Resources.Pulpit);
            list.Images.Add(Properties.Resources.User);
            ImageList = list;
        }

        /// <summary>
        /// Metoda wypełniająca drzewo katalogow
        /// </summary>
        public void Fill()
        {
            BeginUpdate();

            DirTreeNode kat_Pulpit = new DirTreeNode(Config.katalogPulpit, Pulpit, true);
            kat_Pulpit.Text = "Pulpit";
            //kat_Pulpit.Path = Config.katalogPulpit;

            try
            {
                string[] n = Directory.GetDirectories(Config.katalogPulpit);

                if (n.Length == 0)
                    kat_Pulpit.Nodes.Clear();
            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString() + e.Message);
            }

            Nodes.Add(kat_Pulpit);

            DirTreeNode kat_MDokumenty = new DirTreeNode(Config.katalogMojeDokumenty, User, true);
            kat_MDokumenty.Text = "Moje Dokumenty";

            try
            {
                string[] n = Directory.GetDirectories(Config.katalogMojeDokumenty);

                if (n.Length == 0)
                    kat_MDokumenty.Nodes.Clear();

            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString() + e.Message);
            }

            Nodes.Add(kat_MDokumenty);

            DirTreeNode kat_MObrazy = new DirTreeNode(Config.katalogMojeObrazy, Pictures_2, true);
            kat_MObrazy.Text = "Moje Obrazy";

            try
            {
                string[] n = Directory.GetDirectories(Config.katalogMojeObrazy);

                if (n.Length == 0)
                    kat_MObrazy.Nodes.Clear();

            }
            catch (Exception e)
            {
                MessageBox.Show(e.ToString() + e.Message);
            }

            Nodes.Add(kat_MObrazy);

            kat_MKomputer = new DirTreeNode("Mój Komputer", Computer, true);
            kat_MKomputer.Text = "Mój Komputer";
            Nodes.Add(kat_MKomputer);

            

            //kat_MKomputer.Nodes.Clear();

            string[] drives = Directory.GetLogicalDrives();

            foreach (string tempDrive in drives)
            {
                DirTreeNode dn = new DirTreeNode(tempDrive);
                kat_MKomputer.Nodes.Add(dn);
            }

            kat_MKomputer.Expand();

            EndUpdate();

            BeforeExpand += new TreeViewCancelEventHandler(prepare);
            AfterCollapse += new TreeViewEventHandler(clear);
        }
        /// <summary>
        /// Metoda do otwierania wezła drzewa
        /// </summary>
        /// <param name="path">sciezka katalogu do otwrcia</param>
        public void Open(string path)
        {
            TreeNodeCollection nodes = Nodes;
            DirTreeNode subnode = null;
            int i, n;            

            if (path.IndexOf("Mój Komputer") == 0)
                path = path.ToLower().Substring("Mój Komputer".Length, path.Length - "Mój Komputer".Length);
            else
                path = path.ToLower();
            
            Nodes.Clear();            

            nodes = Nodes;
            while (nodes != null)
            {
                n = nodes.Count;
                for (i = 0; i < n; i++)
                {
                    subnode = (DirTreeNode)nodes[i];
                    if (path == subnode.Path)
                    {
                        subnode.Expand();
                        return;
                    }
                    if (path.StartsWith(subnode.Path))
                    {
                        subnode.Expand();
                        break;
                    }
                }
                if (i == n)
                    return;
                nodes = subnode.Nodes;
            }
        }

        /// <summary>
        /// Metoda przygotowująca węzeł drzewa do otwarcia
        /// </summary>        
        void prepare(object sender, TreeViewCancelEventArgs e)
        {
            BeginUpdate();
            DirTreeNode tn = (DirTreeNode)e.Node;
            //zaznaczony = (DirTreeNode)e.Node;
            try
            {
                tn.populate(tn);
                EndUpdate();
            }
            catch (Exception ex)
            {
                if (tn.Path.Length == 3)
                {
                    MessageBox.Show(ex.Message + " - Odmowa dostępu", e.Node.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
                    //e.Node.                
                    e.Node.Remove();
                    //Nodes.Insert(tn.Index, tn);
                    kat_MKomputer.Nodes.Insert(tn.Index, tn);
                    //zaznaczony.Collapse(false);               
                }
                else
                {                    
                    //DirNode("", false);
                }
                EndUpdate();
            }
        }

        /// <summary>
        /// Metoda czyszcząca drzewo (w przypadku aplikacji nie sa usuwane wezly ktore zostaly zamkniete jest to spowodowane odbudowaniem drzewa gdy zmiana katalogu odbywa sie za pomoca wdoku miniatur)
        /// </summary>        
        void clear(object sender, TreeViewEventArgs e)
        {
            BeginUpdate();
            DirTreeNode tn = (DirTreeNode)e.Node;
            //tn.setLeaf(true);
            EndUpdate();
        }

        /// <summary>
        /// Metoda usuwająca wszystkie wezły z drzewa katalogów
        /// </summary>
        public void Delete()
        {
            BeginUpdate();
            //Nodes.RemoveAt(0);
            Nodes.Clear();
            EndUpdate();
        }

        /// <summary>
        /// Klasa imlementująca TreeNode czyli odpowiada za tworzenie wezłów drzewa katalogow
        /// </summary>
        public class DirTreeNode : TreeNode
        {
            string path;
            int type;
            /// <summary>
            /// metoda virtualna wracająca ścieżke węzłą
            /// </summary>
            public virtual string Path { get { return path; } }

            /// <summary>
            /// Konstruktor
            /// </summary>
            /// <param name="s">scieżka węzła</param>
            public DirTreeNode(string s)
                : base(s)
            {
                if (s.CompareTo("A:\\") == 0 || s.CompareTo("B:\\") == 0)
                {
                    Text = s + " [Floppy]";
                    ImageIndex = Dyskietka;
                    SelectedImageIndex = Dyskietka;
                }
                else
                {
                    Text = s + " [" + GetDriveName(s) + "]";
                    //dn = new DirTreeNode(tempDrive, tempDrive + " [" + GetDriveName(tempDrive) + "]");
                    if (GetDriveName(s) != "" && getDriveType(s) == Cdrom)
                    {
                        ImageIndex = Cdrom_z_2;
                        SelectedImageIndex = Cdrom_z_2;
                    }
                    else
                    {
                        ImageIndex = getDriveType(s);
                        SelectedImageIndex = getDriveType(s);
                    }
                }

                path = s.ToLower();
                setLeaf(true);
            }

            /// <summary>
            /// Konstruktor
            /// </summary>
            /// <param name="aType">typ ikony jaka ma byc użyta</param>
            /// <param name="s">scieżka węzła</param>
            /// <param name="z">informacja czy dodajemy węzły do głównego trzonu czy jakieś podrzedne katalogi</param>
            public DirTreeNode(string s, int aType, bool z)
                : base(s)
            {

                path = s.ToLower();
                type = aType;

                if (s.CompareTo("A:\\") == 0 || s.CompareTo("B:\\") == 0)
                {
                    Text = s + " [Floppy]";
                    ImageIndex = Dyskietka;
                    SelectedImageIndex = Dyskietka;
                }
                else
                {
                    Text = s + " [" + GetDriveName(s) + "]";
                    //dn = new DirTreeNode(tempDrive, tempDrive + " [" + GetDriveName(tempDrive) + "]");
                    if (GetDriveName(s) != "" && getDriveType(s) == Cdrom)
                    {
                        ImageIndex = Cdrom_z_2;
                        SelectedImageIndex = Cdrom_z_2;
                    }
                    else
                    {
                        ImageIndex = getDriveType(s);
                        SelectedImageIndex = getDriveType(s);
                    }
                }
                ImageIndex = type;
                SelectedImageIndex = type;

                path = s.ToLower();
                setLeaf(true);
            }

            /// <summary>
            /// Konstruktor
            /// </summary>
            /// <param name="label">jaką etykiete wypisać przy urządzeniu</param>
            /// <param name="s">scieżka węzła</param>
            public DirTreeNode(string s, string label)
                : this(s)
            {
                Text = label;
            }

            /// <summary>
            /// Konstruktor
            /// </summary>
            /// <param name="aType">typ ikony jaką ma być użyta</param>
            /// <param name="s">scieżka węzła</param>
            public DirTreeNode(string s, int aType)
                : base(new FileInfo(s).Name)
            {
                path = s.ToLower();
                type = aType;
                ImageIndex = type;
                SelectedImageIndex = type;
                try
                {
                    string[] n = Directory.GetDirectories(path);

                    if (type == FOLDER && n.Length != 0)
                        setLeaf(true);
                }
                catch (Exception)
                {
                    //MessageBox.Show(e.ToString() + e.Message);
                }
            }

            /// <summary>
            /// Metoda wyznaczająca typ urządzenia
            /// </summary>
            /// <param name="driveLetter">nazwa urządzenia</param>
            /// <returns>zwraca typ urządzenia</returns>
            [DllImport("kernel32.dll")]
            public static extern long GetDriveType(string driveLetter);

            /// <summary>
            /// Metoda wykorzystywana do wyłuskania etykiety urządzenia ( partycja, cdrom, floppy )
            /// </summary>
            [DllImport("Kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
            extern static bool GetVolumeInformation(
                                    string RootPathName,
                                    StringBuilder VolumeNameBuffer,
                                    int VolumeNameSize,
                                    out uint VolumeSerialNumber,
                                    out uint MaximumComponentLength,
                                    out uint FileSystemFlags,
                                    StringBuilder FileSystemNameBuffer,
                                    int nFileSystemNameSize);


            /// <summary>
            /// Metoda zwraca typ urządzenia
            /// </summary>
            /// <param name="drive">nazwa urządzenia</param>
            public int getDriveType(string drive)
            {
                if ((GetDriveType(drive) & 5) == 5) return Cdrom;//cd
                if ((GetDriveType(drive) & 3) == 3) return Dysk;//fixed
                if ((GetDriveType(drive) & 2) == 2) return Dysk;//removable
                if ((GetDriveType(drive) & 4) == 4) return Dyskietka;//remote disk
                if ((GetDriveType(drive) & 6) == 6) return Dyskietka;//ram disk
                return 0;
            }

            /// <summary>
            /// Metoda zwracająca nazwę/etykiete urządzenia
            /// </summary>
            /// <param name="drive">nazwa urządzenia</param>
            public static string GetDriveName(string drive)
            {
                //receives volume name of drive
                StringBuilder volname = new StringBuilder(256);
                //receives serial number of drive,not in case of network drive(win95/98)
                uint sn;
                uint maxcomplen;//receives maximum component length
                uint sysflags;//receives file system flags
                StringBuilder sysname = new StringBuilder(256);//receives the file system name
                bool retval;//return value

                retval = GetVolumeInformation(drive, volname, 256, out sn, out maxcomplen,
                                              out sysflags, sysname, 256);

                if (retval == true) return volname.ToString();
                else return "";
            }

            /// <summary>
            /// Metoda zwracająca etykiete urządzenia
            /// </summary>
            /// <param name="drive">nazwa urządzenia</param>
            public static string Etykieta(string drive)
            {
                return GetDriveName(drive);
            }

            /// <summary>
            /// Metoda tworząca i dodająca węzły do drzewa katalogów
            /// </summary>
            /// <param name="tn">węzeł drzewa który zostanie otwarty</param>
            internal void populate(DirTreeNode tn)
            {
                ArrayList folder = new ArrayList(); ;

                if (tn.FullPath != "Mój Komputer")
                {

                    DirTreeNode dnn = new DirTreeNode(tn.Text);
                    int gdzie = tn.Index;

                    string[] files = Directory.GetDirectories(Path);
                    Array.Sort(files);

                    for (int i = 0; i < files.Length; i++)
                    {
                        folder.Add(new DirTreeNode(files[i], FOLDER));
                    }

                    Nodes.Clear();
                    foreach (DirTreeNode dtn in folder)
                    {
                        Nodes.Add(dtn);
                    }
                    czy_otwiera = false;
                }
                else
                {
                    string[] drives = Directory.GetLogicalDrives();

                    foreach (string tempDrive in drives)
                    {
                        DirTreeNode dn = new DirTreeNode(tempDrive);
                        folder.Add(dn);
                    }
                    Nodes.Clear();
                    foreach (DirTreeNode dtn in folder)
                    {
                        Nodes.Add(dtn);
                    }
                }
            }

            bool isLeaf = true;

            /// <summary>
            /// Metoda ustawiająca dany węzeł czy ma być liściem i nie mieć już potomków czy nie 
            /// </summary>
            /// <param name="b">czy ma byc liściem</param>
            internal void setLeaf(bool b)
            {
                Nodes.Clear();
                isLeaf = b;
                if (IsExpanded)
                    return;
                if (!isLeaf)
                    return;
                Nodes.Add(new TreeNode());
            }

        }

        #region IWyszukiwacz Members

        /// <summary>
        /// metoda służącza do składania zapytania sql i zwracająca Obiekt Wyszukania
        /// </summary>
        /// <returns>zwraca obiekt Wyszukanie</returns>
        public IWyszukiwanie Wyszukaj()
        {
            throw new Exception("The method or operation is not implemented.");
        }
        /// <summary>
        /// delegat informuję aplikacje ze wyszukiwanie zdjęć się zakończyło
        /// </summary>
        public event ZakonczonoWyszukiwanieDelegate ZakonczonoWyszukiwanie;
        /// <summary>
        /// delegat informuję aplikacje ze wyszukiwanie zdjęć się rozpoczeło
        /// </summary>
        public event RozpoczetoWyszukiwanieDelegate RozpoczetoWyszukiwanie;       
        /// <summary>
        /// delegat informuje pasek który wyświetla skąd sa wyświetlane zdjęcia
        /// </summary>
        public event ZmienionoZrodloDelegate ZmienionoZrodlo;
        /// <summary>
        /// delegat informuję aplikacje że zostały zmienione tagi i aplikacja musi wczytać od nowa liste tagów dla każdego zdjęcia
        /// </summary>
        public event ZmienionoTagiDelegate ZmienionoTagi;
        /// <summary>
        /// delegat informuję aplikacje że zostały zmienione id i aplikacja musi wczytać od nowa id dla każdego zdjęcia
        /// </summary>
        public event ZmienionoIdsDelegate ZmienionoIds;

        #endregion

        /// <summary>
        /// Metoda wywołująca sie przed zaznaczeniem węzła
        /// </summary>
        protected override void OnBeforeSelect(TreeViewCancelEventArgs e)
        {
            base.OnBeforeSelect(e);
            czy_otwiera = false;
            //this.SelectedNode = new TreeNode("cos");
            //this.Select(true, true);
            //MessageBox.Show("numer: " + e.Node.SelectedImageIndex);
        }

        /// <summary>
        /// Metoda wywołująca sie po zaznaczeniem węzła
        /// </summary>
        protected override void OnAfterSelect(TreeViewEventArgs e)
        {
            base.OnAfterSelect(e);
            czy_otwiera = false;
            //this.SelectedNode = new TreeNode("cos");
            //this.Select(true, true);
        }

        /// <summary>
        /// Metoda dodająca katalog do albumu
        /// </summary>
        /// <param name="sciezka">sciezka katalogu</param>
        internal void d_d_a(string sciezka)
        {
            List<Zdjecie> zdjecia = new List<Zdjecie>();
            List<string> pliki_przefiltrowane = new List<string>();

            try
            {
                pliki_przefiltrowane = Przefiltruj(sciezka);

                if (pliki_przefiltrowane.Count != 0)
                {
                    dodaj_kolekcje_do_bazy(pliki_przefiltrowane);
                }

            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " - Odmowa dostępu", sciezka, MessageBoxButtons.OK, MessageBoxIcon.Error);                
            }
        }

        /// <summary>
        /// Metoda filtrująca pliki w katalogu
        /// </summary>
        /// <param name="sciezka">sciezka katalogu</param>
        /// <returns>zwraca liste przefiltrowana czyli tylko pliki ze zdjęciami</returns>
        internal List<string> Przefiltruj(string sciezka)
        {
            List<string> pliki = new List<string>();
            List<string> pliki_przefiltrowane = new List<string>();

            try
            {
                pliki.AddRange(Directory.GetFiles(sciezka, "*.jpg"));
                pliki.AddRange(Directory.GetFiles(sciezka, "*.jpeg"));

                pliki.Sort();

                for (int i = 0; i < pliki.Count; i++)
                {
                    try
                    {
                        if ((pliki[i].ToLower().LastIndexOf(".jpg") != -1 && pliki[i].ToLower().LastIndexOf(".jpg") == (pliki[i].Length - 4)) || (pliki[i].ToLower().LastIndexOf(".jpeg") != -1 && pliki[i].ToLower().LastIndexOf(".jpeg") == (pliki[i].Length - 5)))
                        {
                            pliki_przefiltrowane.Add(pliki[i]);
                        }
                    }
                    catch (ArgumentException)
                    {
                        MessageBox.Show("Plik: \"" + pliki[i].Substring(pliki[i].LastIndexOf("\\") + 1) + "\" mimo poprawnego rozszezenie nie zawiera zdjęcia", pliki[i], MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    }
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " - Odmowa dostępu", sciezka, MessageBoxButtons.OK, MessageBoxIcon.Error);
            }

            return pliki_przefiltrowane;
        }

        /// <summary>
        /// Metoda tworząca obiekty zdjęc i dodająca je do kontrolki wyświetlającej
        /// </summary>
        /// <param name="Node">węzł dla którego tworzymy obiekty zdjęć</param>
        /// <returns>zwraca tablice obiektów zdjęć</returns>
        private Zdjecie[] WybierzPlikiZdjec(DirTreeNode Node)
        {
            List<Zdjecie> zdjecia = new List<Zdjecie>();
            List<string> pliki = Przefiltruj(Node.Path);            
            
            Zdjecie z;
            if (Node.Text != "<NAME>")
            {
                try
                {
                    for (int i = 0; i < pliki.Count; i++)
                    {
                        try
                        {
                            if ((pliki[i].ToLower().LastIndexOf(".jpg") != -1 && pliki[i].ToLower().LastIndexOf(".jpg") == (pliki[i].Length - 4)) || (pliki[i].ToLower().LastIndexOf(".jpeg") != -1 && pliki[i].ToLower().LastIndexOf(".jpeg") == (pliki[i].Length - 5)) )
                            {                                
                                z = new Zdjecie(pliki[i]);                                
                                z.ZweryfikujZdjecie();                                
                                zdjecia.Add(z);
                            }
                        }
                        catch (ArgumentException)
                        {

                            MessageBox.Show("Plik: \"" + pliki[i].Substring(pliki[i].LastIndexOf("\\") + 1) + "\" mimo poprawnego rozszezenie nie zawiera zdjęcia", pliki[i], MessageBoxButtons.OK, MessageBoxIcon.Warning);
                        }
                    }
                }
                catch (Exception e)
                {
                    MessageBox.Show(e.Message + " - Odmowa dostępu", Node.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
            }
            return zdjecia.ToArray();
        }

        /// <summary>
        /// Metoda wywołana po otworzeniu danego węzła drzewa
        /// </summary>
        protected override void OnAfterExpand(TreeViewEventArgs e)
        {
            base.OnAfterExpand(e);


            if (e.Node.Text.IndexOf("A:\\") == 0 && e.Node.Text.LastIndexOf("\\") < 4)
            {
                e.Node.Text = "A:\\ " + "[" + DirTreeNode.Etykieta(e.Node.Text.Substring(0, 3)) + "]";
                e.Node.ImageIndex = Dyskietka_z;
                e.Node.SelectedImageIndex = Dyskietka_z;
            }
            else if (e.Node.Text.IndexOf("B:\\") == 0 && e.Node.Text.LastIndexOf("\\") < 4)
            {
                e.Node.Text = "B:\\ " + "[" + DirTreeNode.Etykieta(e.Node.Text.Substring(0, 3)) + "]";
                e.Node.ImageIndex = Dyskietka_z;
                e.Node.SelectedImageIndex = Dyskietka_z;
            }        
            czy_otwiera = true;            
        }

        /// <summary>
        /// Metoda informująca za pomocą delegatów kontrolkę wyświetlająca o zawartości katalogu w zdjęcia i podkatalogi
        /// </summary>
        /// <param name="zap">węzł dla ktorego wykonujemy zapytanie</param>
        private void PowiadomOZawartosciKatalogu(DirTreeNode zap)
        {
            List<Zdjecie> zdjecia = new List<Zdjecie>();
            List<Katalog> katalogi = new List<Katalog>();

            if (ZmienionoZrodlo != null)
                ZmienionoZrodlo(zap.Path);

            if (RozpoczetoWyszukiwanie != null)
                RozpoczetoWyszukiwanie(null);

            try
            {
                katalogi.AddRange(ZnajdzKatalogiWKatalogu((DirTreeNode)zap));
                
                if (!zap.Path.Equals("mój komputer"))
                {
                    //MessageBox.Show(zap.Path);
                    zdjecia.AddRange(WybierzPlikiZdjec((DirTreeNode)zap));
                }
            }
            catch (UnauthorizedAccessException)
            {
                MessageBox.Show("Brak dostępu do wybranego katalogu.");
                return;
            }            

            if (ZakonczonoWyszukiwanie != null)
                ZakonczonoWyszukiwanie(zdjecia.ToArray(), katalogi.ToArray(), true);

        }

        /// <summary>
        /// Metoda wywołana po kliknięciu na węzeł
        /// w zależności od przycisku myszki który klikął
        /// jeżeli lewy zostaje wywołana medota informująca o zawartości danego węzła
        /// jeżeli prawy jest tworzone menu kontekstowe
        /// </summary>
        protected override void OnNodeMouseClick(TreeNodeMouseClickEventArgs e)
        {
            base.OnNodeMouseClick(e);            

            if (e.Button == MouseButtons.Right)
            {
                Context.Items.Clear();
                ToolStripItem toolStripItem = Context.Items.Add("Dodaj zawartosc katalogu " + ((DirTreeNode)e.Node).Path + " do kolekcji",Properties.Resources.dodaj_do_kolekcji);
                toolStripItem.ToolTipText = ((DirTreeNode)e.Node).Path;
                toolStripItem.Click += new EventHandler(DodajDoKolekcji);
                toolStripItem = Context.Items.Add("Dodaj zawartosc katalogu " + ((DirTreeNode)e.Node).Path + " do Albumu",Properties.Resources.Contacts_d);
                toolStripItem.ToolTipText = ((DirTreeNode)e.Node).Path;
                toolStripItem.Click += new EventHandler(DodajDoAlbumu);
                toolStripItem = Context.Items.Add("Dodaj tagi dla katalogu " + ((DirTreeNode)e.Node).Path,Properties.Resources.new_tag);
                toolStripItem.ToolTipText = ((DirTreeNode)e.Node).Path;
                toolStripItem.Click += new EventHandler(DodajTagiDlaKatalogu);
                toolStripItem = Context.Items.Add("Usuń tagi dla katalogu " + ((DirTreeNode)e.Node).Path,Properties.Resources.delete_tag);
                toolStripItem.ToolTipText = ((DirTreeNode)e.Node).Path;
                toolStripItem.Click += new EventHandler(UsunTagiDlaKatalogu);
                toolStripItem = Context.Items.Add("Usuń zawartość katalogu " + ((DirTreeNode)e.Node).Path + " z kolekcji",Properties.Resources.Recycle_Bin_Full_d);
                toolStripItem.ToolTipText = ((DirTreeNode)e.Node).Path;
                toolStripItem.Click += new EventHandler(UsunZKolekcji);


                Context.Show(this, new Point(e.X, e.Y));
            }
            else if (e.Button == MouseButtons.Left && czy_otwiera == false)
            {                
                zaznaczony = (DirTreeNode)e.Node;
                FullPath_zaznaczonego = zaznaczony.FullPath;

                DirNode("", false);                
            }

            czy_otwiera = false;
        }

        /// <summary>
        /// Metoda informuje kontrolke wyświetlająca o nowej zawartości albo katalogu nadrzędnego albo podkatalogu
        /// </summary>
        /// <param name="k">katalog którego zawartość ma być wyświetlona</param>
        public void ZaladujZawartoscKatalogu(Katalog k)
        {
            if (k.CzyDoGory == true)
            {
                DirNode(k.Path, true);
            }
            else
            {
                DirNode(k.Path, false);
            }
        }
        /// <summary>
        /// Metoda do nawigacji za pomocą klawiatury po drzewie. Naciśniecie klawisza Enter na zaznaczonym węźle drzewa spowoduje jego eyświetlenie
        /// </summary>
        protected override void OnKeyPress(KeyPressEventArgs e)
        {
            base.OnKeyPress(e);

            DirTreeNode wezel = (DirTreeNode)this.SelectedNode;
            if (wezel != null)
            {
                if (e.KeyChar == (char)Keys.Enter)
                {
                    zaznaczony = (DirTreeNode)this.SelectedNode;
                    FullPath_zaznaczonego = zaznaczony.FullPath;                    
                    DirNode("", false);
                }
            }
        }

        /// <summary>
        /// Metoda która dotosowuje wygląd drzewa do sytuacji w widoku miniatur
        /// </summary>
        /// <param name="czy_do_gory">czy katalog nadrzędny</param>
        /// <param name="napis">sciezka katalogu do wyświetlenia</param>
        public void DirNode(string napis, bool czy_do_gory)
        {
            string nn = "";
            
            try
            {
                if (napis != "" || czy_do_gory == true)
                {
                    nn = PootwierajDrzewoDoZaznaczonego(zaznaczony);
                }
                if (czy_do_gory)
                {
                    if (nn == "")
                    {
                        zaznaczony = (DirTreeNode)zaznaczony.Parent;
                        zaznaczony.Collapse(true);
                    }

                    FullPath_zaznaczonego = zaznaczony.FullPath;
                }
                else
                {
                    if (napis != "" && nn == "")
                    {
                        zaznaczony.Expand();

                        TreeNodeCollection kolekcja = zaznaczony.Nodes;
                        DirTreeNode ppp = zaznaczony;

                        foreach (TreeNode t in kolekcja)
                        {
                            ppp = (DirTreeNode)t;
                            if (napis.ToLower().CompareTo(ppp.Path) == 0)
                            {
                                break;
                            }
                        }
                        zaznaczony = ppp;
                        FullPath_zaznaczonego = zaznaczony.FullPath;//FullPath_zaznaczonego + "\\" + napis.Substring(napis.LastIndexOf("\\") + 1, napis.Length - napis.LastIndexOf("\\") - 1);
                    }
                }                
                PowiadomOZawartosciKatalogu(zaznaczony);
                UstawienieEtykietyDyskietki(zaznaczony);
            }            
            catch(Exception)
            {
                MessageBox.Show("Dany katalog został usuniety drzewo zostanie zwinięte", "", MessageBoxButtons.OK, MessageBoxIcon.Error);
                Delete();
                Fill();
                zaznaczony = kat_MKomputer;
                FullPath_zaznaczonego = zaznaczony.FullPath;
                PowiadomOZawartosciKatalogu(zaznaczony);
                UstawienieEtykietyDyskietki(zaznaczony);                 
            }           
        }

        /// <summary>
        /// Metoda otwiera drzewo do zaznaczonego węzła
        /// </summary>
        /// <param name="zaz">węzł do którego należy pootwierać</param>
        private string PootwierajDrzewoDoZaznaczonego(DirTreeNode zaz)
        {
            TreeNodeCollection kolekcja = this.Nodes;

            ostatni = null;

            string sciezka = FullPath_zaznaczonego, nazwa_pliku = "", do_sprawdzenia = "";

            string[] spl = sciezka.Split("\\".ToCharArray());

            int licznik = 0, ilosc_w_sciezka = spl.Length - 1;

            bool stan = false, znaleziono_wezl = false, dysk = false, czy_byl_blad = false;

            while (stan == false)
            {
                foreach (DirTreeNode dn in kolekcja)
                {
                    if (licznik == spl.Length)
                    {
                        stan = true;
                        czy_byl_blad = true;
                        break;
                    }

                    if (licznik < spl.Length-1)
                    {                        
                        if (spl[licznik].IndexOf(":") == 1 && spl[licznik].Length == 2 && spl[licznik + 1].IndexOf("[") == 1 && spl[licznik + 1].LastIndexOf("]") == (spl[licznik + 1].Length - 1))
                        {
                            do_sprawdzenia = spl[licznik] + "\\" + spl[licznik + 1];
                            nazwa_pliku = dn.FullPath.Substring(dn.FullPath.LastIndexOf("\\") - 2, dn.FullPath.Length - dn.FullPath.LastIndexOf("\\") + 2);                           
                            dysk = true;
                        }
                        else
                        {
                            do_sprawdzenia = spl[licznik];
                            nazwa_pliku = dn.FullPath.Substring(dn.FullPath.LastIndexOf("\\") + 1, dn.FullPath.Length - dn.FullPath.LastIndexOf("\\") - 1);
                        }
                    }
                    else
                    {
                        do_sprawdzenia = spl[licznik];
                        nazwa_pliku = dn.FullPath.Substring(dn.FullPath.LastIndexOf("\\") + 1, dn.FullPath.Length - dn.FullPath.LastIndexOf("\\") - 1);
                    }

                    if (do_sprawdzenia.CompareTo(nazwa_pliku) == 0)
                    {
                        dn.Expand();
                        
                        kolekcja = dn.Nodes;

                        if (sciezka.CompareTo(dn.FullPath) == 0)
                        {
                            dn.Collapse();
                            zaznaczony = dn;
                            FullPath_zaznaczonego = zaznaczony.FullPath;
                            stan = true;                            
                        }
                        
                        znaleziono_wezl = true;
                        ostatni = dn;
                        
                        break;
                    }
                }

                if (dysk == true)
                {
                    licznik++;
                    dysk = false;
                }


                if (znaleziono_wezl == false)
                {
                    stan = true;                    
                    zaznaczony = ostatni;
                    zaznaczony.Collapse();                    
                    czy_byl_blad = true;                    
                }
                else
                {                  
                    znaleziono_wezl = false;                 
                }               

                licznik++;
            }

            if (czy_byl_blad == true)
            {
                return "cos";
            }
            else
            {
                return "";
            }
        }

        /// <summary>
        /// Metoda ustawia etykiete dyskietki
        /// </summary>
        /// <param name="zap">węzeł zaznaczony</param>
        private void UstawienieEtykietyDyskietki(DirTreeNode zap)
        {
            string etykieta;

            if (zap.Text.IndexOf("A:\\") == 0 && zap.Text.LastIndexOf("\\") < 4)
            {
                etykieta = DirTreeNode.Etykieta(zap.Text.Substring(0, 3));
                if (etykieta != "")
                {
                    zap.Text = "A:\\" + " [" + etykieta + "]";
                    zap.ImageIndex = Dyskietka_z;
                    zap.SelectedImageIndex = Dyskietka_z;
                }
                else
                {
                    zap.Text = "A:\\" + " [Floppy]";
                    zap.ImageIndex = Dyskietka;
                    zap.SelectedImageIndex = Dyskietka;
                }
            }
            else if (zap.Text.IndexOf("B:\\") == 0 && zap.Text.LastIndexOf("\\") < 4)
            {
                etykieta = DirTreeNode.Etykieta(zap.Text.Substring(0, 3));
                if (etykieta != "")
                {
                    zap.Text = "B:\\" + " [" + etykieta + "]";
                    zap.ImageIndex = Dyskietka_z;
                    zap.SelectedImageIndex = Dyskietka_z;
                }
                else
                {
                    zap.Text = "B:\\" + " [Floppy]";
                    zap.ImageIndex = Dyskietka;
                    zap.SelectedImageIndex = Dyskietka;
                }
            }
        }

        /// <summary>
        /// Metoda zwracająca tablice katalogów z danego katalogu
        /// </summary>
        /// <param name="Node"><NAME></param>
        /// <returns>zwraca tablice katalogów</returns>
        private Katalog[] ZnajdzKatalogiWKatalogu(DirTreeNode Node)
        {
            List<string> katal_tab = new List<string>();
            List<Katalog> katalogi = new List<Katalog>();

            //MessageBox.Show(Node.Text);

            if (Node.Text != "Mój Komputer")
            {

                try
                {
                    katal_tab.AddRange(Directory.GetDirectories(Node.Path));
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message + " - Odmowa dostępu", Node.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                //if (Node.Path.Length > 3)
                //{
                    string s1 = "";

                    s1 = Node.Path.Substring(0, Node.Path.LastIndexOf("\\"));

                    if (Node.Text != "Pulpit" && Node.Text != "Moje Dokumenty" && Node.Text != "Moje Obrazy")
                    {
                        if (s1.Length == 2)
                        {
                            katalogi.Add(new Katalog(s1 + "\\", true));
                        }
                        else
                        {
                            katalogi.Add(new Katalog(s1, true));
                        }
                    }

                //}
                
                katal_tab.Sort();
                foreach (string t in katal_tab)
                {
                    katalogi.Add(new Katalog(t, false));
                }
            }
            else
            {
                try
                {
                    katal_tab.AddRange(Directory.GetLogicalDrives());
                }
                catch (Exception ex)
                {
                    MessageBox.Show(ex.Message + " - Odmowa dostępu", Node.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
                }
                katal_tab.Sort();
                foreach (string t in katal_tab)
                {
                    //MessageBox.Show(t);
                    katalogi.Add(new Katalog(t, false));
                }
            }
            return katalogi.ToArray();
        }


        /// <summary>
        /// Metoda dodaje wpisy do bazy
        /// </summary>
        /// <param name="lista">lista plików o których należy dodać wpisy do bazy</param>
        internal void dodaj_kolekcje_do_bazy(List<string> lista)
        {            
            StringBuilder sb = new StringBuilder("Nie udało się dodać do kolekcji nastepujących zdjęć:\n");
            bool nieUdaloSie = false;
            foreach (string n in lista)
            {
                try
                {
                    Zdjecie z = new Zdjecie(n);                    
                    z.ZweryfikujZdjecie();
                    if (z.DodajDoKolekcji() == false)
                    {
                        sb.Append(z.Path + "\n");
                        if (nieUdaloSie == false)
                        {
                            nieUdaloSie = true;
                        }
                    }
                }
                catch (Exception e)
                {
                    MessageBox.Show(e.ToString());
                }               
            }           
            if (nieUdaloSie)
                MessageBox.Show(sb.ToString());
        }

        /// <summary>
        /// Metoda dodaje kolekcje do bazy
        /// </summary>
        internal void DodajDoKolekcji(object sender, EventArgs e)
        {
            ToolStripItem mn = (ToolStripItem)sender;            
            List<string> lista = Przefiltruj(mn.ToolTipText);
            dodaj_kolekcje_do_bazy(lista);

            if (ZmienionoIds != null)
                ZmienionoIds();
        }

        /// <summary>
        /// Metoda usuwa tagi dla katalogu
        /// </summary>
        private void UsunTagiDlaKatalogu(object sender, EventArgs e)
        {
            ToolStripItem mn = (ToolStripItem)sender;

            List<string> lista_stringow = Przefiltruj(mn.ToolTipText);            

            foreach (string plik in lista_stringow)
            {
                Zdjecie z = new Zdjecie(plik);                
                z.ZweryfikujZdjecie();

                if (z.CzyUstawioneId() == true)
                {
                    z.UsunTagi();
                }                
            }

            if (ZmienionoTagi != null)
                ZmienionoTagi();
        }

        /// <summary>
        /// Metoda usuwa katalog z bazy
        /// </summary>
        private void UsunZKolekcji(object sender, EventArgs e)
        {
            ToolStripItem mn = (ToolStripItem)sender;

            List<string> lista_stringow = Przefiltruj(mn.ToolTipText);

            foreach (string plik in lista_stringow)
            {
                Zdjecie z = new Zdjecie(plik);
                z.ZweryfikujZdjecie();

                if (z.CzyUstawioneId() == true)
                {
                    z.UsunZdjecieZBazy();
                    z.UsunId();
                }
            }

            if (ZmienionoIds != null)
                ZmienionoIds();
        }

        /// <summary>
        /// Metoda dodaje tagi dla katalogu
        /// </summary>
        private void DodajTagiDlaKatalogu(object sender, EventArgs e)
        {            
            ToolStripItem mn = (ToolStripItem)sender;

            List<string> lista_stringow = Przefiltruj(mn.ToolTipText);
            List<Zdjecie> lista_zdjec = new List<Zdjecie>();

            foreach (string plik in lista_stringow)
            {
                Zdjecie z = new Zdjecie(plik);
                z.ZweryfikujZdjecie();
                lista_zdjec.Add(z);
            }

            Dodaj_tagi_do_zdjecia dtdz = new Dodaj_tagi_do_zdjecia(lista_zdjec,true);
            dtdz.ZmienionoTagi += new ZmienionoTagiDelegate(this.ZmienionoTagi);
            dtdz.Show();           
        }

        /// <summary>
        /// Metoda dodaje katalog do albumów
        /// </summary>
        internal void DodajDoAlbumu(object sender, EventArgs e)
        {
            ToolStripItem mn = (ToolStripItem)sender;

            List<string> lista_stringow = Przefiltruj(mn.ToolTipText);
            List<Zdjecie> lista_zdjec = new List<Zdjecie>();
            foreach (string s in lista_stringow)
            {
                Zdjecie z = new Zdjecie(s);
                z.ZweryfikujZdjecie();
                lista_zdjec.Add(z);
            }

            Dodaj_albumy_do_zdjecia dadz = new Dodaj_albumy_do_zdjecia(lista_zdjec, this, mn.ToolTipText);
            dadz.Show();

            //Dodaj_katalog_do_bazy ddk = new Dodaj_katalog_do_bazy(mn.ToolTipText, this);
            //ddk.Show();
        }

        /// <summary>
        /// Metoda wywołana po zamknięciu węzła drzewa
        /// </summary>
        protected override void OnAfterCollapse(TreeViewEventArgs e)
        {
            base.OnAfterCollapse(e);
            czy_otwiera = true;
            //MessageBox.Show("after colapse");
        }

        /// <summary>
        /// Metoda wywołana przed zamknięciu węzła drzewa
        /// </summary>
        protected override void OnBeforeCollapse(TreeViewCancelEventArgs e)
        {
            base.OnBeforeCollapse(e);
            czy_otwiera = true;
            //MessageBox.Show("before colapse");
        }

        /// <summary>
        /// Metoda wywołana przed otwarciem węzła drzewa
        /// </summary>
        protected override void OnBeforeExpand(TreeViewCancelEventArgs e)
        {
            base.OnBeforeExpand(e);
            czy_otwiera = true;
            //MessageBox.Show("before expand");
        }

        /// <summary>
        /// Metoda inicjalizująca obiekt drzewa katalogów
        /// </summary>
        private void InitializeComponent()
        {
            this.SuspendLayout();
            // 
            // FileTree
            // 
            this.LabelEdit = true;
            this.ResumeLayout(false);

        }
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Windows.Forms;

namespace Photo
{
    public partial class WidokMiniatur : System.Windows.Forms.ListView, IOpakowanieZdjec, IKontekst
    {
        private int defaultImageSize;
        private List<Miniatura> miniatury;

        public WidokMiniatur()
        {
            InitializeComponent();
        }
        public WidokMiniatur(int imgSize)
            : this()
        {
            this.defaultImageSize = imgSize;
        }

        protected override void OnNotifyMessage(Message m)
        {
            //Filter out the WM_ERASEBKGND message
            if (m.Msg != 0x14)
            {
                base.OnNotifyMessage(m);
            }
        }

        public void AddImages(List<Miniatura> images)
        {
            this.miniatury.AddRange(images);
        }

        public void ShowImages(double zoom)
        {
            Miniatura z;
            Bitmap newBitmap;
            Graphics MyGraphics;
            Rectangle MyRectan;
            ImageList newImageList = new ImageList();
            ListViewItem listViewItem;
            newImageList.ColorDepth = System.Windows.Forms.ColorDepth.Depth32Bit;
            newImageList.Tag = "100%";
            newImageList.TransparentColor = System.Drawing.Color.Transparent;
            newImageList.ImageSize = new Size((int)(zoom * this.defaultImageSize), (int)(zoom * this.defaultImageSize));

            int maxSize = newImageList.ImageSize.Width;
            int scaledH, scaledW, posX, posY;
            this.Items.Clear();
            for (int i = 0; i < miniatury.Count; i++)
            {
                z = miniatury[i];
                newBitmap = new Bitmap(maxSize, maxSize);
                MyGraphics = Graphics.FromImage(newBitmap);

                if (z.Bitmap.Height > z.Bitmap.Width)
                {
                    scaledH = maxSize;
                    scaledW = (int)Math.Round((double)(z.Bitmap.Width * scaledH) / z.Bitmap.Height);
                    posX = (maxSize - scaledW) / 2;
                    posY = 0;
                }
                else
                {
                    scaledW = maxSize;
                    scaledH = (int)Math.Round((double)(z.Bitmap.Height * scaledW) / z.Bitmap.Width);
                    posX = 0;
                    posY = (maxSize - scaledH) / 2;
                }

                MyRectan = new Rectangle(posX, posY, scaledW, scaledH);
                using (Pen p = new Pen(Brushes.LightGray))
                {
                    MyGraphics.DrawRectangle(p, 0, 0, maxSize - 1, maxSize - 1);
                }
                MyGraphics.DrawImage(z.Bitmap, MyRectan);
                newBitmap.Tag = new MiniaturaTag(z.tag.Path);
                newImageList.Images.Add(newBitmap);
                listViewItem = this.Items.Add(new ListViewItem(z.tag.Filename));
                listViewItem.ImageIndex = i;
            }

            // Create an new ImageList for the ListView control
            this.LargeImageList = newImageList;

            // Update the ListView control
            this.Refresh();
        }

        #region IOpakowanieZdjec Members

        public IZdjecie this[int numer]
        {
            get { return new Zdjecie(miniatury[numer].tag.Path); }
        }

        public int Ilosc
        {
            get { return miniatury.Count; }
        }

        public void Dodaj(IZdjecie zdjecie)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void Usun(IZdjecie zdjecie)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void Oproznij()
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public IZdjecie[] WybraneZdjecia()
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void RozpocznijEdycje()
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void ZakonczEdycje()
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void DodajOperacje(PolecenieOperacji operacja)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void UsunWszystkieOperacje()
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public event WybranoZdjecieDelegate WybranoZdjecie;

        public void Wypelnij(IZdjecie[] zdjecia)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        #endregion

        #region IKontekst Members

        public void DodajDoKontekstu(IZdjecie zdjecie)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void UsunZKontekstu(IZdjecie zdjecie)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void ZmodyfikowanoZdjecie(IKontekst kontekst, IZdjecie zdjecie, RodzajModyfikacjiZdjecia rodzaj)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        #endregion
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Text;

namespace Photo
{
    /// <summary>
    /// Klasa zawierajaca podstawowe informacje o katalogu
    /// </summary>
    public class Katalog
    {
        string path;
        bool do_gory;

        /// <summary>
        /// Konstruktor
        /// </summary>
        /// <param name="p">Sciezka katalogu na dysku twardym</param>
        /// <param name="d">Czy katalog jest linkiem do katalogu nadrzednego</param>
        public Katalog(string p, bool d)
        {
            path = p;
            do_gory = d;
        }

        /// <summary>
        /// Propercja zwracajaca sciezke katalogu
        /// </summary>
        public string Path
        {
            get
            {
                return path;
            }
        }

        /// <summary>
        /// Propercja zwracajaca wartosc boolowska, czy katalog jest linkiem do katalogu nadrzednego
        /// </summary>
        public bool CzyDoGory
        {
            get
            {
                return do_gory;
            }
        }

    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;
using System.Windows.Forms;
using System.Threading;

namespace Photo
{
    public class WidokMiniatur : System.Windows.Forms.ListView, IOpakowanieZdjec, IKontekst
    {
        private int defaultImageSize;
        private List<IZdjecie> miniatury = new List<IZdjecie>();
        private double zoom;
        private bool Edycja;
        private Semaphore sem_dodawania = new Semaphore(0, 1);

        public WidokMiniatur()
        {
            LargeImageList = new ImageList();
            LargeImageList.ColorDepth = System.Windows.Forms.ColorDepth.Depth32Bit;
            LargeImageList.Tag = "100%";
            LargeImageList.TransparentColor = System.Drawing.Color.Transparent;
            defaultImageSize = 120;
            zoom = 1.0;
            LargeImageList.ImageSize = new Size((int)(zoom * this.defaultImageSize), (int)(zoom * this.defaultImageSize));

            sem_dodawania.Release();
            //Activate double buffering

            //Enable the OnNotifyMessage event so we get a chance to filter out 
            // Windows messages before they get to the form's WndProc
            this.SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true);
            this.SetStyle(ControlStyles.EnableNotifyMessage, true);
        }
        public WidokMiniatur(int imgSize)
            : this()
        {
            this.defaultImageSize = imgSize;
            LargeImageList.ImageSize = new Size((int)(zoom * this.defaultImageSize), (int)(zoom * this.defaultImageSize));
        }

        protected override void OnNotifyMessage(Message m)
        {
            //Filter out the WM_ERASEBKGND message
            if (m.Msg != 0x14)
            {
                base.OnNotifyMessage(m);
            }
        }

        public void AddImages(List<IZdjecie> images)
        {
            this.miniatury.AddRange(images);
        }

        public void ShowImages()
        {
            Zdjecie z;
            Bitmap newBitmap;
            Graphics MyGraphics;
            Rectangle MyRectan;
            ImageList newImageList = new ImageList();
            ListViewItem listViewItem;

            int maxSize = LargeImageList.ImageSize.Width;
            int scaledH, scaledW, posX, posY;

            LargeImageList.Images.Clear();
            this.Items.Clear();

            for (int i = 0; i < miniatury.Count; i++)
            {
                z = (Zdjecie)miniatury[i];
                newBitmap = new Bitmap(maxSize, maxSize);
                MyGraphics = Graphics.FromImage(newBitmap);

                if (z.Miniatura.Height > z.Miniatura.Width)
                {
                    scaledH = maxSize;
                    scaledW = (int)Math.Round((double)(z.Miniatura.Width * scaledH) / z.Miniatura.Height);
                    posX = (maxSize - scaledW) / 2;
                    posY = 0;
                }
                else
                {
                    scaledW = maxSize;
                    scaledH = (int)Math.Round((double)(z.Miniatura.Height * scaledW) / z.Miniatura.Width);
                    posX = 0;
                    posY = (maxSize - scaledH) / 2;
                }

                MyRectan = new Rectangle(posX, posY, scaledW, scaledH);
                using (Pen p = new Pen(Brushes.LightGray))
                {
                    MyGraphics.DrawRectangle(p, 0, 0, maxSize - 1, maxSize - 1);
                }
                MyGraphics.DrawImage(z.Miniatura, MyRectan);
                newBitmap.Tag = z;
                LargeImageList.Images.Add(newBitmap);
                listViewItem = this.Items.Add(new ListViewItem(z.NazwaPliku));
                listViewItem.ImageIndex = i;
            }

            // Update the ListView control
            this.Refresh();
        }

        #region IOpakowanieZdjec Members

        public IZdjecie this[int numer]
        {
            get { return miniatury[numer]; }
        }

        public int Ilosc
        {
            get { return miniatury.Count; }
        }

        public void Dodaj(IZdjecie zdjecie)
        {
            sem_dodawania.WaitOne();
            miniatury.Add(zdjecie);
            int maxSize = LargeImageList.ImageSize.Width;
            int scaledH, scaledW, posX, posY;
            Bitmap newBitmap = new Bitmap(maxSize, maxSize);
            Graphics MyGraphics = Graphics.FromImage(newBitmap);

            if (zdjecie.Miniatura.Height > zdjecie.Miniatura.Width)
            {
                scaledH = maxSize;
                scaledW = (int)Math.Round(
                    (double)(zdjecie.Miniatura.Width * scaledH) / zdjecie.Miniatura.Height);
                posX = (maxSize - scaledW) / 2;
                posY = 0;
            }
            else
            {
                scaledW = maxSize;
                scaledH = (int)Math.Round(
                    (double)(zdjecie.Miniatura.Height * scaledW) / zdjecie.Miniatura.Width);
                posX = 0;
                posY = (maxSize - scaledH) / 2;
            }

            Rectangle MyRectan = new Rectangle(posX, posY, scaledW, scaledH);
            using (Pen p = new Pen(Brushes.LightGray))
            {
                MyGraphics.DrawRectangle(p, 0, 0, maxSize - 1, maxSize - 1);
            }
            MyGraphics.DrawImage(zdjecie.Miniatura, MyRectan);
            newBitmap.Tag = zdjecie;
            LargeImageList.Images.Add(newBitmap);
            ListViewItem listViewItem = new ListViewItem(zdjecie.NazwaPliku);
            listViewItem.ImageIndex = LargeImageList.Images.Count - 1;
            this.Items.Add(listViewItem);
            sem_dodawania.Release();
        }

        public void Usun(IZdjecie zdjecie)
        {
            miniatury.Remove(zdjecie);
        }

        public void Oproznij()
        {
            miniatury.Clear();
        }

        public IZdjecie[] WybraneZdjecia()
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void RozpocznijEdycje()
        {
            Edycja = true;
        }

        public void ZakonczEdycje()
        {
            Edycja = false;
            foreach (IZdjecie zdjecie in miniatury)
            {
                zdjecie.WykonajOperacje();
                zdjecie.UsunWszystkieOperacje();
            }
        }

        public void DodajOperacje(PolecenieOperacji operacja)
        {
            if (Edycja == false)
            {
                RozpocznijEdycje();
                foreach (IZdjecie zdjecie in miniatury)
                {
                    zdjecie.DodajOperacje(operacja);
                }
                ZakonczEdycje();
            }
            else
            {
                foreach (IZdjecie zdjecie in miniatury)
                {
                    zdjecie.DodajOperacje(operacja);
                }
            }
        }

        public void UsunWszystkieOperacje()
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public event WybranoZdjecieDelegate WybranoZdjecie;

        public void Wypelnij(IZdjecie[] zdjecia)
        {
            sem_dodawania.WaitOne();
            miniatury.Clear();
            miniatury.AddRange(zdjecia);
            foreach (Zdjecie z in zdjecia)
            {
                if (!z.Miniatura.RawFormat.Equals(ImageFormat.Jpeg) && !z.Miniatura.RawFormat.Equals(ImageFormat.Tiff))
                {
                    miniatury.Remove(z);
                }
            }
            ShowImages();
            sem_dodawania.Release();
        }

        #endregion

        #region IKontekst Members

        public void DodajDoKontekstu(IZdjecie zdjecie)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void UsunZKontekstu(IZdjecie zdjecie)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void ZmodyfikowanoZdjecie(IKontekst kontekst, IZdjecie zdjecie, RodzajModyfikacjiZdjecia rodzaj)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        #endregion
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Text;

namespace Photo
{
    class Wyszukiwanie : IWyszukiwanie
    {
        private List<string> wynik = new List<string>();

        #region IWyszukiwanie Members

        public void And(IWyszukiwanie W)
        {
            wynik.AddRange(((Wyszukiwanie)W).wynik);
        }

        public void Or(IWyszukiwanie W)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void And(string Tabela, string Wartosc)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void Or(string Tabela, string Wartosc)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void And(string WyrazenieSQL)
        {
            wynik.Add(WyrazenieSQL);
        }

        public void Or(string WyrazenieSQL)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public IZdjecie[] PodajWynik()
        {
            List<Zdjecie> zdjecia = new List<Zdjecie>();
            foreach (string plik in wynik)
            {
                Zdjecie zdjecie = new Zdjecie(plik);
                zdjecia.Add(zdjecie);
            }
            return zdjecia.ToArray();
        }

        #endregion
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;
using System.Data.SQLite;
using System.Data.SqlClient;

namespace Photo
{
    /// <summary>
    /// Klasa imlementująca UserControl i interjfejs IWyszukiwacz odpowiada za sworzenie kontrolki do wyszukiwanie i za realizacje wyszukania odpowiednich zdjęć w bazie
    /// </summary>
    public partial class WyszukiwarkaControl : UserControl, IWyszukiwacz    
    {
        /// <summary>
        /// Konstruktor
        /// </summary>
        public WyszukiwarkaControl()
        {
            InitializeComponent();
        }

        public IWyszukiwacz wyszukiwacz_albumow;

        /// <summary>
        /// Metoda realizująca zapytanie sql do bazy i zwracająca liste zdjęc która została sworzona w oparciu o wynik zapytania
        /// </summary>
        /// <returns>lista zdjęć która spełnia warunki wyszukania</returns>
        private List<Zdjecie> ZwrocWyszukanie()
        {
            Db baza = new Db();
            baza.Polacz();
            List<Zdjecie> lista_zdjec = new List<Zdjecie>();

            try
            {
                string pelna_sciezka;
                DataSet ds;

                /*ds = baza.Select("select sciezka,nazwa_pliku from Zdjecie");

                foreach (DataTable t in ds.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        if (!(r[0] is DBNull))
                        {
                            pelna_sciezka = r[0] + "\\" + r[1];

                            if (System.IO.File.Exists(pelna_sciezka) == true)
                            {
                                Zdjecie z = new Zdjecie(pelna_sciezka);
                                z.ZweryfikujZdjecie();
                            }
                        }
                    }
                }*/


                string sql = "select sciezka,nazwa_pliku from Zdjecie where ";                                

                foreach (string s in checkedListBox1.CheckedItems)
                {
                    switch (s)
                    {
                        case "po nazwie":
                            sql += " nazwa_pliku like \'%" + textBox1.Text + "%\' or nazwa_pliku like \'" + textBox1.Text + "%\' or nazwa_pliku like \'" + textBox1.Text + "\' or ";
                            break;
                        case "po komentarzu":
                            sql += " komentarz like \'%" + textBox1.Text + "%\' or komentarz like \'" + textBox1.Text + "%\' or komentarz like \'" + textBox1.Text + "\' or ";
                            break;
                        case "po autorze":
                            sql += " autor like \'%" + textBox1.Text + "%\' or autor like \'" + textBox1.Text + "%\' or autor like \'" + textBox1.Text + "\' or ";
                            break;
                    }

                }

                //MessageBox.Show(sql.Substring(0, sql.Length - 4));

                ds = baza.Select(sql.Substring(0, sql.Length - 4));

                foreach (DataTable t in ds.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        if (!(r[0] is DBNull))
                        {
                            pelna_sciezka = r[0] + "\\" + r[1];

                            if (System.IO.File.Exists(pelna_sciezka) == true)
                            {
                                Zdjecie z = new Zdjecie(pelna_sciezka);
                                //z.ZweryfikujZdjecie();

                                if (z.CzyUstawioneId() == true)
                                {
                                    lista_zdjec.Add(z);
                                }
                            }
                        }
                    }
                }

            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad bazy: " + ex.Message);
            }

            return lista_zdjec;
        }

        /// <summary>
        /// Metoda która za pomocą delegatów informuje kontrolke wyświetlająca jakie obiekty zdjęć ma wyświetlić
        /// </summary>
        private void WykonajZapytanie()
        {
            if (textBox1.Text == "" || checkedListBox1.CheckedItems.Count == 0)
            {
                MessageBox.Show("Żeby wyszukać podaj frazę i zaznacz po czym chcesz szukać");
            }
            else
            {
                List<Zdjecie> zdjecia = new List<Zdjecie>();

                if (RozpoczetoWyszukiwanie != null)
                    RozpoczetoWyszukiwanie(null);

                try
                {
                    zdjecia = ZwrocWyszukanie();
                }
                catch (UnauthorizedAccessException)
                {
                    MessageBox.Show("Brak dostępu do wybranego katalogu.");
                    return;
                }

                if (ZakonczonoWyszukiwanie != null)
                    ZakonczonoWyszukiwanie(zdjecia.ToArray(), new Katalog[0], false);
            }
        }

        /// <summary>
        /// Metoda wykonywana gdy użytkownik kliknie przecisk szukaj metoda wywołuje WykonajZapytanie
        /// </summary>
        private void button1_Click(object sender, EventArgs e)
        {
            WykonajZapytanie();            
        }

        #region Wyszukiwacz Members

        /// <summary>
        /// delegat informuję aplikacje ze wyszukiwanie zdjęć się zakończyło
        /// </summary>
        public event ZakonczonoWyszukiwanieDelegate ZakonczonoWyszukiwanie;
        /// <summary>
        /// delegat informuję aplikacje ze wyszukiwanie zdjęć się rozpoczeło
        /// </summary>
        public event RozpoczetoWyszukiwanieDelegate RozpoczetoWyszukiwanie;
        

        /// <summary>
        /// metoda służącza do składania zapytania sql i zwracająca Obiekt Wyszukania
        /// </summary>
        /// <returns>zwraca obiekt Wyszukanie</returns>
        public IWyszukiwanie Wyszukaj()
        {
            throw new Exception("The method or operation is not implemented.");
        }

        #endregion

        /// <summary>
        /// Metoda do możliwości kliknięcia enter po wpisaniu frazy dzięki czemu mechanizm wyszukiwania jest uruchamiany bez wykorzystywania myszki
        /// </summary>
        private void textBox1_KeyPress(object sender, KeyPressEventArgs e)
        {
            Keys k = (Keys)e.KeyChar;
            if (k == Keys.Enter)
            {
                WykonajZapytanie();
            }
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace Photo.DialogBoxes
{
    /// <summary>
    /// Formatka pyta sie uzytkownika czy zapisac zmiany w zdjeciu
    /// </summary>
    public partial class CzyZapisac : Form
    {
        RodzajDecyzji decyzja;

        /// <summary>
        /// Konstruktor
        /// </summary>
        /// <param name="path">Sciezka do pliku</param>
        public CzyZapisac(string path)
        {
            InitializeComponent();
            textBox1.Text = "Czy zapisaŠ niezapisane zmiany w pliku " + path + "?";
        }

        /// <summary>
        /// Propercja zwraca decyzje uzytkownika
        /// </summary>
        public RodzajDecyzji Decyzja
        {
            get
            {
                return decyzja;
            }
        }

        private void Yes_Button_Click(object sender, EventArgs e)
        {
            decyzja = RodzajDecyzji.Tak;
            this.Close();
        }

        private void YesForAll_Click(object sender, EventArgs e)
        {
            decyzja = RodzajDecyzji.TakDlaWszystkich;
            this.Close();
        }

        private void No_Button_Click(object sender, EventArgs e)
        {
            decyzja = RodzajDecyzji.Nie;
            this.Close();
        }

        private void NoForAll_Click(object sender, EventArgs e)
        {
            decyzja = RodzajDecyzji.NieDlaWszystkich;
            this.Close();
        }
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Data;
using System.Text;
using System.Windows.Forms;
using System.Drawing.Imaging;
using System.IO;

namespace Photo
{
    /// <summary>
    /// Kontrolka do wyswietlania zdjecia i jego podstawowej edycji.
    /// </summary>
    public partial class WidokZdjecia : UserControl, IOpakowanieZdjec
    {
        /// <summary>
        /// Konstruktor
        /// </summary>
        public WidokZdjecia()
        {
            InitializeComponent();
            padX = 0;
            padY = 0;
            Edycja = false;
            WidthRatio = 1.0;
            HeightRatio = 1.0;
            zoom = 1.0;
        }

        /// <summary>
        /// Propercja zwraca wartosc boolowska, czy kontrolka ma aktualnie zaladowane zdjecie
        /// </summary>
        public bool czyZaladowaneZdjecie
        {
            get 
            {
                return zdjecie != null;
            }
        }

        /// <summary>
        /// Metoda ustawia kontrolke w tryb dopasowywania wyswietlanego zdjecia do jej rozmiaru
        /// </summary>
        public void UstawDopasowanieDoEkranu()
        {
            DrawMyRectangle(selectedRectangle);
            zoom = 0.0;
            if (this.zdjecie != null)
            {
                Wypelnij(new IZdjecie[] { this.zdjecie });
            }
        }

        /// <summary>
        /// Metoda rysuje obszar zaznaczenia na zdjeciu
        /// </summary>
        public void RysujXorZaznaczenie()
        {
            this.DrawMyRectangle(selectedRectangle);
        }

        /// <summary>
        /// Metoda zwraca kolor piksela we wskazanym polozeniu
        /// </summary>
        /// <param name="x">Wspolrzedna X-owa</param>
        /// <param name="y">Wspolrzedna Y-kowa</param>
        /// <returns></returns>
        private Color MyGetPixel(int x, int y)
        {
            unsafe
            {
                byte* imgPtr = (byte*)(data.Scan0);
                imgPtr += y * data.Stride + x * 3;
                return Color.FromArgb(*(imgPtr++), *(imgPtr++), *imgPtr);
            }
        }

        /// <summary>
        /// Metoda ustawia kolor podanego piksela
        /// </summary>
        /// <param name="x">Wspolrzedna X-owa</param>
        /// <param name="y">Wspolrzedna Y-kowa</param>
        /// <param name="c">Kolor na ktory ma zostac ustawiony piksel</param>
        private void MySetPixel(int x, int y, Color c)
        {
            unsafe
            {
                byte* imgPtr = (byte*)(data.Scan0);
                imgPtr += y * data.Stride + x * 3;
                *(imgPtr++) = c.R;
                *(imgPtr++) = c.G;
                *(imgPtr) = c.B;
            }
        }

        /// <summary>
        /// Medoda xor'uje podany piksel z podanym kolorem
        /// </summary>
        /// <param name="x">Wspolrzedna X-owa</param>
        /// <param name="y">Wspolrzedna Y-kowa</param>
        /// <param name="color">Kolor z ktorym ma zostac xorowany piksel</param>
        private void XorPixel(int x, int y, Color color)
        {

            Color srcPixel = this.MyGetPixel(x, y);
            this.MySetPixel(x, y, Color.FromArgb(color.R ^ srcPixel.R, srcPixel.G ^ color.G, srcPixel.B ^ color.B));

        }

        /// <summary>
        /// Metoda rysuje linie
        /// </summary>
        /// <param name="srcPoint">Punkt poczatkowy</param>
        /// <param name="destPoint">Punkt docelowy</param>
        private void DrawMyLine(Point srcPoint, Point destPoint)
        {
            int d, delta_A, delta_B, x, y;
            int dx = destPoint.X - srcPoint.X;
            int dy = destPoint.Y - srcPoint.Y;

            int inc_x = (dx >= 0) ? 1 : -1;
            int inc_y = (dy >= 0) ? 1 : -1;

            dx = Math.Abs(dx);
            dy = Math.Abs(dy);

            x = 0; y = 0;

            if (dx >= dy)
            {
                d = 2 * dy - dx;
                delta_A = 2 * dy;
                delta_B = 2 * (dy - dx);

                for (int i = 0; i < dx; i++)
                {
                    XorPixel(srcPoint.X + x, srcPoint.Y + y, Color.Gray);
                    if (d > 0)
                    {
                        d += delta_B;
                        x += inc_x;
                        y += inc_y;
                    }
                    else
                    {
                        d += delta_A;
                        x += inc_x;
                    }
                }

            }
            else
            {
                d = 2 * dx - dy;
                delta_A = 2 * dx;
                delta_B = 2 * (dx - dy);

                for (int i = 0; i < dy; i++)
                {
                    XorPixel(srcPoint.X + y, srcPoint.Y + x, Color.Gray);
                    if (d > 0)
                    {
                        d += delta_B;
                        y += inc_x;
                        x += inc_y;
                    }
                    else
                    {
                        d += delta_A;
                        x += inc_y;
                    }
                }
            }
        }

        /// <summary>
        /// Metoda rysuje kwadrat
        /// </summary>
        /// <param name="r">Kwadrat ktory ma zostac narysowany</param>
        internal void DrawMyRectangle(Rectangle r)
        {
            data = ((Bitmap)pictureBox1.Image).LockBits(new Rectangle(0, 0, this.pictureBox1.Image.Width, this.pictureBox1.Image.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            DrawMyLine(new Point(r.X, r.Y), new Point(r.X + r.Width, r.Y));
            DrawMyLine(new Point(r.X, r.Y), new Point(r.X, r.Y + r.Height));
            DrawMyLine(new Point(r.X + r.Width, r.Y), new Point(r.X + r.Width, r.Y + r.Height));
            DrawMyLine(new Point(r.X, r.Y + r.Height), new Point(r.X + r.Width, r.Y + r.Height));
            XorPixel(r.X, r.Y, Color.Gray);
            XorPixel(r.X + r.Width, r.Y + r.Height, Color.Gray);
            ((Bitmap)pictureBox1.Image).UnlockBits(data);
        }

        protected override void OnVisibleChanged(EventArgs e)
        {
            base.OnVisibleChanged(e);
            this.checkImagePosition();
        }

        protected override void OnResize(EventArgs e)
        {
            base.OnResize(e);
            this.checkImagePosition();
            Refresh();
        }

        private void onMouseDown(object sender, MouseEventArgs e)
        {
            if (e.Button == MouseButtons.Left)
            {
                isDrag = true;
                this.lmStartingPoint = new Point(e.X - padX, e.Y - padY);
                if (lmStartingPoint.X < 0)
                    isDrag = false;
                if (lmStartingPoint.Y < 0)
                    isDrag = false;
                this.Refresh();
            }
            else if (e.Button == MouseButtons.Right)
            {

            }
        }

        private void onMouseUp(object sender, MouseEventArgs e)
        {

            isDrag = false;
            if (e.Button == MouseButtons.Left)
            {
                //this.zdjecie.Zaznaczenie = new Rectangle((int)(selectedRectangle.X * WidthRatio), (int)(selectedRectangle.Y * HeightRatio), (int)(selectedRectangle.Width * WidthRatio), (int)(selectedRectangle.Height * HeightRatio));
                if (selectedRectangle.Width == 0 || selectedRectangle.Height == 0)
                {
                    zdjecie.Zaznaczenie = new Rectangle(0, 0, 0, 0);
                }
                else
                {

                    if (zoom == 1.0)
                        zdjecie.Zaznaczenie = selectedRectangle;
                    else if (zoom == 0.0)
                        zdjecie.Zaznaczenie = new Rectangle((int)(selectedRectangle.X * WidthRatio), (int)(selectedRectangle.Y * WidthRatio), (int)(selectedRectangle.Width * WidthRatio), (int)(selectedRectangle.Height * WidthRatio));
                    else
                        zdjecie.Zaznaczenie = new Rectangle((int)(selectedRectangle.X / zoom), (int)(selectedRectangle.Y / zoom), (int)(selectedRectangle.Width / zoom), (int)(selectedRectangle.Height / zoom));
                }
                this.Refresh();
            }
            else if (e.Button == MouseButtons.Right)
            {

            }
        }

        private void onMouseMove(object sender, MouseEventArgs e)
        {
            if (isDrag)
            {
                if (e.Button == MouseButtons.Left)
                {
                    int maxX, maxY;

                    if (e.X >= this.pictureBox1.Width)
                        maxX = this.pictureBox1.Width - 1 - padX;
                    else if (e.X - padX < 0)
                        maxX = 0;
                    else
                        maxX = e.X - padX;
                    if (e.Y >= this.pictureBox1.Height)
                        maxY = this.pictureBox1.Height - 1 - padY;
                    else if (e.Y - padY < 0)
                        maxY = 0;
                    else
                        maxY = e.Y - padY;

                    //if (moving == true)
                    this.DrawMyRectangle(selectedRectangle);
                    //else
                    //    moving = true;

                    selectedRectangle = new Rectangle(lmStartingPoint.X, lmStartingPoint.Y, maxX - lmStartingPoint.X, maxY - lmStartingPoint.Y);

                    this.DrawMyRectangle(selectedRectangle);
                    this.Refresh();
                }
            }
        }

        #region IOpakowanieZdjec Members

        /// <summary>
        /// Propercja zwracajaca wyswietlane zdjecie
        /// </summary>
        /// <param name="numer">Parametr pomijany</param>
        /// <returns>Zwroca obiekt implementujacy interfejs IZdjecie</returns>
        public IZdjecie this[int numer]
        {
            get { return zdjecie; }
        }

        /// <summary>
        /// Propercja zwracajaca ilosc wyswietlanych elementow - 0 lub 1
        /// </summary>
        public int Ilosc
        {
            get 
            {
                if (zdjecie != null)
                    return 1;
                else
                    return 0;
            }
        }

        /// <summary>
        /// Metoda dodajaca zdjecie do wyswietlenia
        /// </summary>
        /// <param name="zdjecie">Zdjecie do wyswietlenia</param>
        public void Dodaj(IZdjecie zdjecie)
        {
            Wypelnij(new IZdjecie[] { zdjecie });
        }

        /// <summary>
        /// Metoda usuwajaca zdjecie z wyswietlenia
        /// </summary>
        /// <param name="zdjecie">Zdjecie do usuniecia</param>
        public void Usun(IZdjecie zdjecie)
        {
            Oproznij();
        }

        /// <summary>
        /// Metoda czyszczaca obszar wyswietlania
        /// </summary>
        public void Oproznij()
        {
            if (this.zdjecie != null)
            {
                this.zdjecie.Dispose();
                this.zdjecie = null;
            }
            if (this.pictureBox1.Image != null)
            {
                this.pictureBox1.Image.Dispose();
                this.pictureBox1.Image = null;
            }
        }

        /// <summary>
        /// Propercja zwraca wybrane (zaznaczone) zdjecia 
        /// </summary>
        public IZdjecie[] WybraneZdjecia
        {
            get { return new IZdjecie[] { this.zdjecie }; }
        }

        /// <summary>
        /// Metoda rozpoczynajaca tryb szybkiej edycji
        /// </summary>
        public void RozpocznijEdycje()
        {
            Edycja = true;
        }

        /// <summary>
        /// Metoda konczaca tryb szybkiej edycji - wykonujaca wszystkie oczekujace operacje
        /// </summary>
        public void ZakonczEdycje()
        {
            Edycja = false;
            if (this.pictureBox1.Image == null)
                return;
            RysujXorZaznaczenie();
            zdjecie.WykonajOperacje();
            zdjecie.UsunWszystkieOperacje();
            if (pictureBox1.Image.Width == zdjecie.Duze.Width && pictureBox1.Image.Height == zdjecie.Duze.Height)
            {
                //RysujXorZaznaczenie();
            }
            Wypelnij(new Zdjecie[] { zdjecie });
            
        }

        /// <summary>
        /// Metoda dodajaca operacje do wykonania na zdjeciu
        /// </summary>
        /// <param name="operacja">Obiekt bedacy poleceniem operacji</param>
        public void DodajOperacje(PolecenieOperacji operacja)
        {
            if (pictureBox1.Image == null)
                return;
            if (Edycja == false)
            {
                RozpocznijEdycje();
                zdjecie.DodajOperacje(operacja);
                ZakonczEdycje();
            }
            else
                zdjecie.DodajOperacje(operacja);
        }

        /// <summary>
        /// Metoda usuwajaca wszystkie operacje na zdjeciu
        /// </summary>
        public void UsunWszystkieOperacje()
        {
            zdjecie.UsunWszystkieOperacje();
        }

        /// <summary>
        /// Zdarzenie informujace o wybraniu zdjecia
        /// </summary>
        public event WybranoZdjecieDelegate WybranoZdjecie;

        /// <summary>
        /// Metoda niezywana
        /// </summary>
        public void Wypelnij(IZdjecie[] zdjecia, Katalog[] k, bool CzyZDrzewa)
        {
            throw new Exception("This method is not used");
        }

        /// <summary>
        /// Zdarzenie informujace o modyfikacji zdjecia
        /// </summary>
        public event ZmodyfikowanoZdjecieDelegate ZmodyfikowanoZdjecie;

        /// <summary>
        /// Metoda wypelniajaca kontrolke przekazanym zdjeciem
        /// </summary>
        /// <param name="zdjecia">Tablica zdjec</param>
        public void Wypelnij(IZdjecie[] zdjecia)
        {
            if (zdjecia.Length != 0)
            {
                //this.Oproznij();
                Zdjecie temp = this.zdjecie;
                this.zdjecie = (Zdjecie)zdjecia[0];
                this.pictureBox1.Image = ZoomImage();
                this.checkImagePosition();
                this.lmStartingPoint = new Point();
                this.selectedRectangle = new Rectangle(0, 0, 0, 0);
                zdjecie.Zaznaczenie = selectedRectangle;
                if (temp != zdjecie && temp != null)
                {
                    if (temp.Edytowano)
                    {
                        RodzajDecyzji decyzja = temp.ZapisanieNiezapisanych();
                        switch (decyzja)
                        {
                            case RodzajDecyzji.Tak:
                                temp.Zapisz();
                                break;
                            case RodzajDecyzji.Nie:
                                break;
                            case RodzajDecyzji.TakDlaWszystkich:
                                temp.Zapisz();
                                break;
                            case RodzajDecyzji.NieDlaWszystkich:
                                break;
                        }
                        
                    }
                    temp.Dispose();
                    if (ZmodyfikowanoZdjecie != null)
                        ZmodyfikowanoZdjecie(null, temp, RodzajModyfikacjiZdjecia.Zawartosc);
                }
                this.Refresh();
            }
        }

        #endregion

        /// <summary>
        /// Propercja zwracajaca/ustawiajaca zdjecie
        /// </summary>
        public Zdjecie Zdjecie
        {
            get
            {
                return zdjecie;
            }
            set
            {
                zdjecie = value;
            }
        }

        /// <summary>
        /// Metoda zapisujaca zmiany na zdjeciu
        /// </summary>
        public void ZapiszPlik()
        {
            if (czyZaladowaneZdjecie == false)
                return;
            try
            {
                zdjecie.Zapisz();
            }
            catch (DirectoryNotFoundException)
            {
                MessageBox.Show("Wybrana scieżka nie istnieje!", "Błąd!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        }

        /// <summary>
        /// Metoda zmieniajaca rozmiar zdjecia w zaleznosci od wybranego zoom'a
        /// </summary>
        /// <returns></returns>
        private Image ZoomImage()
        {
            if (zoom == 0.0)
            {
                return FitToPage();
            }
            else if (zoom == 1.0)
            {
                return zdjecie.Duze;
            } 
            else
            {
                int scaledH, scaledW;

                if (zdjecie.Duze.Height > zdjecie.Duze.Width)
                {
                    scaledH = (int)(zdjecie.Duze.Height * zoom);
                    scaledW = (int)Math.Round((double)(zdjecie.Duze.Width * scaledH) / zdjecie.Duze.Height);
                }
                else
                {
                    scaledW = (int)(zdjecie.Duze.Width * zoom);
                    scaledH = (int)Math.Round((double)(zdjecie.Duze.Height * scaledW) / zdjecie.Duze.Width);
                }

                Bitmap newBitmap = new Bitmap(scaledW, scaledH);
                Graphics MyGraphics = Graphics.FromImage(newBitmap);
                MyGraphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;

                Rectangle MyRectan = new Rectangle(0, 0, scaledW, scaledH);
                MyGraphics.DrawImage(zdjecie.Duze, MyRectan);
                MyGraphics.Dispose();
                WidthRatio = zdjecie.Duze.Width / scaledW;
                HeightRatio = zdjecie.Duze.Height / scaledH;
                return newBitmap;
            }
        }

        /// <summary>
        /// Metoda ustawiajaca zdjecie na srodku widoku
        /// </summary>
        private void checkImagePosition()
        {
            if (this.pictureBox1.Image != null)
            {
                if (this.Width > pictureBox1.Image.Width)
                {
                    padX = (this.Width - pictureBox1.Image.Width) / 2;
                }
                else
                {
                    padX = 0;
                }

                if (this.Height > pictureBox1.Image.Height)
                {
                    padY = (this.Height - pictureBox1.Image.Height) / 2;
                }
                else
                {
                    padY = 0;
                }
                this.pictureBox1.Padding = new Padding(padX, padY, 0, 0);
                this.pictureBox1.Width = pictureBox1.Image.Width + padX;
                this.pictureBox1.Height = pictureBox1.Image.Height + padY;
            }
        }

        /// <summary>
        /// Metoda dopasowujaca zdjecie do rozmiarow kontrolki
        /// </summary>
        /// <returns></returns>
        public Bitmap FitToPage()
        {
            int scaledH, scaledW;
            int wDiff, hDiff;

            hDiff = zdjecie.Duze.Height - this.Height;
            wDiff = zdjecie.Duze.Width - this.Width;

            if (hDiff > wDiff)
            {
                scaledH = this.Height;
                scaledW = (int)Math.Round((double)(zdjecie.Duze.Width * scaledH) / zdjecie.Duze.Height);
            }
            else
            {
                scaledW = this.Width;
                scaledH = (int)Math.Round((double)(zdjecie.Duze.Height * scaledW) / zdjecie.Duze.Width);
            }

            Bitmap newBitmap = new Bitmap(scaledW, scaledH);
            Graphics MyGraphics = Graphics.FromImage(newBitmap);
            MyGraphics.InterpolationMode = System.Drawing.Drawing2D.InterpolationMode.HighQualityBicubic;

            Rectangle MyRectan = new Rectangle(0, 0, scaledW, scaledH);
            MyGraphics.DrawImage(zdjecie.Duze, MyRectan);
            MyGraphics.Dispose();
            WidthRatio = (double)zdjecie.Duze.Width / scaledW;
            HeightRatio = (double)zdjecie.Duze.Height / scaledH;
            return newBitmap;
        }

        /// <summary>
        /// Metoda ustawiajaca zoom
        /// </summary>
        /// <param name="z">Zmienna typu "double", wieksza od 0.</param>
        internal void Zoom(double z)
        {
            if (z <= 0)
                return;
            if (zoom != z)
            {
                if (this.pictureBox1.Image != null)
                    DrawMyRectangle(selectedRectangle);
                zoom = z;
                if (this.zdjecie != null)
                {
                    Wypelnij(new IZdjecie[] { this.zdjecie });
                }
            }
            
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    public partial class MiniaturaControl : UserControl, IZdjecie
    {
        List<PolecenieOperacji> operacje = new List<PolecenieOperacji>();

        public MiniaturaControl()
        {
            InitializeComponent();
            pictureBox1.Click += new EventHandler(pictureBox1_Click);
        }

        public MiniaturaControl(IZdjecie zdjecie)
        {
            InitializeComponent();
            pictureBox1.Click += new EventHandler(pictureBox1_Click);
        }

        new public event EventHandler Click;

        void pictureBox1_Click(object sender, EventArgs e)
        {
            zaznaczone = !zaznaczone;
            if (Click != null)
            {
                if (zaznaczone)
                    Click(this, e);
                else
                    Click(null, e);
            }
        }

        public string ImageLocation
        {
            set
            {
                pictureBox1.ImageLocation = value;
            }
            get
            {
                return pictureBox1.ImageLocation;
            }
        }

        public bool zaznaczone
        {
            get
            {
                return (BackColor == Color.YellowGreen) ? true : false;
            }

            set
            {
                if (value == true)
                {
                    BackColor = Color.YellowGreen;
                }
                else
                {
                    BackColor = Color.Olive;
                }
            }
        }

        #region Zdjecie Members

        public void DodajOperacje(PolecenieOperacji polecenie)
        {
            operacje.Add(polecenie);
        }

        public void WykonajOperacje()
        {
            if (operacje.Count > 0)
            {
                foreach (PolecenieOperacji polecenie in operacje)
                {
                    polecenie.Wykonaj((Bitmap)pictureBox1.Image);
                }
                if (ZmodyfikowanoZdjecie != null)
                    ZmodyfikowanoZdjecie(null, this, RodzajModyfikacjiZdjecia.Zawartosc);
            }
        }

        public void UsunWszystkieOperacje()
        {
            operacje.Clear();
        }

        public Image Miniatura
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public event ZmodyfikowanoZdjecieDelegate ZmodyfikowanoZdjecie;

        #endregion
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Text;

namespace Photo
{
    /// <summary>
    /// Formatka dzieiczaca po StatusStrip, wyswietlajaca wazne dla uzytkownika informacje.
    /// </summary>
    class PasekStanuControl : StatusStrip
    {
        private ToolStripStatusLabel wyszukiwanieLabel;
        private ToolStripStatusLabel katalogLabel;
        private ToolStripSeparator sep;

        /// <summary>
        /// Konstruktor
        /// </summary>
        public PasekStanuControl() :
            base()
        {
            InitializeComponent();

            this.Items.Add(wyszukiwanieLabel);
            this.Items.Add(sep);
            this.Items.Add(katalogLabel);
        }

        /// <summary>
        /// Metoda informujaca uzytkownika o rozpoczeniu wyszukiwania
        /// </summary>
        public void RozpoczetoWyszukiwanie(IWyszukiwanie wyszukiwanie)
        {
            wyszukiwanieLabel.Text = "Rozpoczęto: Wyszukiwanie";
            this.Invalidate();
        }

        /// <summary>
        /// Metoda informujaca uzytkownika o zakonczeniu wyszukiwania
        /// </summary>
        public void ZakonczonoWyszukiwanie(IZdjecie[] zdjecia, Katalog[] k, bool czyzdrzewa)
        {
            wyszukiwanieLabel.Text = "Zakończono: Wyszukiwanie";
        }

        /// <summary>
        /// Metoda informujaca uzytkownika o rozpoczeniu akcji
        /// </summary>
        /// <param name="Nazwa">Nazwa akcji do wyswietlenia</param>
        public void RozpoczetoAkcje(string Nazwa)
        {
            wyszukiwanieLabel.Text = "Rozpoczęto: " + Nazwa;
        }

        /// <summary>
        /// Metoda informujaca uzytkownika o zakonczeniu akcji
        /// </summary>
        /// <param name="Nazwa">Nazwa akcji do wyswietlenia</param>
        public void ZakonczonoAkcje(string Nazwa)
        {
            wyszukiwanieLabel.Text = "Zakońcono: " + Nazwa;
        }

        /// <summary>
        /// Metoda informujaca uzytkownika o zmianie zrodla wyswietlanych zdjec
        /// </summary>
        /// <param name="dir">Nazwa zrodla do wyswietlenia</param>
        public void ZmienionoZrodlo(string dir)
        {
            katalogLabel.Text = dir;
        }

        /// <summary>
        /// Metoda inicjalizujaca formatke
        /// </summary>
        private void InitializeComponent()
        {
            //Label Wyszukiwanie
            wyszukiwanieLabel = new ToolStripStatusLabel();
            wyszukiwanieLabel.Text = "Aplikacja uruchomiona";

            //Separator
            sep = new ToolStripSeparator();

            //Label Katalog
            katalogLabel = new ToolStripStatusLabel();
            katalogLabel.Spring = true;
            katalogLabel.TextAlign = System.Drawing.ContentAlignment.MiddleLeft;
        }
    }
}
<file_sep>
using System.Collections.Generic;
using System.Drawing;

namespace Photo
{
    /// <summary>
    /// Interfejs implementowany przez klasy które chcą wykonywać operacje na bitmapach.
    /// </summary>
    public interface IOperacja
    {
        /// <summary>
        /// Zwraca nazwę operacji.
        /// </summary>
        string NazwaOperacji
        {
            get;
        }
        /// <summary>
        /// Zwraca kod operacji, kod jest przydzielany przez aplikację podczas uruchamiania.
        /// Służy do jednoznacznej identyfikacji operacji (nazwa być nie musi).
        /// </summary>
        int KodOperacji
        {
            get;
            set;
        }
        /// <summary>
        /// Ikona wyświetlana w menu operacji.
        /// </summary>
        Image Ikona
        {
            get;
        }
        /// <summary>
        /// Autor implementacji.
        /// </summary>
        string Autor
        {
            get;
        }
        /// <summary>
        /// Wersja implementacji.
        /// </summary>
        string Wersja
        {
            get;
        }
        /// <summary>
        /// Kontakt do autora implementacji.
        /// </summary>
        string Kontakt
        {
            get;
        }
        /// <summary>
        /// Wywoływana gdy użytkownik chce wykonać operację. Ma na celu zebranie potrzebnych argumentów, np.
        /// przez wyświetlenie okna dialogowego.
        /// </summary>
        /// <returns>Wartości argumentów ustalone przez użytkownika.</returns>
        Stack<object> PodajArgumenty();
        /// <summary>
        /// Wykonuje zaimplementowaną operacje graficzną na bitmapie.
        /// </summary>
        /// <param name="Bitmap">Bitmapa na której ma zostać wykonana operacja.</param>
        /// <param name="Argumenty">Argumenty dla operacji. Na dnie stosu leży argument pierwszy.</param>
        void Wykonaj(Bitmap Bitmap, Stack<object> Argumenty);
    }

    /// <summary>
    /// Delegat informujący o wybraniu zdjęcia z pewnego zbioru.
    /// </summary>
    /// <param name="zdjecie">Wybrany obiekt.</param>
    public delegate void WybranoZdjecieDelegate(IZdjecie zdjecie);

    /// <summary>
    /// Interfejs który przechowuje zbiór zdjęć (elementów implementujących interfejs IZdjecie).
    /// Powinien znać podzbiór zdjęć wybranych przez użytkownika.
    /// Posiada stan Edycja. Jeśli stan Edycja jest aktywny opakowanie zbiera polecenia operacji 
    /// (PolecenieOperacji), które wykona na zdjęciach wybranych przez użytkownika przy zmianie stanu 
    /// Edycja na nieaktywny.
    /// </summary>
    /// <seealso cref="IZdjecie"/>
    public interface IOpakowanieZdjec
    {
        /// <summary>
        /// Indekser pozwalający uzyskać zdjęcie (IZdjecie) ze zbioru.
        /// </summary>
        /// <param name="numer">Indeks zdjęcia.</param>
        /// <returns></returns>
        IZdjecie this[int numer]
        {
            get;
        }
        /// <summary>
        /// Zwraca liczbe przechowywanych zdjęć.
        /// </summary>
        int Ilosc
        {
            get;
        }
        /// <summary>
        /// Umieszcza obiekt typu IZdjecie w zbiorze.
        /// </summary>
        /// <param name="zdjecie">Obiekt który chcemy dodać.</param>
        void Dodaj(IZdjecie zdjecie);
        /// <summary>
        /// Usuwa zdjęcie ze zbioru.
        /// </summary>
        /// <param name="zdjecie">Obiekt który chcemy usunąć.</param>
        void Usun(IZdjecie zdjecie);
        /// <summary>
        /// Powoduje ze opakowanie staje się puste.
        /// </summary>
        void Oproznij();
        /// <summary>
        /// Zwraca zdjęcia wybrane przez użytkownika.
        /// </summary>
        /// <returns></returns>
        IZdjecie[] WybraneZdjecia();
        /// <summary>
        /// Rozpoczyna edycję (stan Edycja staje sie aktywny).
        /// Jeśli stan Edycja był aktywny już wcześniej - nie wykonuje nic.
        /// </summary>
        void RozpocznijEdycje();
        /// <summary>
        /// Zmienia stan Edycja na nieaktywny.
        /// Jeśli stan edycja był aktywny, wykonuje wszystkie polecenia operacji od momentu 
        /// ostatniej zmiany stanu Edycja z nieaktywnego na aktywny.
        /// </summary>
        void ZakonczEdycje();
        /// <summary>
        /// Dodaje polecenie operacji do zdjęć wybranych przez użytkownika.
        /// Jeśli stan Edycja jest nieaktywny, to wykonuje operację natychmiast.
        /// </summary>
        /// <param name="operacja">Obiekt polecenia operacji która ma zostać wykonana.</param>
        void DodajOperacje(PolecenieOperacji operacja);
        void UsunWszystkieOperacje();
        /// <summary>
        /// Zdarzenie informujące o wskazaniu nowego zdjęcia przez użytkownika.
        /// Gdy nie jest wybrane żadne zdjęcie, delegaci otrzymują wartość null jako argument.
        /// </summary>
        /// <seealso cref="WybranoZdjecieDelegate"/>
        event WybranoZdjecieDelegate WybranoZdjecie;
        /// <summary>
        /// Powoduje że opakowanie wypełnia się nowym zbiorem zdjęć.
        /// </summary>
        /// <param name="zdjecia">Nowy zbiór obiektów dla opakowania.</param>
        void Wypelnij(IZdjecie[] zdjecia);
    }

    public enum RodzajModyfikacjiZdjecia
    {
        Zawartosc,
        Metadane,
        Lokalizacja,
        UsunietoZBazy,
        UsunietoZDysku,
        DodanoDoBazy
    }

    /// <summary>
    /// Delagat zdarzenia modyfikacji zdjęcia.
    /// </summary>
    /// <param name="zdjecie">Zdjęcie które zostało zmodyfikowane.</param>
    public delegate void ZmodyfikowanoZdjecieDelegate(IKontekst kontekst, IZdjecie zdjecie, RodzajModyfikacjiZdjecia rodzaj);

    /// <summary>
    /// Interfejs opisujący zdjęcie.
    /// </summary>
    public interface IZdjecie
    {
        /// <summary>
        /// Dodaje polecenie operacji do zdjęcia. Lista operacji zostanie wykonana metodą WykonajOperacje.
        /// </summary>
        /// <param name="operacja">Obiekt polecenia operacji do wykonania.</param>
        void DodajOperacje(PolecenieOperacji operacja);
        /// <summary>
        /// Wykonuje listę operacji dodanych metodą DodajOperacje.
        /// </summary>
        void WykonajOperacje();
        /// <summary>
        /// Usuwa wszystkie polecenia operacji z listy.
        /// </summary>
        void UsunWszystkieOperacje();
        /// <summary>
        /// Propercja podająca obrazek przedstawiający miniaturę zdjęcia.
        /// </summary>
        System.Drawing.Image Miniatura
        {
            get;
        }
        /// <summary>
        /// Zdarzenie informujące o modyfikacji zdjęcia.
        /// </summary>
        /// <seealso cref="ZmodyfikowanoZdjecieDelegate"/>
        event ZmodyfikowanoZdjecieDelegate ZmodyfikowanoZdjecie;
    }

    /// <summary>
    /// Interfejs dla obiektów które chcą być kontekstem w którym pojawia się zdjęcie.
    /// Umożliwia to reakcję na zmiany zachodzące na obiekcie IZdjecie, które znajduje
    /// się w wielu kontekstach przez każdy z kontekstów.
    /// </summary>
    public interface IKontekst
    {
        /// <summary>
        /// Umieszcza obiekt typu IZdjecie w kontekście.
        /// </summary>
        /// <param name="zdjecie">Obiekt który chcemy dodać.</param>
        void DodajDoKontekstu(IZdjecie zdjecie);
        /// <summary>
        /// Usuwa zdjęcie z tego kontekstu.
        /// </summary>
        /// <param name="zdjecie">Obiekt który chcemy usunąć.</param>
        void UsunZKontekstu(IZdjecie zdjecie);
        /// <summary>
        /// Wywoływany w momencie modyfikacji zdjęcia przez któryś z kontekstów.
        /// </summary>
        /// <param name="kontekst">Kontekst który dokonał modyfikacji.</param>
        /// <param name="zdjecie">Zdjęcie które zostało zmodyfikowane.</param>
        /// <param name="rodzaj">Rodzaj modyfikacji.</param>
        void ZmodyfikowanoZdjecie(IKontekst kontekst, IZdjecie zdjecie, RodzajModyfikacjiZdjecia rodzaj);
    }

    /// <summary>
    /// Delegat informujący o zakończeniu wyszukiwania.
    /// </summary>
    /// <param name="zdjecia">Lista zdjęć bedąca wynikiem wyszukiwania.</param>
    public delegate void ZakonczonoWyszukiwanieDelegate(IZdjecie[] zdjecia);

    /// <summary>
    /// Interfejs dla obiektu wyszukującego zdjęcia.
    /// </summary>
    public interface IWyszukiwacz
    {
        /// <summary>
        /// Metoda wykonuje proces wyszukiwania. 
        /// </summary>
        /// <returns></returns>
        IWyszukiwanie Wyszukaj();
        event ZakonczonoWyszukiwanieDelegate ZakonczonoWyszukiwanie;
    }

    /// <summary>
    /// Interfejs dla obiektów wyrażeń wyszukujących, które można bezpośrednio zamienić na 
    /// rezultat (zbiór obiektów typu IZdjęcie) będący wynikiem tego wyrażenia.
    /// Umożliwia składanie wyrażeń spójnikami logicznymi.
    /// </summary>
    public interface IWyszukiwanie
    {
        /// <summary>
        /// Koniunkcja z innym wyrażeniem.
        /// </summary>
        /// <param name="W">IWyszukiwanie będące drugim argumentem koniunkcji.</param>
        void And(IWyszukiwanie W);
        /// <summary>
        /// Alternatywa z innym wyrażeniem.
        /// </summary>
        /// <param name="W">IWyszukiwanie będące drugim argumentem alternatywy.</param>
        void Or(IWyszukiwanie W);
        /// <summary>
        /// Koniunkcja tego wyrażenia z warunkiem dla relacji.
        /// Na przykład: warunek dla 'data_wykonania' w relacji 'zdjecie'.
        /// </summary>
        /// <param name="Relacja"></param>
        /// <param name="Wartosc"></param>
        void And(string Relacja, string Warunek);
        void Or(string Relacja, string Warunek);
        void And(string Wyrazenie);
        void Or(string Wyrazenie);
        /// <summary>
        /// Zwraca tablicę zdjęc będącą rezultatem tego wyrażenia wyszukującego.
        /// </summary>
        /// <returns></returns>
        IZdjecie[] PodajWynik();
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Data.SQLite;
using System.Data.SqlClient;

namespace Photo
{
    /// <summary>
    /// Klasa tworząca formatke dodającą albumy do zdjęć
    /// </summary>
    public partial class Dodaj_albumy_do_zdjecia : Form
    {                
        private List<Zdjecie> lista_zdjec;
        private int opcja = 0;//1 - dodawanie z katalogu  // 2 - dodawanie z miniaturek        
        private string sciezka;
        private FileTree drzewo;
        private PrzegladarkaZdjec przegladarka;

        /// <summary>
        /// Konstruktor
        /// </summary>
        /// <param name="z">zdjecie dla którego ma formatka być wywołana</param>
        public Dodaj_albumy_do_zdjecia(Zdjecie z)
        {
            InitializeComponent();
            //zdjecie = z;
            //Wypelnij();
            //opcja = 1;
        }
        /// <summary>
        /// Konstruktor wykorzystywaby gdy wywołujemy formatke dodawania z widoku miniatur
        /// </summary>
        /// <param name="lis_z">lista zdjęć dla których mają być dodane albumy</param>
        /// <param name="pr">obiekt przeglądarki zdjęć potrzebny do wywołania metod z tego obiektu</param>
        /// <param name="s">scieżka zdjęcia/zdjęć dla którego/których wykonuje się dodawanie do albumu</param>
        public Dodaj_albumy_do_zdjecia(List<Zdjecie> lis_z, PrzegladarkaZdjec pr, string s)
        {
            InitializeComponent();
            lista_zdjec = lis_z;
            przegladarka = pr;
            if (lista_zdjec.Count == 1 && lista_zdjec[0].CzyUstawioneId() == true)
            {                
                Wypelnij(lista_zdjec[0]);
            }
            else
            {
                Wypelnij_dla_kilku();
            }

            sciezka = s.Substring(0, s.LastIndexOf("\\"));
            if (sciezka.Length == 2)
                sciezka += "\\";
            opcja = 2;
        }
        /// <summary>
        /// Konstruktor wykorzystywaby gdy wywołujemy formatke dodawania z drzewa katalogów
        /// </summary>
        /// <param name="lis_z">lista zdjęć dla których mają być dodane albumy</param>
        /// <param name="tr">obiekt drzewa katalogów potrzebny do wywołania metod z tego obiektu</param>
        /// <param name="s">scieżka zdjęcia/zdjęć dla którego/których wykonuje się dodawanie do albumu</param>
        public Dodaj_albumy_do_zdjecia(List<Zdjecie> lis_z, FileTree tr, string s)
        {
            InitializeComponent();
            lista_zdjec = lis_z;
            drzewo = tr;
            if (lista_zdjec.Count == 1)
            {
                lista_zdjec[0].WypelnijListeTagow();
                Wypelnij(lista_zdjec[0]);
            }
            else
            {
                Wypelnij_dla_kilku();
            }
            sciezka = s;
            opcja = 1;
        }

        /// <summary>
        /// Metoda wypełniająca formatke albumami ustawionymi dla zdjęcia
        /// </summary>
        /// <param name="zdjecie">zdjęcia dla którego wypełniamy formatke</param>
        private void Wypelnij(Zdjecie zdjecie)
        {            
            Db baza = new Db();
            baza.Polacz();
            try
            {                
                bool czy_znaleziony = false;                

                DataSet ds = baza.Select("select id_tagu, nazwa from Tag where album = 1");
                DataSet zczytanie_z_bazy_almumow;

                foreach (DataTable t in ds.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        if (!(r[0] is DBNull))
                        {                            
                            zczytanie_z_bazy_almumow = baza.Select("select id_tagu from TagZdjecia where id_zdjecia=" + zdjecie.Id + " and id_tagu in (select id_tagu from Tag where album=1)");

                            foreach (DataTable t2 in zczytanie_z_bazy_almumow.Tables)
                            {
                                foreach (DataRow r2 in t2.Rows)
                                {
                                    if (!(r2[0] is DBNull))
                                    {                                        
                                        if ((Int64)r2[0] == (Int64)r[0])
                                        {                                            
                                            this.checkedListBox1.Items.Add((string)r[1], true);
                                            czy_znaleziony = true;
                                            break;
                                        }
                                    }
                                }
                            }
                            
                            if (czy_znaleziony == false)
                            {
                                this.checkedListBox1.Items.Add((string)r[1], false);
                            }
                            czy_znaleziony = false;
                        }
                    }
                }
            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad bazy: " + ex.Message);
            }
            baza.Rozlacz();        
        }
        
        /// <summary>
        /// Metoda wypełniająca formatke dla kilku zdjęć nie jesteśmy w stanie w jednej formatce wyświetlić albumów dla każdego zdjęcia wiec wyświetla sie liste albumó lecz żaden z nich nie jest zaznaczony gdy użytkownik zaznaczy albumy zostana one dodane do każdego zdjęcia z listy zdjęć
        /// </summary>
        private void Wypelnij_dla_kilku()
        {
            Db baza = new Db();
            baza.Polacz();
            try
            {   
                DataSet ds = baza.Select("select id_tagu, nazwa from Tag where album = 1");

                foreach (DataTable t in ds.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        if (!(r[0] is DBNull))
                        {                            
                            this.checkedListBox1.Items.Add((string)r[1], false);                            
                        }
                    }
                }
            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad bazy: " + ex.Message);
            }
            baza.Rozlacz();            
        }

        /// <summary>
        /// Metoda dodająca albumy do zdjęć i dodająca odpowiednie wpisy do bazy
        /// </summary>
        /// <param name="list">lista zdjęć dla których metoda ma być wywołana</param>
        private void DodajDoAlbumu(List<Zdjecie> list)
        {
            Db baza = new Db();
            baza.Polacz();

            try
            {
                foreach (Zdjecie zdjecie in lista_zdjec)
                {
                    if (zdjecie.CzyUstawioneId() == true)
                    {                        
                        if (lista_zdjec.Count == 1)
                        {                            
                            baza.Delete("TagZdjecia", "id_zdjecia=" + zdjecie.Id + " and id_tagu in (select id_tagu from Tag where album = 1)");                         
                        }

                        foreach (string ob in this.checkedListBox1.CheckedItems)
                        {
                            DataSet ds = baza.Select("select id_tagu from Tag where nazwa=\'" + ob + "\' and album = 1");

                            foreach (DataTable t in ds.Tables)
                            {
                                foreach (DataRow r in t.Rows)
                                {
                                    if (!(r[0] is DBNull))
                                    {
                                        baza.Insert("TagZdjecia", zdjecie.Id + "," + r[0]);                                       
                                    }
                                }
                            }
                        }                       
                    }
                }
            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad sql " + ex.Message);
            }

            baza.Rozlacz();            
        }

        /// <summary>
        /// Metoda wywałana gdy użytkownik kliknie przycisk Zatwierdź. Uruchamia metody dodawania do albumu
        /// </summary>
        private void button1_Click(object sender, EventArgs e)
        {
            if (opcja == 1)
            {
                drzewo.d_d_a(sciezka);
                DodajDoAlbumu(lista_zdjec);
            }
            else if (opcja == 2)
            {
                przegladarka.dodaj_kolekcje_do_bazy(lista_zdjec);
                DodajDoAlbumu(lista_zdjec);
            }            
            
            this.Dispose();
        }
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    public partial class ListaAlbumowControl : UserControl, IWyszukiwacz
    {
        public ListaAlbumowControl()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            IZdjecie[] zdjecia = Wyszukaj().PodajWynik();
            if (ZakonczonoWyszukiwanie != null)
                ZakonczonoWyszukiwanie(zdjecia);
        }

        #region IWyszukiwacz Members

        public event ZakonczonoWyszukiwanieDelegate ZakonczonoWyszukiwanie;
        public event RozpoczetoWyszukiwanieDelegate RozpoczetoWyszukiwanie;
        public event ZnalezionoZdjecieDelegate ZnalezionoZdjecie;

        public IWyszukiwanie Wyszukaj()
        {
            Wyszukiwanie wynik = new Wyszukiwanie();
            if (listBox1.SelectedIndex == 0)
                wynik.And("..\\..\\img\\album1.bmp");
            if (listBox1.SelectedIndex == 1)
                wynik.And("..\\..\\img\\album2.bmp");
            if (listBox1.SelectedIndex == 2)
                wynik.And("..\\..\\img\\album3.bmp");
            return wynik;
        }

        #endregion
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Data.SQLite;
using System.Data.SqlClient;

namespace Photo.DialogBoxes
{
    public partial class Dodanie_tagow_do_zdjecia : Form
    {
        public Dodanie_tagow_do_zdjecia()
        {
            InitializeComponent();
        }


        private void Wypelnij()
        {
            Db baza = new Db();
            baza.Polacz();
            try
            {

            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad bazy");
            }

            baza.Rozlacz();
        }
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    /// <summary>
    /// Klasa opakowująca drzewo katalogow zawiera obiekty: Filetree i Button
    /// </summary>
    public partial class DrzewoOpakowane : UserControl
    {
        /// <summary>
        /// Konstruktor
        /// </summary>
        public DrzewoOpakowane()
        {
            InitializeComponent();
        }

        /// <summary>
        /// Metoda wykonywana po naciśnieciu klawisza odśwież Tworzy drzewo katalogów od nowa
        /// </summary>
        private void button1_Click_1(object sender, EventArgs e)
        {
            fileTree1.Delete();
            fileTree1.Fill();  
        }

        /// <summary>
        /// Metoda wyświetlająca zawartość katlogu
        /// </summary>
        /// <param name="k">katalog który ma być wyświetlony</param>
        public void ZaladujZawartoscKatalogu(Katalog k)
        {
            fileTree1.ZaladujZawartoscKatalogu(k);
        }

        /// <summary>
        /// Metoda do zmiany fokusa. Fokus po naciśnięciu kombinacji klawiszy Control+F przeskakuje do okna wyświetlającego miniaturki
        /// </summary>
        private void fileTree1_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.KeyData == (Keys.Control | Keys.F))
            {
                if (ZabierzFocus != null)
                    ZabierzFocus();
            }
        }

    }
}
<file_sep>﻿using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.Text;

namespace Photo
{
    public class Zdjecie : IZdjecie, IDisposable
    {
        Bitmap miniatura;
        string path;

        List<PolecenieOperacji> operacje = new List<PolecenieOperacji>();

        public Bitmap Miniatura
        {
            set
            {
                miniatura.Tag = this;
                miniatura = Miniatura;
            }
            get
            {
                return miniatura;
            }
        }

        public Zdjecie(string Path)
        {
            path = Path;
            miniatura = new Bitmap(path);
        }

        public string NazwaPliku
        {
            get
            {
                return path.Substring(path.LastIndexOf('\\') + 1);
            }
        }

        public string Path
        {
            get
            {
                return path;
            }
            set
            {
                this.path = value;
            }
        }

        #region Zdjecie Members

        public void DodajOperacje(PolecenieOperacji polecenie)
        {
            operacje.Add(polecenie);
        }

        public void WykonajOperacje()
        {
            if (operacje.Count > 0)
            {
                foreach (PolecenieOperacji polecenie in operacje)
                {
                    polecenie.Wykonaj(miniatura);
                }
                if (ZmodyfikowanoZdjecie != null)
                    ZmodyfikowanoZdjecie(null, this, RodzajModyfikacjiZdjecia.Zawartosc);
            }
        }

        public void UsunWszystkieOperacje()
        {
            operacje.Clear();
        }

        public Bitmap Duze
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public event ZmodyfikowanoZdjecieDelegate ZmodyfikowanoZdjecie;

        #endregion

        #region Meta

        public void SetIIPhotoProperty(string value)
        {
            System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
            PropertyItem propItem = miniatura.PropertyItems[0];
            propItem.Id = PropertyTags.IIPhotoTag;
            propItem.Type = 2;
            propItem.Value = encoding.GetBytes(value);
            propItem.Len = propItem.Value.Length;
            miniatura.SetPropertyItem(propItem);
        }

        public string GetProperty(int propID)
        {
            PropertyItem i;
            try
            {
                string val;
                i = miniatura.GetPropertyItem(propID);
                switch (i.Type)
                {
                    case 1: val = Encoding.Unicode.GetString(i.Value); break;
                    case 2: val = Encoding.ASCII.GetString(i.Value); break;
                    case 3: val = BitConverter.ToUInt16(i.Value, 0).ToString(); break;
                    default: val = "Value not supported"; break;
                }
                return val;
            }
            catch
            {
                return "";
            }
        }

        #endregion

        #region IDisposable Members

        public void Dispose()
        {
            this.miniatura.Dispose();
        }

        #endregion
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    public partial class InformacjeControl : UserControl
    {
        public InformacjeControl()
        {
            InitializeComponent();

            Tags.Columns.Add("Nazwa");
            Tags.Columns.Add("Wartość");
            Exif.Columns.Add("Nazwa");
            Exif.Columns.Add("Wartość");

            Tags.Items.Add(new ListViewItem(new string[] { "Brak informacji"}));
            Exif.Items.Add(new ListViewItem(new string[] { "Brak informacji" }));
        }

        public void Zaladuj(IZdjecie zdjecie)
        {
            if (zdjecie != null)
            {
                //MiniaturaControl mini = (MiniaturaControl)zdjecie;
                //listBox1.Items.Add(mini.ImageLocation);
            }
            else
            {
                //listBox1.Items.Add("null");
            }
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.Data;
using System.Text;
using System.Windows.Forms;

namespace Listview2
{
    public partial class ImageViewer : UserControl
    {
        public ImageViewer()
        {
            InitializeComponent();
        }
        public void SetThumbnailView()
        {
            thumbnailView1.Visible = true;
            imageView1.Visible = false;
        }
        public void SetImageView()
        {
            imageView1.Visible = true;
            thumbnailView1.Visible = false;
        }
        public ThumbnailView Thumbnailview
        {
            get
            {
                return thumbnailView1;
            }
        }
        public ImageView Imageview
        {
            get
            {
                return imageView1;
            }
        }

        public void Zoom(double zoom)
        {
            if (imageView1.Visible == true)
            {
                imageView1.Zoom(zoom);
            }
            else if (thumbnailView1.Visible == true)
            {
                thumbnailView1.ShowImages(zoom);
            }
        }

        public void Crop()
        {
            if (imageView1.Visible == true)
            {
                imageView1.Crop();
            }
        }

        public void toGrayScale()
        {
            if (imageView1.Visible == true)
            {
                imageView1.toGrayScale();
            }
        }

        private void mouseDoubleClick(object sender, MouseEventArgs e)
        {
            ListViewItem listViewItem = ((ThumbnailView)sender).FocusedItem;
            Bitmap b = (Bitmap)thumbnailView1.Images[listViewItem.ImageIndex];
            this.imageView1.setImage(new Bitmap(((ThumbnailTag)b.Tag).Path));
            this.SetImageView();
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Windows.Forms;
using System.Text;

namespace Photo
{
    //class Thre

    class PasekStanuControl : StatusStrip
    {
        private ToolStripStatusLabel Label = new ToolStripStatusLabel();

        public PasekStanuControl() :
            base()
        {
            this.Items.Add(Label);
        }

        public void RozpoczetoWyszukiwanie(IWyszukiwanie wyszukiwanie)
        {
            Label.Text = "Rozpoczęto : Wyszukiwanie.";
            this.Invalidate();
        }

        public void ZakonczonoWyszukiwanie(IZdjecie[] zdjecia)
        {
            Label.Text = "Zakończono : Wyszukiwanie.";
        }

        public void RozpoczetoAkcje(string Nazwa)
        {
            Label.Text = "Rozpoczęto : " + Nazwa + ".";
        }

        public void ZakonczonoAkcje(string Nazwa)
        {
            Label.Text = "Zakońcono : " + Nazwa + ".";
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.IO;
using System.Collections;
using System.Data.SQLite;
using System.Data.SqlClient;

namespace Photo
{
    /// <summary>
    /// Klasa implementująca UserControl i interfejs IWyszukiwacz służy do tworzenia, obsługi drzewa albumów i tagów
    /// </summary>
    public partial class ListaAlbumowControl : UserControl, IWyszukiwacz
    {
        private ContextMenuStrip Context;
        private TreeNode albumy, tagi;
        private bool czy_otwiera = false, czy_otwarte_albumy = false, zaznaczony = false;
        //Dictionary<int, string> slownik;
        public List<Int64> lista_tagow, lista_albumow;
        public List<string> lista_nazw_tagow, lista_nazw_albumow;
        private int ilosc_zaznaczonych_albumow, ilosc_zaznaczonych_tagow;
        //private bool czy_wszystkie_tagi_ustawione = false, czy_wszystkie_albumy_ustawione = false;
        //private string albumy = "";

        /// <summary>
        /// delegat ten informuje kontrolke wyświetlająca miniaturki że zostały zmiennione tagi żeby kontrolka wyświetlała tylko zdjęcia z odpowiednimi tagami
        /// </summary>        
        public event ZmieninoTagiDelegate ZmienionoTagi;
        /// <summary>
        /// delegat informuje pasek który wyświetla skąd sa wyświetlane zdjęcia
        /// </summary>
        public event ZmienionoZrodloDelegate ZmienionoZrodlo;

        private const int contacts = 0;
        private const int tag = 1;

        /// <summary>
        /// Konstruktor
        /// </summary>
        public ListaAlbumowControl()
        {
            InitializeComponent();
            Context = new ContextMenuStrip();

            lista_albumow = new List<Int64>();
            lista_tagow = new List<Int64>();
            lista_nazw_albumow = new List<string>();
            lista_nazw_tagow = new List<string>();
            ilosc_zaznaczonych_albumow = 0;
            ilosc_zaznaczonych_tagow = 0;

            ImageList list = new ImageList();
            list.Images.Add(Properties.Resources.Contacts1);
            list.Images.Add(Properties.Resources.tag);
            this.treeView1.ImageList = list;

            Wypelnij();
            

            tagi.Expand();
            albumy.Expand();
        }

        /// <summary>
        /// Metoda usuwająca wszystkie węzły drzewa
        /// </summary>
        private void Usun_wszystkie()
        {
            treeView1.BeginUpdate();
            treeView1.Nodes.Clear();
            treeView1.EndUpdate();
        }


        /// <summary>
        /// Metoda wypełniająca zawartość drzewa dane są pobierane z bazy
        /// </summary>
        private void Wypelnij()
        {
            Db baza = new Db();

            baza.Polacz();

            try
            {
                //baza.Insert_czesci("Tag", "nazwa,album", "\'miejsca\',1");

                TreeNode alb = new TreeNode("Albumy", contacts, contacts);
                TreeNode ta = new TreeNode("Tagi",tag,tag);
                albumy = alb;
                tagi = ta;

                //baza.Delete("Tag", "album=1");


                DataSet dataSet = baza.Select("select id_tagu,nazwa from Tag where album=1 order by nazwa asc;");

                foreach (DataTable t in dataSet.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        if (!(r[0] is DBNull))
                        {
                            alb.Nodes.Add(new TreeNode((string)r[1],contacts,contacts));
                            lista_albumow.Add((Int64)r[0]);
                            lista_nazw_albumow.Add((string)r[1]);
                        }                        
                    }
                }

                dataSet = baza.Select("select nazwa,id_tagu from Tag where album=0 order by nazwa asc;");
                
                foreach (DataTable t in dataSet.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        if (!(r[0] is DBNull))
                        {
                            ta.Nodes.Add(new TreeNode((string)r[0], tag, tag));
                            lista_tagow.Add((Int64)r[1]);
                            lista_nazw_tagow.Add((string)r[0]);                
                        }                           
                    }
                }                

                this.treeView1.Nodes.Add(alb);
                this.treeView1.Nodes.Add(ta);

            }
            catch (SqlException ex)
            {
                MessageBox.Show(ex.Message);
            }

            baza.Rozlacz();
        }


        /// <summary>
        /// Metoda od znajdowania numeru tagu gdy mamy do dyspozycji tylko nazwe
        /// </summary>
        /// <param name="nazwa">nazwa tagu</param>
        /// <returns>zwraca numer tagu o danej nazwie</returns>
        private Int64 znajdzNumer(string nazwa)
        {
            for (int i = 0; i < lista_nazw_tagow.Count; i++)
            {                
                if (lista_nazw_tagow[i] == nazwa)
                {             
                    return lista_tagow[i];
                }
            }
            return 0;
        }


        /// <summary>
        /// Metoda wykonywana gdy użytkownik kliknie na przycisk pokaż. Wtedy zostają wyszukane zdjęcia z zaznaczonych albumów
        /// i po uprzednim sprawdzeniu o tagi zdjęcia zostają wysłane do kontrolki wyświetlającej miniturki
        /// </summary>
        private void button1_Click(object sender, EventArgs e)
        {
            List<Zdjecie> zdjecia = null;
            List<Zdjecie> przefi = new List<Zdjecie>();

            if (ilosc_zaznaczonych_albumow != 0)
            {
                if (ilosc_zaznaczonych_tagow != 0)
                {
                    string sql = "";

                    foreach (TreeNode tr in tagi.Nodes)
                    {
                        if (tr.Checked == true)
                        {
                            sql += "and id_tagu=" + znajdzNumer(tr.Text) + " ";
                        }   
                    }

                    sql = sql.Substring(3, sql.Length - 3);
                                        
                    if (RozpoczetoWyszukiwanie != null)
                        RozpoczetoWyszukiwanie(null);

                    try
                    {
                        zdjecia = PokazPlikiZAlbumu(null, true);
                        
                        Db baza = new Db();
                        baza.Polacz();

                        string tag;                        

                        //MessageBox.Show("select * from TagZdjecia where id_zdjecia=" + "tag_zdjecia" + " and ( " + sql + " )");
                        int do_ilu = zdjecia.Count;

                        for (int i = 0; i < do_ilu; i++)
                        {
                            tag = zdjecia[i].Id;//zdjecia[i]..IIPhotoTag;

                            if (tag != "")
                            {
                                try
                                {
                                    DataSet ds = baza.Select("select max(id_zdjecia) from TagZdjecia where id_zdjecia = " + tag + " and (" + sql + ")");

                                    foreach (DataTable t in ds.Tables)
                                    {
                                        foreach (DataRow r in t.Rows)
                                        {
                                            if (!(r[0] is DBNull))
                                            {                                                
                                                przefi.Add(zdjecia[i]);
                                            }
                                        }
                                    }
                                }
                                catch (SqlException ex)
                                {
                                    MessageBox.Show("blad bazy: " + ex.Message);
                                }
                            }
                        }
                        baza.Rozlacz();

                    }
                    catch (UnauthorizedAccessException)
                    {
                        MessageBox.Show("Brak dostępu do wybranego katalogu.");
                        return;
                    }                   

                    if (ZakonczonoWyszukiwanie != null)
                        ZakonczonoWyszukiwanie(przefi.ToArray(), new Katalog[0], false);                    
                }
                else
                {
                    if (RozpoczetoWyszukiwanie != null)
                        RozpoczetoWyszukiwanie(null);

                    try
                    {
                        zdjecia = PokazPlikiZAlbumu(null, true);
                    }
                    catch (UnauthorizedAccessException)
                    {
                        MessageBox.Show("Brak dostępu do wybranego katalogu.");
                        return;
                    }

                    if (ZakonczonoWyszukiwanie != null)
                        ZakonczonoWyszukiwanie(zdjecia.ToArray(), new Katalog[0], false);                   
                }
            }            
        }
        

        #region IWyszukiwacz Members

        /// <summary>
        /// delegat informuję aplikacje ze wyszukiwanie zdjęć się zakończyło
        /// </summary>
        public event ZakonczonoWyszukiwanieDelegate ZakonczonoWyszukiwanie;

        /// <summary>
        /// delegat informuję aplikacje ze wyszukiwanie zdjęć się rozpoczeło
        /// </summary>
        public event RozpoczetoWyszukiwanieDelegate RozpoczetoWyszukiwanie;

        

        /// <summary>
        /// metoda służącza do składania zapytania sql i zwracająca Obiekt Wyszukania
        /// </summary>
        /// <returns>zwraca obiekt Wyszukanie</returns>
        public IWyszukiwanie Wyszukaj()
        {
           /* Wyszukiwanie wynik = new Wyszukiwanie();
            List<Zdjecie> lista = new List<Zdjecie>();
            //Zdjecie zd1 = new Zdjecie(
            lista.Add(new Zdjecie("c:\\IM000271.jpg"));
            lista.Add(new Zdjecie("c:\\IM000271t.jpg"));
                /*if (listBox1.SelectedIndex == 0)
                wynik.And("..\\..\\img\\album1.bmp");
            if (listBox1.SelectedIndex == 1)
                wynik.And("..\\..\\img\\album2.bmp");
            if (listBox1.SelectedIndex == 2)*/
             //   wynik.And("..\\..\\img\\album3.bmp");
               // return (IZdjecie[])lista.ToArray;
                //wynik;

            throw new Exception("The method or operation is not implemented.");
            
        }

        #endregion

        /// <summary>
        /// Metoda która zwraca zdjęcia należace do albumu który właśnie klikneliśmy
        /// </summary>
        /// <param name="Node">węzł drzewa z którego wyłusamy nazwe albumu</param>
        /// <returns>lista zdjęć która została utworzona przez przeszukanie bazy</returns>
        private List<Zdjecie> ZwrocZdjeciaZAlbumu(TreeNode Node)
        {
            Db baza = new Db();

            Dictionary<Int64, string> nieOdnalezione = new Dictionary<long,string>();
            //List<Int64> nieOdnalezione = new List<Int64>();
            List<Zdjecie> lista = new List<Zdjecie>();

            DataSet ds = null;
            string pelna_sciezka;

            baza.Polacz();

            try
            {
                if (Node.FullPath.IndexOf("Albumy") == 0 && Node.FullPath.Length > "Albumy".Length)
                {
                    ds = baza.Select("select sciezka,nazwa_pliku,id_zdjecia from zdjecie where id_zdjecia in (select id_zdjecia from TagZdjecia where id_tagu in (select id_tagu from Tag where album=1 and nazwa=\'" + Node.FullPath.Substring("Albumy".Length + 1, Node.FullPath.Length - ("Albumy".Length + 1)) + "\'))");
                }
                else if (Node.FullPath.IndexOf("Albumy") == 0)
                {
                    ds = baza.Select("select sciezka,nazwa_pliku,id_zdjecia from zdjecie where id_zdjecia in (select id_zdjecia from TagZdjecia where id_tagu in (select id_tagu from Tag where album=1))");
                }
                pelna_sciezka = "";

                foreach (DataTable t in ds.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        if (!(r[0] is DBNull))
                        {
                            pelna_sciezka = r[0] + "\\" + r[1];

                            if (System.IO.File.Exists(pelna_sciezka) == true)
                            {
                                Zdjecie z = new Zdjecie(pelna_sciezka);
                                lista.Add(z);
                            }
                            else
                            {
                                nieOdnalezione.Add((Int64)r[2], pelna_sciezka);                                
                            }
                        }
                    }
                }
            }
            catch (SqlException)
            {
                MessageBox.Show("blad bazy");
            }

            baza.Rozlacz();

            if (nieOdnalezione.Count > 0)
            {
                Dictionary<long, string>.Enumerator enu = nieOdnalezione.GetEnumerator();
                KeyValuePair<long, string> kv;
                enu.MoveNext();
                while (true)
                {
                    kv = enu.Current;
                    ZnajdzPliki zp = new ZnajdzPliki(kv);
                    DialogResult dr = zp.ShowDialog();
                    if (dr == DialogResult.OK)
                    {
                        if (zp.czyOdnaleziono())
                        {
                            Zdjecie odnalezioneZdjecie = new Zdjecie(zp.OdnalezionyPlik);
                            odnalezioneZdjecie.ZweryfikujZdjecie();
                            lista.Add(odnalezioneZdjecie);
                            if (!enu.MoveNext())
                                break;
                        }
                    }
                    else if (dr == DialogResult.Cancel)
                    {
                        if (!enu.MoveNext())
                            break;
                    }
                    else if (dr == DialogResult.Abort)
                    {
                        break;
                    }
                }
            }

            return lista;
        }

        /// <summary>
        /// Metoda zwraca liste zdjęć które należy wyświetlić w kontrolce miniatur
        /// </summary>
        /// <param name="czy_kilka">czy_kilka jak true to kilka albumów sie zwraca</param>
        /// <param name="Node">dla jakiego węzła ma być wykonane przeszukanie bazy</param>
        /// <returns>lista zdjęć które mają być wyświetlone</returns>
        private List<Zdjecie> PokazPlikiZAlbumu(TreeNode Node, bool czy_kilka) 
        {
            string albumy_string = "";

            if (czy_kilka == false)
            {
                if (Node.FullPath != "Albumy")
                {
                    if (ZmienionoZrodlo != null)
                        ZmienionoZrodlo("Album: " + Node.FullPath.Substring("Albumy".Length + 1, Node.FullPath.Length - ("Albumy".Length + 1)));
                }
                else
                {
                    albumy_string = "Albumy: ";

                    foreach (TreeNode tr in albumy.Nodes)
                    {
                        albumy_string += tr.FullPath.Substring("Albumy".Length + 1, tr.FullPath.Length - ("Albumy".Length + 1)) + ", ";
                    }

                    if (ZmienionoZrodlo != null)
                        ZmienionoZrodlo(albumy_string.Substring(0, albumy_string.Length - 2));
                }
                 
                return ZwrocZdjeciaZAlbumu(Node);
            }
            else
            {
                List<Zdjecie> lista_zdjec = new List<Zdjecie>();

                albumy_string = "Albumy: ";

                foreach (TreeNode tr in albumy.Nodes)
                {
                    if (tr.Checked == true)
                    {
                        albumy_string += tr.FullPath.Substring("Albumy".Length + 1, tr.FullPath.Length - ("Albumy".Length + 1)) + ", ";
                        lista_zdjec.AddRange(ZwrocZdjeciaZAlbumu(tr));//MessageBox.Show("dlugosc: " + lista_zdjec.Count);                        
                    }
                }

                if (ZmienionoZrodlo != null)
                    ZmienionoZrodlo(albumy_string.Substring(0, albumy_string.Length - 2));

                return lista_zdjec;
            }
        }

        /// <summary>
        /// Metoda która odświeża zawartość drzewa po dodaniu/usunięciu albumu/tagu
        /// </summary>
        public void odswiez()
        {
            bool al = false, t = false;
            
            if (albumy.IsExpanded == true)
            {                
                al = true;
            }
            if (tagi.IsExpanded == true)
            {
                tagi.Expand();
                t = true;
            }

            Usun_wszystkie();
            Wypelnij();

            if (al)
            {
                albumy.Expand();
            }
            if (t)
            {
                tagi.Expand();
            }
        }

        /// <summary>
        /// Metoda wywołująca formularz dodawania albumu
        /// </summary>
        private void DodajAlbum(object sender, EventArgs e)
        {
            ToolStripItem mn = (ToolStripItem)sender;
            
            Dodaj_Album da = new Dodaj_Album(this);
            da.Show();            
        }

        /// <summary>
        /// Metoda usuwająca album z drzewa i z bazy
        /// </summary>
        private void UsunAlbum(object sender, EventArgs e)
        {
            ToolStripItem mn = (ToolStripItem)sender;          

            Db baza = new Db();

            baza.Polacz();

            try
            {
                baza.Delete("Tag", "nazwa=\'" + mn.ToolTipText + "\' and album=1");
                for (int i = 0; i < lista_nazw_albumow.Count; i++)
                {
                    if (lista_nazw_albumow[i] == mn.ToolTipText)
                    {
                        baza.Delete("TagZdjecia", "id_tagu=" + lista_albumow[i]);
                        lista_nazw_albumow.RemoveAt(i);
                        lista_albumow.RemoveAt(i);
                    }
                }
            }
            catch (SqlException ex)
            {
                MessageBox.Show(ex.ToString() + ex.Message);
            }
            baza.Rozlacz();

            odswiez();
        }

        /// <summary>
        /// Metoda usuwająca zawartość albumu czyli usuwa wszystkie wpisy w bazie na temat zdjęć należących do tego albumu
        /// </summary>
        private void UsunZawartoscAlbumu(object sender, EventArgs e)
        {
            ToolStripItem mn = (ToolStripItem)sender;
            Int64 id_tagu = -1;
            Db baza = new Db();

            baza.Polacz();

            try
            {
                
                DataSet dataSet = baza.Select("select id_tagu from Tag where album=1 and nazwa=\'" + mn.ToolTipText + "\';");
                
                foreach (DataTable t in dataSet.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        id_tagu = (Int64)r[0];
                    }
                }                

                baza.Delete("TagZdjecia", "id_tagu=" + id_tagu);
            }
            catch (SqlException ex)
            {
                MessageBox.Show(ex.ToString() + ex.Message);
            }
            baza.Rozlacz();

            odswiez();
        }

        /// <summary>
        /// Metoda wywołująca formularz dodawania tagu
        /// </summary>
        private void DodajTag(object sender, EventArgs e)
        {
            ToolStripItem mn = (ToolStripItem)sender;            

            Dodaj_Tag dt = new Dodaj_Tag(this);
            dt.Show();
        }

        /// <summary>
        /// Metoda usuwająca tag z bazy i z drzewa
        /// </summary>
        private void UsunTag(object sender, EventArgs e)
        {
            ToolStripItem mn = (ToolStripItem)sender;            

            Db baza = new Db();

            baza.Polacz();

            try
            {
                baza.Delete("Tag", "nazwa=\'" + mn.ToolTipText + "\' and album=0");
                for (int i = 0; i < lista_nazw_tagow.Count; i++)
                {
                    if (lista_nazw_tagow[i] == mn.ToolTipText)
                    {
                        baza.Delete("TagZdjecia", "id_tagu=" + lista_tagow[i]);
                        lista_nazw_tagow.RemoveAt(i);
                        lista_tagow.RemoveAt(i);
                    }
                }
            }
            catch (SqlException ex)
            {
                MessageBox.Show(ex.ToString() + ex.Message);
            }
            baza.Rozlacz();

            odswiez();
        }

        /// <summary>
        /// Metoda która ze względu na przyciśnięty przycisk myszki:
        /// jeżeli lewy to za pomocą delegatów informuje kontrolke wyświetlającą o obiektach jakie mają być w danej chwili wyświetlone
        /// jeżeli prawy to tworzy sie menu kontekstowe
        /// </summary>        
        private void treeView1_NodeMouseClick(object sender, TreeNodeMouseClickEventArgs e)
        {
           //MessageBox.Show("wchodzi");

            if (czy_otwarte_albumy == false)
            {
                if (albumy.IsExpanded == true)
                {
                    czy_otwiera = true;
                    czy_otwarte_albumy = true;
                }
                else
                {
                    czy_otwiera = false;
                }
            }
            else
            {
                if (albumy.IsExpanded == false)
                {
                    czy_otwiera = true;
                    czy_otwarte_albumy = false;
                }
                else
                {
                    czy_otwiera = false;
                }
            }

            if(zaznaczony == true)
                czy_otwiera = true;


            if (e.Button == MouseButtons.Right)
            {
                if (e.Node.FullPath.IndexOf("Albumy") == 0)
                {

                    Context.Items.Clear();                    
                    
                    ToolStripItem toolStripItem = Context.Items.Add("Dodaj Album",Properties.Resources.Contacts_d);
                    toolStripItem.Click += new EventHandler(DodajAlbum);
                    toolStripItem = Context.Items.Add("Usun Zawartość Albumu",Properties.Resources.Recycle_Bin_Full_d);
                    toolStripItem.ToolTipText = e.Node.Text;
                    toolStripItem.Click += new EventHandler(UsunZawartoscAlbumu);
                    toolStripItem = Context.Items.Add("Usun Album",Properties.Resources.Recycle_Bin_Empty_d);
                    toolStripItem.ToolTipText = e.Node.Text;
                    toolStripItem.Click += new EventHandler(UsunAlbum);
                   
                    Context.Show(this, new Point(e.X, e.Y));
                }
                else
                {
                    Context.Items.Clear();
                    ToolStripItem toolStripItem = Context.Items.Add("Dodaj Tag",Properties.Resources.tag);
                    toolStripItem.Click += new EventHandler(DodajTag);
                    toolStripItem = Context.Items.Add("Usun Tag", Properties.Resources.Recycle_Bin_Empty_d);
                    toolStripItem.ToolTipText = e.Node.Text;                    
                    toolStripItem.Click += new EventHandler(UsunTag);

                    Context.Show(this, new Point(e.X, e.Y));
                }
            }
            else if (e.Button == MouseButtons.Left && czy_otwiera == false)
            {                
                if (e.Node.FullPath.IndexOf("Albumy") == 0)
                {

                    this.treeView1.SelectedNode = e.Node;
                    //this.treeView1.Select(true, true);

                    List<Zdjecie> zdjecia = null;

                    if (RozpoczetoWyszukiwanie != null)
                        RozpoczetoWyszukiwanie(null);

                    try
                    {
                        zdjecia = PokazPlikiZAlbumu(e.Node,false);
                    }
                    catch (UnauthorizedAccessException)
                    {
                        MessageBox.Show("Brak dostępu do wybranego katalogu.");
                        return;
                    }

                    if (ZakonczonoWyszukiwanie != null)
                        ZakonczonoWyszukiwanie(zdjecia.ToArray(), new Katalog[0], false);
                    czy_otwiera = true;
                }
            }

            zaznaczony = false;
        }

        /// <summary>
        /// Metoda która zostaje wywołana po zaznaczeniu checkboxa jeżeli zaznaczony był checkbox obok tagu automatycznie jest informowana kontrolka wyświetlająca miniaturki o liście zaznaczonych tagów
        /// </summary>
        private void treeView1_AfterCheck(object sender, TreeViewEventArgs e)
        {            
            int czy_al_zaz = 0, czy_ta_zaz = 0;

            if (e.Node.FullPath == "Albumy")// && czy_wszystkie_albumy_ustawione == false)
            {
                if (e.Node.Checked == true)
                {
                    czy_al_zaz = 1;
                    foreach (TreeNode t in e.Node.Nodes)
                    {
                        t.Checked = true;
                        ilosc_zaznaczonych_albumow = lista_albumow.Count;
                    }
                }
                else
                {
                    czy_al_zaz = 2;
                    foreach (TreeNode t in e.Node.Nodes)
                    {
                        t.Checked = false;
                        ilosc_zaznaczonych_albumow = 0;
                    }
                }
            }

            if (e.Node.FullPath == "Tagi")// && czy_wszystkie_tagi_ustawione == false)
            {
                if (e.Node.Checked == true)
                {
                    czy_ta_zaz = 1;
                    foreach (TreeNode t in e.Node.Nodes)
                    {
                        t.Checked = true;
                        ilosc_zaznaczonych_tagow = lista_tagow.Count;
                    }
                }
                else
                {
                    czy_ta_zaz = 2;
                    foreach (TreeNode t in e.Node.Nodes)
                    {
                        t.Checked = false;
                        ilosc_zaznaczonych_tagow = 0;
                    }
                }
            }

            if (czy_al_zaz == 0)
            {
                if (e.Node.FullPath.IndexOf("Albumy") == 0 && e.Node.FullPath.Length != "Albumy".Length)
                {
                    if (e.Node.Checked == true)
                    {
                        ilosc_zaznaczonych_albumow += 1;
                    }
                    else
                    {
                        ilosc_zaznaczonych_albumow -= 1;
                    }
                }
            }
            /*else if (e.Node.FullPath == "Tagi")
            {
                if (e.Node.Checked == true)
                {
                    ilosc_zaznaczonych_tagow = 0;
                }
                else
                {
                    ilosc_zaznaczonych_tagow = lista_tagow.Count;
                }

            }*/
            if (czy_ta_zaz == 0)
            {
                if (e.Node.FullPath.IndexOf("Tagi") == 0 && e.Node.FullPath.Length != "Tagi".Length)
                {
                    if (e.Node.Checked == true)
                    {
                        ilosc_zaznaczonych_tagow += 1;
                    }
                    else
                    {
                        ilosc_zaznaczonych_tagow -= 1;
                    }
                }
            }


            if (e.Node.FullPath.IndexOf("Tagi") == 0)
            {
                List<Int64> lista_tagow_do_przekazania = new List<Int64>();              

                foreach (TreeNode t in tagi.Nodes)
                {
                    if (t.Checked == true)
                    {                
                        lista_tagow_do_przekazania.Add(znajdzNumer(t.Text));
                    } 
                }

                if (ZmienionoTagi != null)
                    ZmienionoTagi(lista_tagow_do_przekazania);                
            }

            /*if (ilosc_zaznaczonych_tagow == 0 && czy_wszystkie_tagi_ustawione == true)
            {
                tagi.Checked = false;
                czy_wszystkie_tagi_ustawione = false;
                MessageBox.Show("1");
            }
            if (ilosc_zaznaczonych_tagow == tagi.Nodes.Count && czy_wszystkie_tagi_ustawione == false)
            {
                tagi.Checked = true;
                czy_wszystkie_tagi_ustawione = true;
                MessageBox.Show("2");
            }

            if (ilosc_zaznaczonych_albumow == 0 && czy_wszystkie_albumy_ustawione == true)
            {
                albumy.Checked = false;
                czy_wszystkie_albumy_ustawione = false;
                MessageBox.Show("3");
            }
            if (ilosc_zaznaczonych_albumow == albumy.Nodes.Count && czy_wszystkie_albumy_ustawione == false)
            {
                albumy.Checked = true;
                czy_wszystkie_albumy_ustawione = true;
                MessageBox.Show("4");
            }*/           
        }

        /// <summary>
        /// Metoda która zostaje wywołana przed zaznaczeniu checkboxa
        /// </summary>
        private void treeView1_BeforeCheck(object sender, TreeViewCancelEventArgs e)
        {
            zaznaczony = true;
        }        
    }
}
<file_sep>﻿using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.Text;

namespace Photo
{
    public class Zdjecie : IZdjecie, IDisposable
    {
        Bitmap miniatura;
        string path;
        int Orientation;
        string format;

        List<PolecenieOperacji> operacje = new List<PolecenieOperacji>();

        public Bitmap Miniatura
        {
            set
            {
                miniatura.Tag = this;
                miniatura = Miniatura;
            }
            get
            {
                return miniatura;
            }
        }

        public Bitmap Duze
        {
            get
            {
                return miniatura;
            }
        }

        public Zdjecie(string Path)
        {
            path = Path;
            miniatura = new Bitmap(path);
            format = sprawdzFormatPliku();
            UseOrientationTag();
        }

        public string NazwaPliku
        {
            get
            {
                return path.Substring(path.LastIndexOf('\\') + 1);
            }
        }

        public string Path
        {
            get
            {
                return path;
            }
            set
            {
                this.path = value;
            }
        }

        public string sprawdzFormatPliku()
        {
            if (this.Duze.RawFormat.Equals(ImageFormat.Jpeg))
                return "Jpeg";
            else if (this.Duze.RawFormat.Equals(ImageFormat.Tiff))
                return "Tiff";
            else
                return "";
        }

        public string FormatPliku
        {
            get
            {
                return format;
            }
        }

        #region Zdjecie Members

        public void DodajOperacje(PolecenieOperacji polecenie)
        {
            operacje.Add(polecenie);
        }

        public void WykonajOperacje()
        {
            if (operacje.Count > 0)
            {
                foreach (PolecenieOperacji polecenie in operacje)
                {
                    polecenie.Wykonaj(miniatura);
                }
                if (ZmodyfikowanoZdjecie != null)
                    ZmodyfikowanoZdjecie(null, this, RodzajModyfikacjiZdjecia.Zawartosc);
            }
        }

        public void UsunWszystkieOperacje()
        {
            operacje.Clear();
        }

        public event ZmodyfikowanoZdjecieDelegate ZmodyfikowanoZdjecie;

        #endregion

        #region Meta

        public void SetIIPhotoProperty(string value)
        {
            System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
            PropertyItem propItem = miniatura.PropertyItems[0];
            propItem.Id = PropertyTags.IIPhotoTag;
            propItem.Type = 2;
            propItem.Value = encoding.GetBytes(value);
            propItem.Len = propItem.Value.Length;
            miniatura.SetPropertyItem(propItem);
        }

        public string GetProperty(int propID)
        {
            PropertyItem i;
            string val;
              
            foreach(int id in miniatura.PropertyIdList)
            {
                if (id == propID)
                {
                    i = miniatura.GetPropertyItem(propID);
                    switch (i.Type)
                    {
                        case 1: val = Encoding.Unicode.GetString(i.Value); break;
                        case 2: val = Encoding.ASCII.GetString(i.Value); break;
                        case 3: val = BitConverter.ToUInt16(i.Value, 0).ToString(); break;
                        default: val = "Value not supported"; break;
                    }
                    return PropertyTags.ParseProp(propID, val);
                }
            }
            return "";
        }

        public void UseOrientationTag()
        {
            foreach (int id in miniatura.PropertyIdList)
            {
                if (id == PropertyTags.Orientation)
                {
                    Orientation = BitConverter.ToUInt16(miniatura.GetPropertyItem(id).Value, 0);
                    switch (Orientation)
                    {
                        case 2:
                            this.Miniatura.RotateFlip(RotateFlipType.RotateNoneFlipY);
                            break;
                        case 3:
                            this.Miniatura.RotateFlip(RotateFlipType.Rotate180FlipNone);
                            break;
                        case 4:
                            this.Miniatura.RotateFlip(RotateFlipType.RotateNoneFlipX);
                            break;
                        case 5:
                            this.Miniatura.RotateFlip(RotateFlipType.Rotate90FlipY);
                            break;
                        case 6:
                            this.Miniatura.RotateFlip(RotateFlipType.Rotate90FlipNone);
                            break;
                        case 7:
                            this.Miniatura.RotateFlip(RotateFlipType.Rotate270FlipY);
                            break;
                        case 8:
                            this.Miniatura.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            break;
                    }
                }
            }
        }

        #endregion

        #region IDisposable Members

        public void Dispose()
        {
            this.miniatura.Dispose();
        }

        #endregion
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Text;
using System.Data.SQLite;
using System.Data;
using System.Data.Common;
using System.Data.SqlClient;

namespace Photo
{
    class Db
    {
        private string DBfile;
        private SQLiteConnection conn;

        public Db(string path)
        {
            DBfile = path;
        }

        public void StworzBD()
        {
            if (System.IO.File.Exists(DBfile) == false)
            {
                SQLiteConnection.CreateFile(DBfile);
            }
        }

        public void Polacz()
        {
            this.StworzBD();
            this.conn = new SQLiteConnection("Data Source=" + DBfile + ";Version=3;");
            conn.Open();
        }

        public void Rozlacz()
        {
            conn.Close();
        }

        public void SzybkieInserty(string tableName, string parameters, string[,] fields)
        {
            using (SQLiteTransaction dbTrans = conn.BeginTransaction())
            {
                using (SQLiteCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = "insert into " + tableName + " values(" + parameters + ");";

                    SQLiteParameter[] sqlparams = new SQLiteParameter[fields.GetLength(1)];

                    for (int i = 0; i < fields.GetLength(1); i++)
                    {
                        sqlparams[i] = cmd.CreateParameter();
                        cmd.Parameters.Add(sqlparams[i]);
                    }

                    for (int i = 0; i < fields.GetLength(0); i++)
                    {
                        for (int j = 0; j < fields.GetLength(1); j++)
                        {
                            sqlparams[j].Value = fields[i, j];
                        }
                        cmd.ExecuteNonQuery();
                    }
                    dbTrans.Commit();
                }
            }
        }

        public SQLiteDataAdapter PobierzAdapter(string query, bool forEdit)
        {
            SQLiteDataAdapter sqladapt = new SQLiteDataAdapter(query, conn);
            DataSet dataSet = new DataSet("Dane");
            if (forEdit)
            {
                new SQLiteCommandBuilder(sqladapt);
            }
            return sqladapt;
        }

        public DataSet PobierzDane(SQLiteDataAdapter ad)
        {
            DataSet dataSet = new DataSet("Dane");
            ad.Fill(dataSet);
            return dataSet;
        }

        public DataSet Select(string select)
        {
            SQLiteDataAdapter sqladapt = new SQLiteDataAdapter(select, conn);
            DataSet dataSet = new DataSet("Dane");
            sqladapt.Fill(dataSet);
            return dataSet;
        }

        public void WykonajQuery(string query)
        {
            SQLiteCommand cmd = conn.CreateCommand();
            cmd.CommandText = query;
            cmd.ExecuteNonQuery();
        }
    }
}
<file_sep>using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Windows.Forms;
using System.Collections.Generic;
using System.DirectoryServices;
using System.Reflection;

namespace Photo
{
    /// <summary>
    /// Klasa opisująca polecenie operacji graficznej.
    /// </summary>
    public class PolecenieOperacji
    {
        /// <summary>
        /// Obiekt klasy IOperacja, która zostanie użyta do wykonania operacji.
        /// </summary>
        private IOperacja Operacja;
        /// <summary>
        /// Stos argumentów dla wykonania operacji z pola Operacja.
        /// </summary>
        private Stack<object> Argumenty = new Stack<object>();

        /// <summary>
        /// </summary>
        /// <param name="Operacja">Operacja jaka ma być wykonana.</param>
        /// <param name="Argumenty">Lista argumentów dla operacji.</param>
        public PolecenieOperacji(IOperacja Operacja, object[] Argumenty)
        {
            this.Operacja = Operacja;
            foreach (object arg in Argumenty)
            {
                this.Argumenty.Push(arg);
            }
        }

        /// <summary>
        /// Powoduje wykonanie operacji opisanej przez to polecenie na bitmapie.
        /// </summary>
        /// <param name="z">Bitmapa na której wykonywana jest operacja.</param>
        public void Wykonaj(Zdjecie z)
        {
            Operacja.Wykonaj(z, Argumenty);
        }
    }

    /// <summary>
    /// Delegat zazadania peracji
    /// </summary>
    /// <param name="polecenie">Polecenie operacji, o ktora zazadano</param>
    public delegate void ZazadanieOperacjiDelegate(PolecenieOperacji polecenie);

    /// <summary>
    /// Klasa wykonujaca czynnosci inicjalizujace Operacje
    /// </summary>
    class Operacje
    {
        private List<IOperacja> operacje = new List<IOperacja>();
        public event ZazadanieOperacjiDelegate ZazadanieOperacji;

        /// <summary>
        /// Metoda wczytujaca dynamicznie pluginy z Operacjami
        /// </summary>
        public void WczytajPluginy()
        {
            if (!System.IO.Directory.Exists(Config.katalogPluginow))
                return;
            string[] pluginy = System.IO.Directory.GetFiles(Config.katalogPluginow, "*.dll");
            foreach (string plugin in pluginy)
            {
                Assembly asm = Assembly.LoadFile(plugin);
                foreach (Type type in asm.GetTypes())
                {
                    ConstructorInfo ci = type.GetConstructor(new Type[] { });
                    if (ci != null)
                    {
                        object obj = ci.Invoke(new object[] { });
                        if (obj is IOperacja)
                            operacje.Add((IOperacja)obj);
                    }
                }
            }
        }

        /// <summary>
        /// Metoda wczytujaca wbudowane Operacje
        /// </summary>
        public void WczytajWbudowane()
        {
            operacje.Add(new XOR());
            operacje.Add(new Grayscale());
            operacje.Add(new Crop());
            operacje.Add(new Rotate(2));
            operacje.Add(new Rotate(1));
            operacje.Add(new Rotate(3));
        }

        /// <summary>
        /// Metoda dodajaca wczytane operacje do interfejsu graficznego
        /// </summary>
        /// <param name="tool">ToolStip na ktory ma zostac dodana operacja</param>
        /// <param name="filtry">ToolStripMenuItem na ktory ma zostac dodana operacja</param>
        public void WrzucDoGui(ToolStrip tool, ToolStripMenuItem filtry)
        {
            foreach (IOperacja operacja in operacje)
            {
                if (operacja.CzyNaToolbar() == true)
                {
                    ToolStripButton button = new ToolStripButton(operacja.NazwaOperacji, operacja.Ikona);
                    button.Tag = operacja;
                    button.Click += new EventHandler(button_Click);
                    tool.Items.Add(button);
                }
                else
                {
                    ToolStripMenuItem menuItem = new ToolStripMenuItem(operacja.NazwaOperacji, operacja.Ikona);
                    menuItem.Tag = operacja;
                    menuItem.Click += new EventHandler(button_Click);
                    filtry.DropDownItems.Add(menuItem);
                }
            }
        }

        void button_Click(object sender, EventArgs e)
        {
            ToolStripItem item = (ToolStripItem)sender;
            IOperacja operacja = (IOperacja)item.Tag;
            PolecenieOperacji polecenie = new PolecenieOperacji(operacja, operacja.PodajArgumenty().ToArray());
            ZazadanieOperacji(polecenie);
        }
    }

    /// <summary>
    /// Klasa wykonujaca odwrocenie kolorow zdjecia
    /// </summary>
    class XOR : IOperacja
    {
        private int kodOperacji;

        #region IOperacja Members

        public string NazwaOperacji
        {
            get { return "Negatyw"; }
        }

        int IOperacja.KodOperacji
        {
            get
            {
                return kodOperacji;
            }
            set
            {
                kodOperacji = value;
            }
        }

        public Image Ikona
        {
            get
            {
                return Properties.Resources.xor;
            }
        }

        public string Autor
        {
            get { throw new System.Exception("The method or operation is not implemented."); }
        }

        public string Wersja
        {
            get { throw new System.Exception("The method or operation is not implemented."); }
        }

        public string Kontakt
        {
            get { throw new System.Exception("The method or operation is not implemented."); }
        }

        public void Wykonaj(Zdjecie z, System.Collections.Generic.Stack<object> Argumenty)
        {
            if (z.Zaznaczenie.IsEmpty)
            {
                BitmapFilter.Invert(z.Duze);
            }
            else
            {
                if (z.Zaznaczenie.Width < 0)
                {
                    z.Zaznaczenie.X += z.Zaznaczenie.Width;
                    z.Zaznaczenie.Width *= -1;
                }
                if (z.Zaznaczenie.Height < 0)
                {
                    z.Zaznaczenie.Y += z.Zaznaczenie.Height;
                    z.Zaznaczenie.Height *= -1;
                }
                Bitmap xored = new Bitmap(Math.Abs(z.Zaznaczenie.Width), Math.Abs(z.Zaznaczenie.Height), z.Duze.PixelFormat);
                Graphics g = Graphics.FromImage(xored);
                g.DrawImage(z.Duze, new Rectangle(0, 0, xored.Width, xored.Height), z.Zaznaczenie, GraphicsUnit.Pixel);
                g.Dispose();
                BitmapFilter.Invert(xored);
                g = Graphics.FromImage(z.Duze);
                g.DrawImage(xored, z.Zaznaczenie);
                g.Dispose();
            }
        }

        public Stack<object> PodajArgumenty()
        {
            return new Stack<object>();
        }

        #endregion

        #region IOperacja Members


        public bool CzyNaToolbar()
        {
            return false;
        }

        #endregion
    }

    /// <summary>
    /// Klasa wykonujaca konwersje zdjecia do odcieni szarosci
    /// </summary>
    class Grayscale : IOperacja
    {
        #region IOperacja Members

        private int kodOperacji;

        public string NazwaOperacji
        {
            get { return "Skala szarości"; }
        }

        public int KodOperacji
        {
            get
            {
                return kodOperacji;
            }
            set
            {
                kodOperacji = value;
            }
        }

        public Image Ikona
        {
            get { return Properties.Resources.desaturate; }
        }

        public string Autor
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public string Wersja
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public string Kontakt
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public Stack<object> PodajArgumenty()
        {
            return new Stack<object>();
        }

        public void Wykonaj(Zdjecie z, Stack<object> Argumenty)
        {
            if (z.Zaznaczenie.IsEmpty)
            {
                BitmapFilter.GrayScale(z.Duze);
            }
            else
            {
                if (z.Zaznaczenie.Width < 0)
                {
                    z.Zaznaczenie.X += z.Zaznaczenie.Width;
                    z.Zaznaczenie.Width *= -1;
                }
                if (z.Zaznaczenie.Height < 0)
                {
                    z.Zaznaczenie.Y += z.Zaznaczenie.Height;
                    z.Zaznaczenie.Height *= -1;
                }
                Bitmap grayed = new Bitmap(Math.Abs(z.Zaznaczenie.Width), Math.Abs(z.Zaznaczenie.Height), z.Duze.PixelFormat);
                Graphics g = Graphics.FromImage(grayed);
                g.DrawImage(z.Duze, new Rectangle(0, 0, grayed.Width, grayed.Height), z.Zaznaczenie, GraphicsUnit.Pixel);
                g.Dispose();
                BitmapFilter.GrayScale(grayed);
                g = Graphics.FromImage(z.Duze);
                g.DrawImage(grayed, z.Zaznaczenie);
                g.Dispose();
            }
        }

        public bool CzyNaToolbar()
        {
            return false;
        }

        #endregion
    }

    /// <summary>
    /// Klasa wykonujaca obcinanie zdjecia do podanych rozmiarow
    /// </summary>
    class Crop : IOperacja
    {
        #region IOperacja Members

        private int kodOperacji;

        public string NazwaOperacji
        {
            get { return "Wytnij"; }
        }

        public int KodOperacji
        {
            get
            {
                return kodOperacji;
            }
            set
            {
                kodOperacji = value;
            }
        }

        public Image Ikona
        {
            get { return Properties.Resources.crop; }
        }

        public string Autor
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public string Wersja
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public string Kontakt
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public Stack<object> PodajArgumenty()
        {
            return new Stack<object>();
        }

        public void Wykonaj(Zdjecie z, Stack<object> Argumenty)
        {
            if (z.Zaznaczenie.Width != 0 && z.Zaznaczenie.Height != 0)
            {
                if (z.Zaznaczenie.Width < 0)
                {
                    z.Zaznaczenie.X += z.Zaznaczenie.Width;
                    z.Zaznaczenie.Width *= -1;
                }
                if (z.Zaznaczenie.Height < 0)
                {
                    z.Zaznaczenie.Y += z.Zaznaczenie.Height;
                    z.Zaznaczenie.Height *= -1;
                }
                Bitmap cropped = new Bitmap(Math.Abs(z.Zaznaczenie.Width), Math.Abs(z.Zaznaczenie.Height), z.Duze.PixelFormat);
                Graphics g = Graphics.FromImage(cropped);
                g.DrawImage(z.Duze, new Rectangle(0, 0, cropped.Width, cropped.Height), z.Zaznaczenie, GraphicsUnit.Pixel);
                g.Dispose();
                foreach (PropertyItem pi in z.Duze.PropertyItems)
                {
                    cropped.SetPropertyItem(pi);
                }
                z.Duze = cropped;
            }
        }

        public bool CzyNaToolbar()
        {
            return false;
        }

        #endregion
    }

    /// <summary>
    /// Klasa wykonujaca obroty zdjecia
    /// </summary>
    class Rotate : IOperacja
    {
        #region IOperacja Members

        private int kodOperacji;

        public Rotate(int k)
        {
            kodOperacji = k;
        }

        public string NazwaOperacji
        {
            get 
            {
                switch (KodOperacji)
                {
                    case 1: return "90° CW";
                    case 2: return "90° CCW";
                    case 3: return "180° CW";
                    default: return "";
                }
            }
        }

        public int KodOperacji
        {
            get
            {
                return kodOperacji;
            }
            set
            {
                kodOperacji = value;
            }
        }

        public Image Ikona
        {
            get
            {
                switch (KodOperacji)
                {
                    case 1: return Properties.Resources.rotate_90;
                    case 2: return Properties.Resources.rotate_270;
                    case 3: return Properties.Resources.rotate_180;
                    default: return null;
                }
            }
        }

        public string Autor
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public string Wersja
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public string Kontakt
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public Stack<object> PodajArgumenty()
        {
            return new Stack<object>();
        }

        public void Wykonaj(Zdjecie z, Stack<object> Argumenty)
        {
            switch (KodOperacji)
            {
                case 1:
                    z.Duze.RotateFlip(RotateFlipType.Rotate90FlipNone);
                    break;
                case 2:
                    z.Duze.RotateFlip(RotateFlipType.Rotate270FlipNone);
                    break;
                case 3:
                    z.Duze.RotateFlip(RotateFlipType.Rotate180FlipNone);
                    break;
            }
            z.Duze = Zdjecie.FromImage(z.Duze);
        }

        public bool CzyNaToolbar()
        {
            switch (KodOperacji)
            {
                case 1: return true;
                case 2: return true;
                case 3: return false;
            }
            return false;
        }

        #endregion
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing.Imaging;

/*
 * Pierwszy parametr to sciezka do zdjecia wejsciowego, 
 * Drugi to sciezka do zdjecia w ktorym bedzie zapisany nasz tag przykladowy + odczytane jakies dane z Exif'a
 */

namespace Properties
{
    class Program
    {
        static void Main(string[] args)
        {
            MyBitmap img = new MyBitmap(args[0]);
            Console.WriteLine("Tag na poczatku: {0}", img.GetProperty(PropertyTags.IIPhotoTag));
            img.SetIIPhotoProperty("testowyTag");
            img.Save(args[1], ImageFormat.Jpeg);
            img.Dispose();

            img = new MyBitmap(args[1]);
            Console.WriteLine("Tag po wpisaniu: {0}", img.GetProperty(PropertyTags.IIPhotoTag));
            Console.WriteLine("Exif: {0}", img.GetProperty(PropertyTags.EquipMake));
            Console.WriteLine("Exif: {0}", img.GetProperty(PropertyTags.EquipModel));
            Console.WriteLine("Exif: {0}", img.GetProperty(PropertyTags.Orientation));
            Console.WriteLine("Exif: {0}", img.GetProperty(PropertyTags.ExifFlash));
            img.Dispose();
            Console.ReadLine();
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Windows.Forms;

namespace Listview2
{
    public class ThumbnailView : System.Windows.Forms.ListView
    {
        private int defaultImageSize;
        private List<Bitmap> images;

        public ThumbnailView()
        {
            images = new List<Bitmap>();
            //Activate double buffering
            this.SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true);

            //Enable the OnNotifyMessage event so we get a chance to filter out 
            // Windows messages before they get to the form's WndProc
            this.SetStyle(ControlStyles.EnableNotifyMessage, true);
            this.defaultImageSize = 120;
        }
        public ThumbnailView(int imgSize)
            : this()
        {
            this.defaultImageSize = imgSize;
        }

        protected override void OnNotifyMessage(Message m)
        {
            //Filter out the WM_ERASEBKGND message
            if (m.Msg != 0x14)
            {
                base.OnNotifyMessage(m);
            }
        }

        public void AddImages(List<Bitmap> images) {
            this.images.AddRange(images);
        }

        public List<Bitmap> Images
        {
            get
            {
                return images;
            }
        }

        public void ShowImages(double zoom) {
            Bitmap b, newBitmap;
            Graphics MyGraphics;
            Rectangle MyRectan;
            ImageList newImageList = new ImageList();
            ListViewItem listViewItem;
            newImageList.ColorDepth = System.Windows.Forms.ColorDepth.Depth32Bit;
            newImageList.Tag = "100%";
            newImageList.TransparentColor = System.Drawing.Color.Transparent;
            newImageList.ImageSize = new Size((int)(zoom * this.defaultImageSize), (int)(zoom * this.defaultImageSize));

            int maxSize = newImageList.ImageSize.Width;
            int scaledH, scaledW, posX, posY;
            this.Items.Clear();
            for (int i = 0; i < images.Count; i++)
            {
                b = images[i];
                newBitmap = new Bitmap(maxSize, maxSize);
                MyGraphics = Graphics.FromImage(newBitmap);

                if (b.Height > b.Width)
                {
                    scaledH = maxSize;
                    scaledW = (int)Math.Round((double)(b.Width * scaledH) / b.Height);
                    posX = (maxSize - scaledW) / 2;
                    posY = 0;
                }
                else
                {
                    scaledW = maxSize;
                    scaledH = (int)Math.Round((double)(b.Height * scaledW) / b.Width);
                    posX = 0;
                    posY = (maxSize - scaledH) / 2;
                }

                MyRectan = new Rectangle(posX, posY, scaledW, scaledH);
                using (Pen p = new Pen(Brushes.LightGray))
                {
                    MyGraphics.DrawRectangle(p, 0, 0, maxSize - 1, maxSize - 1);
                }
                MyGraphics.DrawImage(b, MyRectan);
                newBitmap.Tag = new ThumbnailTag(((ThumbnailTag)b.Tag).Filename);
                newImageList.Images.Add(newBitmap);
                listViewItem = this.Items.Add(new ListViewItem(((ThumbnailTag)b.Tag).Filename));
                listViewItem.ImageIndex = i;
            }

            // Create an new ImageList for the ListView control
            this.LargeImageList = newImageList;

            // Update the ListView control
            this.Refresh();
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Text;
using System.Data;
using System.Data.Common;
using System.Data.SQLite;
using System.Data.SqlClient;

namespace ConsoleApplication1
{
    class MySqlite {
        private string DBfile;
        private SQLiteConnection conn;

        public MySqlite(string path) {
            DBfile = path;
        }

        public void createDB() {
            if (System.IO.File.Exists(DBfile) == false)
            {
                SQLiteConnection.CreateFile(DBfile);
            }
        }

        public void connect() {
            this.createDB();
            this.conn = new SQLiteConnection("Data Source="+DBfile+";Version=3;");
            conn.Open();
        }

        public void close() {
            conn.Close();
        }

        public void fastInserts(string tableName, string parameters, string[,] fields)
        {
            using (SQLiteTransaction dbTrans = conn.BeginTransaction())
            {
                using (SQLiteCommand cmd = conn.CreateCommand())
                {
                    cmd.CommandText = "insert into " + tableName + " values(" + parameters + ");";

                    SQLiteParameter[] sqlparams = new SQLiteParameter[fields.GetLength(1)];

                    for (int i = 0; i < fields.GetLength(1); i++) {
                        sqlparams[i] = cmd.CreateParameter();
                        cmd.Parameters.Add(sqlparams[i]);
                    }

                    for (int i = 0; i < fields.GetLength(0); i++)
                    {
                        for (int j = 0; j < fields.GetLength(1); j++)
                        {
                            sqlparams[j].Value = fields[i, j];
                        }
                        cmd.ExecuteNonQuery();
                    }
                    dbTrans.Commit();
                }
            }
        }

        public SQLiteDataAdapter getAdapter(string query, bool forEdit) {
            SQLiteDataAdapter sqladapt = new SQLiteDataAdapter(query, conn);
            DataSet dataSet = new DataSet("Dane");
            if (forEdit)
            {
                new SQLiteCommandBuilder(sqladapt);
            }
            return sqladapt;
        }

        public DataSet getData(SQLiteDataAdapter ad)
        {
            DataSet dataSet = new DataSet("Dane");
            ad.Fill(dataSet);
            return dataSet;
        }

        public DataSet select(string select)
        {
            SQLiteDataAdapter sqladapt = new SQLiteDataAdapter(select, conn);
            DataSet dataSet = new DataSet("Dane");
            sqladapt.Fill(dataSet);
            return dataSet;
        }

        public void executeQuery(string query)
        {
            SQLiteCommand cmd = conn.CreateCommand();
            cmd.CommandText = query;
            cmd.ExecuteNonQuery();
        }

    }

    class Program
    {
        static void Main(string[] args)
        {
            MySqlite db = new MySqlite("mydb.db3");
            db.connect();

            try
            {
                db.executeQuery("create table users(" +
                                "id integer primary key autoincrement," +
                                "username varchar(32)," +
                                "password varchar(128))");
            } catch (SQLiteException e) {
                Console.WriteLine("{0}", e.Message);
            }

            string[,] users = new string[50, 2];
            for (int n = 0; n < 50; n++) {
                users[n, 0] = "user_" + n.ToString();
                users[n, 1] = "pass_" + n.ToString();
            }

            db.fastInserts("users", "NULL, ?,?", users);

            DataSet dataSet = db.select("select * from users;");
            foreach (DataTable t in dataSet.Tables)
            {
                Console.WriteLine("Tabela {0} zawiera {1} wiersze", t.TableName, t.Rows.Count);
                foreach (DataRow r in t.Rows)
                {
                    Console.Write("-> ");
                    foreach (DataColumn c in t.Columns)
                        Console.Write("{0}={1}, ", c.ColumnName, r[c.ColumnName]);
                    Console.WriteLine();
                }
            }

            dataSet.Dispose();

            SQLiteDataAdapter da = db.getAdapter("select * from users;", true);
            DataSet ds = db.getData(da);

            DataRow[] drows = ds.Tables[0].Select("username = 'user_30'");
            for (int i = 0; i < drows.Length; i++)
            {
                drows[i].BeginEdit();
                drows[i]["password"] = "<PASSWORD>!";
                drows[i].EndEdit();
            }
            Console.WriteLine("zmodyfikowano: {0} wierszy", da.Update(ds));
            ds.Dispose();
            da.Dispose();

            dataSet = db.select("select * from users;");
            foreach (DataTable t in dataSet.Tables)
            {
                Console.WriteLine("Tabela {0} zawiera {1} wiersze", t.TableName, t.Rows.Count);
                foreach (DataRow r in t.Rows)
                {
                    Console.Write("-> ");
                    foreach (DataColumn c in t.Columns)
                        Console.Write("{0}={1}, ", c.ColumnName, r[c.ColumnName]);
                    Console.WriteLine();
                }
            }

            db.close();
            Console.ReadLine();
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            imageViewer1.SetThumbnailView();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            imageViewer1.SetThumbnailView();
            List<Miniatura> images = new List<Miniatura>();
            Miniatura tempMini;

            for (int i = 1; i < 11; i++)
            {
                tempMini = new Miniatura(@"img\\small_img" + i.ToString() + ".jpg");
                tempMini.tag = new MiniaturaTag(@"img\\img" + i.ToString() + ".jpg");
                images.Add(tempMini);
            }
            imageViewer1.Thumbnailview.AddImages(images);
            imageViewer1.Thumbnailview.ShowImages(1.0);
            
        }

        /*private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            switch (comboBox1.SelectedItem.ToString())
            {
                case "50%": imageViewer1.Zoom(0.5); break;
                case "75%": imageViewer1.Zoom(0.75); break;
                case "100%": imageViewer1.Zoom(1.0); break;
                case "150%": imageViewer1.Zoom(1.5); break;
                default: break;
            }
        }*/

        private void button2_Click(object sender, EventArgs e)
        {
            imageViewer1.SetThumbnailView();
        }

        /*private void button3_Click(object sender, EventArgs e)
        {
            imageViewer1.Crop();
        }

        private void button4_Click(object sender, EventArgs e)
        {
            imageViewer1.toGrayScale();
        }*/
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.Data;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    /// <summary>
    /// Kontrolka wyswietlajaca informacje o zdjeciach.
    /// </summary>
    public partial class InformacjeControl : UserControl
    {
        /// <summary>
        /// Konstruktow ustawia wyglad kontrolki.
        /// </summary>
        public InformacjeControl()
        {
            InitializeComponent();

            Tags.Columns.Add("Nazwa");
            Tags.Columns.Add("Wartość");
            Exif.Columns.Add("Nazwa");
            Exif.Columns.Add("Wartość");
            Tags.Columns[0].Width = 65;
            Exif.Columns[0].Width = 70;
            Tags.Columns[1].Width = 100;
            Exif.Columns[1].Width = 95;
        }

        /// <summary>
        /// Metoda pobierajaca zdjecie i przekazujaca je do wyswietlenia
        /// </summary>
        /// <param name="zdjecie">Zdjecie ktorego informacje maja zostac wyswietlone</param>
        public void Zaladuj(Zdjecie zdjecie)
        {
            this.zdjecie = zdjecie;
            Wyswietl();
        }

        /// <summary>
        /// Metoda wypelniajaca kontrolke informacjami o zdjeciu
        /// </summary>
        private void Wyswietl()
        {
            Tags.Items.Clear();
            Exif.Items.Clear();
            if (zdjecie != null)
            {
                fillTags();
                fillExif();
            }
            else
            {
                Tags.Items.Add(new ListViewItem(new string[] { "Brak", "informacji" }));
                Exif.Items.Add(new ListViewItem(new string[] { "Brak", "informacji" }));
            }
        }

        /// <summary>
        /// Metoda pobierajaca dane Exif ze zdjecia i dodajaca je do wyswietlenia
        /// </summary>
        private void fillExif()
        {
            PropertyItem[] propertyItems = zdjecie.PobierzDaneExif();
            Dictionary<int, string> d = PropertyTags.defaultExifIds;
            string propertyValue;

            foreach(PropertyItem pItem in propertyItems) {
                if (d.ContainsKey(pItem.Id)) 
                {
                    propertyValue = PropertyTags.ParseProp(pItem);
                    if (!propertyValue.Equals(""))
                        Exif.Items.Add(new ListViewItem(new string[] { d[pItem.Id], propertyValue }));
                }
            }
        }

        /// <summary>
        /// Metoda pobierajaca podstawowe dane o zdjeciu i dodajaca je do wyswietlenia
        /// </summary>
        private void fillTags()
        {
            Tags.Items.Add(new ListViewItem(new string[] { "Lokalizacja", zdjecie.Path.Substring(0, zdjecie.Path.LastIndexOf('\\') + 1) }));
            Tags.Items.Add(new ListViewItem(new string[] { "Nazwa", zdjecie.NazwaPliku }));
            Tags.Items.Add(new ListViewItem(new string[] { "Szerokość", zdjecie.Rozmiar.Width.ToString() }));
            Tags.Items.Add(new ListViewItem(new string[] { "Wysokość", zdjecie.Rozmiar.Height.ToString() }));
            Tags.Items.Add(new ListViewItem(new string[] { "Format", zdjecie.FormatPliku }));
            if (zdjecie.CzyUstawioneId())
                Tags.Items.Add(new ListViewItem(new string[] { "Data dodania:", zdjecie.ZwrocDateDodaniaDoKolekcji() }));
            StringBuilder sb;
            List<string> Albumy = zdjecie.ZwrocNazwyAlbumow();
            List<string> Tagi = zdjecie.ZwrocNazwyTagow();
            if (Albumy.Count > 0)
            {
                sb = new StringBuilder();
                int i;
                for (i = 0; i < Albumy.Count - 1; i++)
                {
                    sb.Append(Albumy[i] + ", ");
                }
                sb.Append(Albumy[i]);
                Tags.Items.Add(new ListViewItem(new string[] { "Albumy", sb.ToString() }));
            }
            if (Tagi.Count > 0)
            {
                sb = new StringBuilder();
                int i;
                for (i = 0; i < Tagi.Count - 1; i++)
                {
                    sb.Append(Tagi[i] + ", ");
                }
                sb.Append(Tagi[i]);
                Tags.Items.Add(new ListViewItem(new string[] { "Tagi", sb.ToString() }));
            }
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    public partial class PhotoForm : Form
    {
        private Operacje operacje;

        public PhotoForm()
        {
            InitializeComponent();

            /* Inicjalizacja okna głównego.
             */
            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            SetStyle(ControlStyles.EnableNotifyMessage, true);

            /* Inicjalizacja kontrolki DrzewoKatalogow.
             */

            drzewoOpakowane1.fileTree1.Fill();

            //fileTree1.Fill();

            /* Inicjalizacja operacji graficznych.
             */
            operacje = new Operacje();
            operacje.WczytajWbudowane();
            operacje.WczytajPluginy();
            operacje.WrzucNaToolBar(toolStripOperacje);
            operacje.ZazadanieOperacji += new ZazadanieOperacjiDelegate(przegladarkaZdjec.DodajOperacje);

            /* Inicjalizacja wyszukiwarki.
             */
            wyszukiwarkaControl1.wyszukiwacz_albumow = listaAlbumowControl;

            /* Delegowanie RozpoczetoWyszukiwanieDelegate.
             */
            drzewoOpakowane1.fileTree1.RozpoczetoWyszukiwanie +=
                new RozpoczetoWyszukiwanieDelegate(statusStrip.RozpoczetoWyszukiwanie);

            /* Delegowanie ZnalezionoZdjecieDelegate.
             */
            drzewoOpakowane1.fileTree1.ZnalezionoZdjecie += 
                new ZnalezionoZdjecieDelegate(przegladarkaZdjec.Dodaj);

            /* Delegowanie ZakonczonoWyszukiwanieDelegate.
             */
            drzewoOpakowane1.fileTree1.ZakonczonoWyszukiwanie +=
                new ZakonczonoWyszukiwanieDelegate(statusStrip.ZakonczonoWyszukiwanie);
            listaAlbumowControl.ZakonczonoWyszukiwanie +=
                new ZakonczonoWyszukiwanieDelegate(przegladarkaZdjec.Wypelnij);
            wyszukiwarkaControl1.ZakonczonoWyszukiwanie +=
                new ZakonczonoWyszukiwanieDelegate(przegladarkaZdjec.Wypelnij);
            //fileTree1.ZakonczonoWyszukiwanie +=
                //new ZakonczonoWyszukiwanieDelegate(przegladarkaZdjec.Wypelnij);

            /* Delegowanie WybranoZdjecieDelegate
             */
            //listaOpakowanControl.WybranoZdjecie +=
            //new WybranoZdjecieDelegate(informacjeControl.Zaladuj);
        }

        private void Alfa_Click(object sender, EventArgs e)
        {
            przegladarkaZdjec.RozpocznijEdycje();
        }

        private void Omega_Click(object sender, EventArgs e)
        {
            przegladarkaZdjec.ZakonczEdycje();
        }

        private void toolStripButton1_Click(object sender, EventArgs e)
        {
            przegladarkaZdjec.SetThumbnailView();
        }

        private void button1_Click(object sender, EventArgs e)
        {

            //fileTree1.Delete();
            //fileTree1.Fill();
            
        }

        private void przegladarkaZdjec_Resize(object sender, EventArgs e)
        {
            //drzewoOpakowane1.fileTree1.Refresh();// = false;
        }

        private void splitContainer2_Panel1_Resize(object sender, EventArgs e)
        {

        }
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Data.SQLite;
using System.Data.SqlClient;

namespace Photo
{
    /// <summary>
    /// Klasa tworząca formatke do dodawania tagów do zdjęć
    /// </summary>
    public partial class Dodaj_tagi_do_zdjecia : Form
    {
        private PrzegladarkaZdjec przegladarka;
        //private Zdjecie zdjecie;
        private List<Zdjecie> lista_zdjec;
        private int opcja = 0;
        bool czy_lista_z_katalogu = false;

        /// <summary>
        /// delegat ten informuje kontrolke wyświetlająca miniaturki że zostały zmiennione tagi żeby kontrolka wyświetlała tylko zdjęcia z odpowiednimi tagami
        /// </summary>        
        public event ZmienionoTagiDelegate ZmienionoTagi;

        /// <summary>
        /// Konstruktor
        /// </summary>
        /// <param name="p">obiekt przeglądarka zdjęć potrzebny do użycia pewnych metod z tego obiektu</param>
        public Dodaj_tagi_do_zdjecia(PrzegladarkaZdjec p)
        {
            InitializeComponent();
            przegladarka = p;
            //Wypelnij();
        }
        
        /// <summary>
        /// Konstruktor
        /// </summary>
        /// <param name="z">obiekt zdjęcia potrzebny do użycia pewnych metod z tego obiektu</param>
        public Dodaj_tagi_do_zdjecia(Zdjecie z)
        {
            InitializeComponent();
            //zdjecie = z;
            //Wypelnij();
            //opcja = 1;
        }
        /// <summary>
        /// Konstruktor
        /// </summary>
        /// <param name="czy_katalog">zmienna bool czy chcemy dodać tagi dla katalogu czy nie</param>
        /// <param name="lis_z">lista zdjęć dla których dodajemy tagi</param>        
        public Dodaj_tagi_do_zdjecia(List<Zdjecie> lis_z, bool czy_katalog )
        {
            InitializeComponent();
            lista_zdjec = lis_z;
            if (lista_zdjec.Count == 1)
            {
                lista_zdjec[0].WypelnijListeTagow();
                Wypelnij(lista_zdjec[0]);
            }
            else
            {
                Wypelnij_dla_kilku();
            }
            czy_lista_z_katalogu = czy_katalog;
            //opcja = 2;
        }

        /// <summary>
        /// Metoda wypełniająca formatke z godnie z informacjami z bazy dotyczących danego zdjęcia
        /// </summary>
        /// <param name="zdjecie">zdjęcie dla którego uaktualniamy tagi</param>
        private void Wypelnij(Zdjecie zdjecie)
        {            
            Db baza = new Db();
            baza.Polacz();
            try
            {
                List<Int64> lista;
                bool czy_znaleziony = false;                

                DataSet ds = baza.Select("select id_tagu, nazwa from Tag where album = 0");

                foreach (DataTable t in ds.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        if (!(r[0] is DBNull))
                        {
                            lista = zdjecie.Tagi;
                            //MessageBox.Show("lista.count: " + lista.Count);
                            foreach (Int64 tag in lista)
                            {                                
                                if (tag == (Int64)r[0])
                                {                                    
                                    this.checkedListBox1.Items.Add((string)r[1], true);
                                    czy_znaleziony = true;
                                    break;
                                }
                            }
                            if (czy_znaleziony == false)
                            {
                                this.checkedListBox1.Items.Add((string)r[1], false);
                            }
                            czy_znaleziony = false;
                        }
                    }
                }
            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad bazy: " + ex.Message);
            }
            baza.Rozlacz();        
        }

        //wypelnia kontrolke tagami ale zadne nie jest zaznaczone bierz sie i ustawia sie tago dla wszystkich zaznaczonych zdjec
        /// <summary>
        /// Metoda wypełnia formatke dla kilku zdjęć czyli wszystkie tagi są odznaczone
        /// </summary>
        private void Wypelnij_dla_kilku()
        {
            Db baza = new Db();
            baza.Polacz();
            try
            {   
                DataSet ds = baza.Select("select id_tagu, nazwa from Tag where album = 0");

                foreach (DataTable t in ds.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        if (!(r[0] is DBNull))
                        {                            
                            this.checkedListBox1.Items.Add((string)r[1], false);                            
                        }
                    }
                }
            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad bazy: " + ex.Message);
            }
            baza.Rozlacz();            
        }

        /// <summary>
        /// Metoda jest wywoływana po kliknięciu przez użytkownika Zatwierdź. Uruchamia metody dodawania tagów
        /// </summary>
        private void button1_Click(object sender, EventArgs e)
        {
            Db baza = new Db();
            baza.Polacz();
            List<Int64> listaTagowDoUstawienia;// = new List<Int64>();

            if (lista_zdjec.Count == 1)
                opcja = 1;
            
            try
            {
                foreach (Zdjecie zdjecie in lista_zdjec)
                {
                    if (zdjecie.CzyUstawioneId() == true)
                    {
                        //MessageBox.Show("dodaje tag");
                        if (opcja == 1)
                        {                            
                            //usuniecie wszystkich tagow zeby dodac nowe
                            baza.Delete("TagZdjecia", "id_zdjecia=" + zdjecie.Id + " and id_tagu in (select id_tagu from Tag where album = 0)");
                            listaTagowDoUstawienia = new List<Int64>();
                        }
                        else
                        {
                            /*zdjecie.WypelnijListeTagow();
                            if (zdjecie.CzyUstawioneId() == true)
                                MessageBox.Show("tak: "+zdjecie.Id);
                            else
                                MessageBox.Show("nie");
                             */
                            listaTagowDoUstawienia = zdjecie.Tagi;
                        }

                        foreach (string ob in this.checkedListBox1.CheckedItems)
                        {
                            DataSet ds = baza.Select("select id_tagu from Tag where nazwa=\'" + ob + "\' and album = 0");

                            foreach (DataTable t in ds.Tables)
                            {
                                foreach (DataRow r in t.Rows)
                                {
                                    if (!(r[0] is DBNull))
                                    {
                                        baza.Insert("TagZdjecia", zdjecie.Id + "," + r[0]);
                                        listaTagowDoUstawienia.Add((Int64)r[0]);
                                        //MessageBox.Show("TagZdjecia" + zdjecie.Id + "," + r[0]);
                                    }
                                }
                            }
                        }
                        zdjecie.Tagi = listaTagowDoUstawienia;
                        //zdjecie.WypelnijListeTagow();
                        //zdjecie.Tagi = listaTagowDoUstawienia;
                        //MessageBox.Show("zd.t.cou: " + zdjecie.Tagi.Count);
                    }
                }

                if (czy_lista_z_katalogu == true)
                {
                    if (ZmienionoTagi != null)
                        ZmienionoTagi();
                }

            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad sql " + ex.Message);
            }
            
            baza.Rozlacz();

            this.Dispose();
        }
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.IO;
using System.Collections;
using Photo;

namespace Photo
{
    public class FileTree : TreeView, IWyszukiwacz
    {        
        public FileTree()
        {
            GenerateImage();            
            this.BackColor = Color.Beige;
        }       

        public const int Dysk = 0;
        public const int FOLDER = 1;
        public const int Dyskietka = 2;
        public const int Cdrom = 3;
        public const int Cdrom_z = 4;
        public const int Dyskietka_z = 5;

        public void GenerateImage()
        {
            ImageList list = new ImageList();
            list.Images.Add(Properties.Resources.Dysk);
            list.Images.Add(Properties.Resources.folder);
            list.Images.Add(Properties.Resources.Dyskietka);
            list.Images.Add(Properties.Resources.Cdrom);
            list.Images.Add(Properties.Resources.Cdrom_z);
            list.Images.Add(Properties.Resources.Dyskietka_z);
            ImageList = list;
        }

        public void Fill()
        {
            BeginUpdate();
            string[] drives = Directory.GetLogicalDrives();

            foreach (string tempDrive in drives)
            {
                DirTreeNode dn = new DirTreeNode(tempDrive);
                Nodes.Add(dn);              

                if (tempDrive.IndexOf("C:\\") != -1)
                {                    
                    this.SelectedNode = dn;
                    this.Select(true, true);
                }                
            }

            EndUpdate();

            BeforeExpand += new TreeViewCancelEventHandler(prepare);
            AfterCollapse += new TreeViewEventHandler(clear);
        }

        public void Open(string path)
        {
            TreeNodeCollection nodes = Nodes;
            DirTreeNode subnode = null;
            int i, n;

            path = path.ToLower();
            nodes = Nodes;
            while (nodes != null)
            {
                n = nodes.Count;
                for (i = 0; i < n; i++)
                {
                    subnode = (DirTreeNode)nodes[i];
                    if (path == subnode.Path)
                    {
                        subnode.Expand();                        
                        return;
                    }
                    if (path.StartsWith(subnode.Path))
                    {
                        subnode.Expand();                        
                        break;
                    }
                }
                if (i == n)
                    return;
                nodes = subnode.Nodes;
            }
        }
        void prepare(object sender, TreeViewCancelEventArgs e)
        {
            BeginUpdate();
            DirTreeNode tn = (DirTreeNode)e.Node;
            try
            {
                tn.populate();
                EndUpdate();
            }
            catch (Exception ex)
            {
                MessageBox.Show(ex.Message + " - Odmowa dostÍpu", e.Node.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
                                
                e.Node.Remove();                
                Nodes.Insert(tn.Index, tn);
                                
                EndUpdate();
            }
        }
        void clear(object sender, TreeViewEventArgs e)
        {
            BeginUpdate();
            DirTreeNode tn = (DirTreeNode)e.Node;
            tn.setLeaf(true);
            EndUpdate();
        }

        public void Delete()
        {
            BeginUpdate();
            //Nodes.RemoveAt(0);
            Nodes.Clear();
            EndUpdate();
        }

        

        public class DirTreeNode : TreeNode
        {
            string path;
            int type;
            public virtual string Path { get { return path; } }

            public DirTreeNode(string s)
                : base(s)
            {
                if (s.CompareTo("A:\\") == 0 || s.CompareTo("B:\\") == 0)
                {                    
                    Text = s + " [Floppy]";
                    ImageIndex = Dyskietka;
                    SelectedImageIndex = Dyskietka;                    
                }
                else
                {
                    Text = s + " [" + GetDriveName(s) + "]";
                    //dn = new DirTreeNode(tempDrive, tempDrive + " [" + GetDriveName(tempDrive) + "]");
                    if (GetDriveName(s) != "" && getDriveType(s) == Cdrom)
                    {
                        ImageIndex = Cdrom_z;
                        SelectedImageIndex = Cdrom_z;
                    }
                    else
                    {
                        ImageIndex = getDriveType(s);
                        SelectedImageIndex = getDriveType(s);
                    }
                }

                path = s.ToLower();
                setLeaf(true);                
            }
            public DirTreeNode(string s, string label)
                : this(s)
            {
                Text = label;
            }
            public DirTreeNode(string s, int aType)
                : base(new FileInfo(s).Name)
            {
                path = s.ToLower();
                type = aType;
                ImageIndex = type;
                SelectedImageIndex = type;
                try
                {
                    string[] n = Directory.GetDirectories(path);

                    if (type == FOLDER && n.Length != 0)
                        setLeaf(true);
                }
                catch (Exception)
                {
                }
            }

            
            [DllImport("kernel32.dll")]
            public static extern long GetDriveType(string driveLetter);
            [DllImport("Kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
            extern static bool GetVolumeInformation(
                                    string RootPathName,
                                    StringBuilder VolumeNameBuffer,
                                    int VolumeNameSize,
                                    out uint VolumeSerialNumber,
                                    out uint MaximumComponentLength,
                                    out uint FileSystemFlags,
                                    StringBuilder FileSystemNameBuffer,
                                    int nFileSystemNameSize);



            public int getDriveType(string drive)
            {
                if ((GetDriveType(drive) & 5) == 5) return Cdrom;//cd
                if ((GetDriveType(drive) & 3) == 3) return Dysk;//fixed
                if ((GetDriveType(drive) & 2) == 2) return Dysk;//removable
                if ((GetDriveType(drive) & 4) == 4) return Dyskietka;//remote disk
                if ((GetDriveType(drive) & 6) == 6) return Dyskietka;//ram disk
                return 0;
            }



            public static string GetDriveName(string drive)
            {
                //receives volume name of drive
                StringBuilder volname = new StringBuilder(256);
                //receives serial number of drive,not in case of network drive(win95/98)
                uint sn;
                uint maxcomplen;//receives maximum component length
                uint sysflags;//receives file system flags
                StringBuilder sysname = new StringBuilder(256);//receives the file system name
                bool retval;//return value

                retval = GetVolumeInformation(drive, volname, 256, out sn, out maxcomplen,
                                              out sysflags, sysname, 256);

                if (retval == true) return volname.ToString();
                else return "";
            }

            public static string Etykieta(string drive)
            {
                return GetDriveName(drive);
            }

            internal void populate()
            {
                ArrayList folder = new ArrayList();

                //string

                string[] files = Directory.GetDirectories(Path);
                Array.Sort(files);

                if (files.Length == 0 && type == Dysk)
                    return;

                for (int i = 0; i < files.Length; i++)
                {
                    folder.Add(new DirTreeNode(files[i], FOLDER));
                }

                Nodes.Clear();
                foreach (DirTreeNode dtn in folder)
                {
                    Nodes.Add(dtn);
                }
            }

            bool isLeaf = true;
            internal void setLeaf(bool b)
            {
                Nodes.Clear();
                isLeaf = b;
                if (IsExpanded)
                    return;
                if (!isLeaf)
                    return;
                Nodes.Add(new TreeNode());
            }

        }

        #region IWyszukiwacz Members

        public IWyszukiwanie Wyszukaj()
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public event ZakonczonoWyszukiwanieDelegate ZakonczonoWyszukiwanie;
        public event ZnalezionoZdjecieDelegate ZnalezionoZdjecie;
        public event RozpoczetoWyszukiwanieDelegate RozpoczetoWyszukiwanie;

        #endregion


        protected override void OnBeforeSelect(TreeViewCancelEventArgs e)
        {
            base.OnBeforeSelect(e);
            //MessageBox.Show("numer: " + e.Node.SelectedImageIndex);

        }

        protected override void OnAfterSelect(TreeViewEventArgs e)
        {
            base.OnAfterSelect(e);

            if (RozpoczetoWyszukiwanie != null)
                RozpoczetoWyszukiwanie(null);

            BackgroundWorker bw = new BackgroundWorker();
            bw.WorkerReportsProgress = true;
            bw.DoWork += new DoWorkEventHandler(bw_DoWork);
            bw.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
            bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
            bw.RunWorkerAsync(e.Node);

            //DirTreeNode dn = new DirTreeNode("napis");            

            string etykieta;

            if (e.Node.Text.IndexOf("A:\\") == 0 && e.Node.Text.LastIndexOf("\\") < 4)
            {
                etykieta = DirTreeNode.Etykieta(e.Node.Text.Substring(0, 3));
                if (etykieta != "")
                {
                    e.Node.Text = "A:\\" + " [" + etykieta + "]";
                    e.Node.ImageIndex = Dyskietka_z;
                    e.Node.SelectedImageIndex = Dyskietka_z;
                }
                else
                {
                    e.Node.Text = "A:\\" + " [Floppy]";
                    e.Node.ImageIndex = Dyskietka;
                    e.Node.SelectedImageIndex = Dyskietka;
                }
            }
            else if (e.Node.Text.IndexOf("B:\\") == 0 && e.Node.Text.LastIndexOf("\\") < 4)
            {
                etykieta = DirTreeNode.Etykieta(e.Node.Text.Substring(0, 3));
                if (etykieta != "")
                {
                    e.Node.Text = "B:\\" + " [" + etykieta + "]";
                    e.Node.ImageIndex = Dyskietka_z;
                    e.Node.SelectedImageIndex = Dyskietka_z;
                }
                else
                {
                    e.Node.Text = "B:\\" + " [Floppy]";
                    e.Node.ImageIndex = Dyskietka;
                    e.Node.SelectedImageIndex = Dyskietka;
                }
            }
        }

        void bw_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            if (ZnalezionoZdjecie != null)
                ZnalezionoZdjecie((Zdjecie)e.UserState);
        }

        void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (ZakonczonoWyszukiwanie != null)
            {
                ZakonczonoWyszukiwanie((IZdjecie[])e.Result);
            }
            
            this.Refresh();
        }

        void bw_DoWork(object sender, DoWorkEventArgs args)
        {
            DirTreeNode Node = (DirTreeNode)args.Argument;
            BackgroundWorker bw = sender as BackgroundWorker;
            args.Result = ZnajdzPlikiWKatalogu(bw, Node);
        }

        private Zdjecie[] ZnajdzPlikiWKatalogu(BackgroundWorker bw, DirTreeNode Node)
        {
            List<Zdjecie> zdjecia = new List<Zdjecie>();
            List<string> pliki = new List<string>();

            try
            {
                pliki.AddRange(Directory.GetFiles(Node.Path, "*.jpg"));
                pliki.AddRange(Directory.GetFiles(Node.Path, "*.jpeg"));
                pliki.AddRange(Directory.GetFiles(Node.Path, "*.tif"));
                pliki.AddRange(Directory.GetFiles(Node.Path, "*.tiff"));

                pliki.Sort();

                for (int i = 0; i < pliki.Count; i++)
                {
                    try
                    {
                        if ((pliki[i].ToLower().LastIndexOf(".jpg") != -1 && pliki[i].ToLower().LastIndexOf(".jpg") == (pliki[i].Length - 4)) || (pliki[i].ToLower().LastIndexOf(".jpeg") != -1 && pliki[i].ToLower().LastIndexOf(".jpeg") == (pliki[i].Length - 5)) || (pliki[i].ToLower().LastIndexOf(".tif") != -1 && pliki[i].ToLower().LastIndexOf(".tif") == (pliki[i].Length - 4)) || (pliki[i].ToLower().LastIndexOf(".tiff") != -1 && pliki[i].ToLower().LastIndexOf(".tiff") == (pliki[i].Length - 5)))                        
                        {
                            Zdjecie z = new Zdjecie(pliki[i]);
                            bw.ReportProgress(0, z);
                            zdjecia.Add(z);
                        }                        
                    }
                    catch (ArgumentException)
                    {
                        //MessageBox.Show("testowo: plik nie jest w poprawnym formacie ");
                        MessageBox.Show("Plik: \"" + pliki[i].Substring(pliki[i].LastIndexOf("\\") + 1) + "\" mimo poprawnego rozszezenie nie zawiera zdjÍcia", pliki[i], MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    }
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " - Odmowa dostÍpu", Node.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);



                /*if (Node.Text.Length == 3)
                {
                    if (Node.Text.CompareTo("A:\\") == 0 || Node.Text.CompareTo("B:\\") == 0 )
                    {
                        Node.ImageIndex = Dyskietka;
                        Node.SelectedImageIndex = Dyskietka;
                    }
                }
*/
                DirTreeNode dd = new DirTreeNode("napis");

                this.SelectedNode = dd;
                //this.SelectedNode = null;


            }
            return zdjecia.ToArray();
           
        }

        protected override void OnAfterExpand(TreeViewEventArgs e)
        {
            base.OnAfterExpand(e);
            

            if (e.Node.Text.IndexOf("A:\\") == 0 && e.Node.Text.LastIndexOf("\\") < 4)
            {
                e.Node.Text = "A:\\ " + "[" + DirTreeNode.Etykieta(e.Node.Text.Substring(0, 3)) + "]";
                e.Node.ImageIndex = Dyskietka_z;
                e.Node.SelectedImageIndex = Dyskietka_z;
            }
            else if (e.Node.Text.IndexOf("B:\\") == 0 && e.Node.Text.LastIndexOf("\\") < 4)
            {
                e.Node.Text = "B:\\ " + "[" + DirTreeNode.Etykieta(e.Node.Text.Substring(0, 3)) + "]";
                e.Node.ImageIndex = Dyskietka_z;
                e.Node.SelectedImageIndex = Dyskietka_z;
            }
        }

        protected override void OnClick(EventArgs e)
        {
            base.OnClick(e);

            //e.Equals = 
        }

        public override ContextMenu ContextMenu
        {
            get
            {
                return base.ContextMenu;
            }
            set
            {
                base.ContextMenu = value;                
            }
        }

        protected override void OnNodeMouseClick(TreeNodeMouseClickEventArgs e)
        {
            base.OnNodeMouseClick(e);

            if (e.Button == MouseButtons.Right)
            {
                //List<MenuItem> = new List<MenuItem>;

                MenuItem[] lista = new MenuItem[5];

                lista[0] = new MenuItem(e.Node.Text);
                lista[4] = new MenuItem("dodaj");
                lista[1] = new MenuItem("dodaj2");
                lista[2] = new MenuItem("dodaj3");
                lista[3] = new MenuItem("dodaj4");

                /*lista.Add( new MenuItem("dodaj"));
                lista.Add( new MenuItem("dodaj2"));
                lista.Add( new MenuItem("dodaj3"));
                lista.Add( new MenuItem("dodaj4"));*/

                ContextMenu m = new ContextMenu(lista);

                m.Show(this, new Point(e.X, e.Y));

                //menu_kon_dla_drzewka mm = new menu_kon_dla_drzewka();
                
                //this.ContextMenuStrip.Show(this, new Point(e.X, e.Y));                
            }
        }

        protected override void OnMouseClick(MouseEventArgs e)
        {   


           
        }

        //protected override do

        private void InitializeComponent()
        {
            this.SuspendLayout();
            // 
            // FileTree
            // 
            this.LabelEdit = true;
            this.ResumeLayout(false);

        }
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.Text;

namespace Photo
{
    public class MiniaturaTag
    {
        string path;

        public MiniaturaTag(string path)
        {
            this.path = path;
        }
        public string Filename
        {
            get
            {
                return path.Substring(path.LastIndexOf('\\') + 1);
            }
        }
        public string Path
        {
            get
            {
                return path;
            }
            set
            {
                this.path = value;
            }
        }
    }
}<file_sep>using System;
using System.Windows.Forms;
using System.Collections.Generic;
using System.Text;

namespace Photo
{
    class ListaOpakowanControl : TabControl, IOpakowanieZdjec
    {
        public void WynikWyszukiwania(IZdjecie[] zdjecia)
        {
            TabPages[0].Controls.Clear();
            ListaMiniaturControl miniatury = new ListaMiniaturControl();
            miniatury.WybranoZdjecie += WybranoZdjecie;
            miniatury.Dock = DockStyle.Fill;
            miniatury.Wypelnij(zdjecia);
            TabPages[0].Controls.Add(miniatury);
        }

        #region IOpakowanieZdjec Members

        private IOpakowanieZdjec AktywneOpakowanie
        {
            get
            {
                IOpakowanieZdjec opakowanie = null;
                foreach (Control control in SelectedTab.Controls)
                {
                    if (control is IOpakowanieZdjec)
                        opakowanie = (IOpakowanieZdjec)control;
                }
                return opakowanie;
            }
        }

        public IZdjecie this[int numer]
        {
            get 
            {
                if (AktywneOpakowanie != null)
                    return AktywneOpakowanie[numer];
                return null;
            }
        }

        public int Ilosc
        {
            get
            {
                if (AktywneOpakowanie != null)
                    return AktywneOpakowanie.Ilosc;
                return 0;
            }
        }

        public void Dodaj(IZdjecie zdjecie)
        {
            if (AktywneOpakowanie != null)
                AktywneOpakowanie.Dodaj(zdjecie);
        }

        public void Usun(IZdjecie zdjecie)
        {
            if (AktywneOpakowanie != null)
                AktywneOpakowanie.Usun(zdjecie);
        }

        public void Oproznij()
        {
            if (AktywneOpakowanie != null)
                AktywneOpakowanie.Oproznij();
        }

        public IZdjecie[] WybraneZdjecia()
        {
            if (AktywneOpakowanie != null)
                return AktywneOpakowanie.WybraneZdjecia();
            return new IZdjecie[] { };
        }

        public void RozpocznijEdycje()
        {
            if (AktywneOpakowanie != null)
                AktywneOpakowanie.RozpocznijEdycje();
        }

        public void ZakonczEdycje()
        {
            if (AktywneOpakowanie != null)
                AktywneOpakowanie.ZakonczEdycje();
        }

        public void DodajOperacje(PolecenieOperacji operacja)
        {
            if (AktywneOpakowanie != null)
                AktywneOpakowanie.DodajOperacje(operacja);
        }

        public void UsunWszystkieOperacje()
        {
            if (AktywneOpakowanie != null)
                AktywneOpakowanie.UsunWszystkieOperacje();
        }

        public event WybranoZdjecieDelegate WybranoZdjecie;

        public void Wypelnij(IZdjecie[] zdjecia)
        {
            if (AktywneOpakowanie != null)
                AktywneOpakowanie.Wypelnij(zdjecia);
        }

        #endregion
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    public partial class InformacjeControl : UserControl
    {
        public InformacjeControl()
        {
            InitializeComponent();
        }

        public void Zaladuj(IZdjecie zdjecie)
        {
            if (zdjecie != null)
            {
                MiniaturaControl mini = (MiniaturaControl)zdjecie;
                listBox1.Items.Add(mini.ImageLocation);
            }
            else
            {
                listBox1.Items.Add("null");
            }
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Collections;

public class FileTree : TreeView
{
    public FileTree()
    {
        GenerateImage();
        Fill();
        this.BackColor = Color.Beige;
    }
    const int HD = 0;
    const int FOLDER = 1;
    
    protected void GenerateImage()
    {
        ImageList list = new ImageList();
        list.Images.Add(new Icon("..\\..\\hd.ico"));
        list.Images.Add(new Icon("..\\..\\folder.ico"));
        
        ImageList = list;
    }
    public void Fill()
    {
        BeginUpdate();
        string[] drives = Directory.GetLogicalDrives();
        for (int i = 0; i < drives.Length; i++)
        {
            DirTreeNode dn = new DirTreeNode(drives[i]);
            dn.ImageIndex = HD;

            Nodes.Add(dn);
        }
        EndUpdate();
        
        BeforeExpand += new TreeViewCancelEventHandler(prepare);
        AfterCollapse += new TreeViewEventHandler(clear);
    }
    public void Open(string path)
    {
        TreeNodeCollection nodes = Nodes;
        DirTreeNode subnode = null;
        int i, n;

        path = path.ToLower();
        nodes = Nodes;
        while (nodes != null)
        {
            n = nodes.Count;
            for (i = 0; i < n; i++)
            {
                subnode = (DirTreeNode)nodes[i];
                if (path == subnode.Path)
                {
                    subnode.Expand();
                    return;
                }
                if (path.StartsWith(subnode.Path))
                {
                    subnode.Expand();
                    break;
                }
            }
            if (i == n)
                return;
            nodes = subnode.Nodes;
        }
    }
    void prepare(object sender, TreeViewCancelEventArgs e)
    {
        BeginUpdate();
        DirTreeNode tn = (DirTreeNode)e.Node;
        try
        {            
            tn.populate();
            EndUpdate();
        }
        catch (Exception ex)
        {
            EndUpdate();
            MessageBox.Show(ex.Message);
            tn.Nodes.Clear();
        }
    }
    void clear(object sender, TreeViewEventArgs e)
    {
        BeginUpdate();
        DirTreeNode tn = (DirTreeNode)e.Node;
        tn.setLeaf(true);
        EndUpdate();
    }

    public class DirTreeNode : TreeNode
    {
        string path;
        int type;
        public virtual string Path { get { return path; } }

        public DirTreeNode(string s): base(s)
        {
            path = s.ToLower();
            setLeaf(true);
            type = HD;
            ImageIndex = type;
            SelectedImageIndex = type;
        }
        public DirTreeNode(string s, int aType): base(new FileInfo(s).Name)
        {
            path = s.ToLower();
            type = aType;
            ImageIndex = type;
            SelectedImageIndex = type;
            try
            {
                string[] n = Directory.GetDirectories(path);

                if (type == FOLDER && n.Length != 0)
                    setLeaf(true);
            }
            catch(Exception)
            {
            }
        }        

        internal void populate()
        {
            ArrayList folder = new ArrayList();           

            string[] files = Directory.GetDirectories(Path);
            
            for (int i = 0; i < files.Length; i++)
            {            
                folder.Add(new DirTreeNode(files[i], FOLDER));                
            }
            
            Nodes.Clear();
            foreach (DirTreeNode dtn in folder)
            {
                Nodes.Add(dtn);                
            }            
        }

        bool isLeaf = true;
        internal void setLeaf(bool b)
        {            
            Nodes.Clear();
            isLeaf = b;
            if (IsExpanded)
                return;
            if (!isLeaf)
                return;
            Nodes.Add(new TreeNode());
        }
        
    }
}<file_sep>using System.Collections.Generic;
using System.Drawing;
using System;

namespace Photo
{
    /// <summary>
    /// Interfejs implementowany przez klasy które chcą wykonywać operacje na bitmapach.
    /// </summary>
    public interface IOperacja
    {
        /// <summary>
        /// Zwraca nazwę operacji.
        /// </summary>
        string NazwaOperacji
        {
            get;
        }
        /// <summary>
        /// Zwraca kod operacji, kod jest przydzielany przez aplikację podczas uruchamiania.
        /// Służy do jednoznacznej identyfikacji operacji (nazwa być nie musi).
        /// </summary>
        int KodOperacji
        {
            get;
            set;
        }
        /// <summary>
        /// Ikona wyświetlana w menu operacji.
        /// </summary>
        Image Ikona
        {
            get;
        }
        /// <summary>
        /// Autor implementacji.
        /// </summary>
        string Autor
        {
            get;
        }
        /// <summary>
        /// Wersja implementacji.
        /// </summary>
        string Wersja
        {
            get;
        }
        /// <summary>
        /// Kontakt do autora implementacji.
        /// </summary>
        string Kontakt
        {
            get;
        }
        /// <summary>
        /// Wywoływana gdy użytkownik chce wykonać operację. Ma na celu zebranie potrzebnych argumentów, np.
        /// przez wyświetlenie okna dialogowego.
        /// </summary>
        /// <returns>Wartości argumentów ustalone przez użytkownika.</returns>
        Stack<object> PodajArgumenty();
        /// <summary>
        /// Wykonuje zaimplementowaną operacje graficzną na bitmapie.
        /// </summary>
        /// <param name="z">Zdjecie na którym ma zostać wykonana operacja.</param>
        /// <param name="Argumenty">Argumenty dla operacji. Na dnie stosu leży argument pierwszy.</param>
        void Wykonaj(Zdjecie z, Stack<object> Argumenty);

        /// <summary>
        /// Metoda zwracajaca informacje, czy operacja ma zostac umieszczona
        /// na toolbarze, czy nie.
        /// </summary>
        /// <returns>Czy umiescic na toolbarze</returns>
        bool CzyNaToolbar();
    }

    /// <summary>
    /// Delegat informujący o wybraniu zdjęcia z pewnego zbioru.
    /// </summary>
    /// <param name="zdjecie">Wybrany obiekt.</param>
    public delegate void WybranoZdjecieDelegate(Zdjecie zdjecie);

    /// <summary>
    /// Delegat informujący o wybraniu katalogu z pewnego zbioru.
    /// </summary>
    /// <param name="katalog">Wybrany obiekt.</param>
    public delegate void WybranoKatalogDelegate(Katalog katalog);

    /// <summary>
    /// Delegat informujący o zaznaczeniu zdjęcia z pewnego zbioru.
    /// </summary>
    /// <param name="zdjecie">Wybrany obiekt.</param>
    public delegate void ZaznaczonoZdjecieDelegate(Zdjecie zdjecie);
    /// <summary>
    /// Delegat informujący o wlaczeniu widoku zdjecia
    /// </summary>
    public delegate void WlaczonoWidokZdjeciaDelegate();
    /// <summary>
    /// Delegat informujący o wylaczeniu widoku zdjecia
    /// </summary>
    public delegate void WylaczonoWidokZdjeciaDelegate();

    /// <summary>
    /// Delegat informujący o wylaczeniu widoku zdjecia
    /// </summary>
    public delegate bool ZabierzFocusDelegate();

    /// <summary>
    /// Delegat informujący o zmianie tagow
    /// </summary>
    public delegate void ZmieninoTagiDelegate(List<long> t);

    /// <summary>
    /// Interfejs który przechowuje zbiór zdjęć (elementów implementujących interfejs IZdjecie).
    /// Powinien znać podzbiór zdjęć wybranych przez użytkownika.
    /// Posiada stan Edycja. Jeśli stan Edycja jest aktywny opakowanie zbiera polecenia operacji 
    /// (PolecenieOperacji), które wykona na zdjęciach wybranych przez użytkownika przy zmianie stanu 
    /// Edycja na nieaktywny.
    /// </summary>
    /// <seealso cref="IZdjecie"/>
    public interface IOpakowanieZdjec
    {
        /// <summary>
        /// Indekser pozwalający uzyskać zdjęcie (IZdjecie) ze zbioru.
        /// </summary>
        /// <param name="numer">Indeks zdjęcia.</param>
        /// <returns></returns>
        IZdjecie this[int numer]
        {
            get;
        }
        /// <summary>
        /// Zwraca liczbe przechowywanych zdjęć.
        /// </summary>
        int Ilosc
        {
            get;
        }
        /// <summary>
        /// Umieszcza obiekt typu IZdjecie w zbiorze.
        /// </summary>
        /// <param name="zdjecie">Obiekt który chcemy dodać.</param>
        void Dodaj(IZdjecie zdjecie);
        /// <summary>
        /// Usuwa zdjęcie ze zbioru.
        /// </summary>
        /// <param name="zdjecie">Obiekt który chcemy usunąć.</param>
        void Usun(IZdjecie zdjecie);
        /// <summary>
        /// Powoduje ze opakowanie staje się puste.
        /// </summary>
        void Oproznij();
        /// <summary>
        /// Zwraca zdjęcia wybrane przez użytkownika.
        /// </summary>
        /// <returns></returns>
        IZdjecie[] WybraneZdjecia
        {
            get;
        }
        /// <summary>
        /// Rozpoczyna edycję (stan Edycja staje sie aktywny).
        /// Jeśli stan Edycja był aktywny już wcześniej - nie wykonuje nic.
        /// </summary>
        void RozpocznijEdycje();
        /// <summary>
        /// Zmienia stan Edycja na nieaktywny.
        /// Jeśli stan edycja był aktywny, wykonuje wszystkie polecenia operacji od momentu 
        /// ostatniej zmiany stanu Edycja z nieaktywnego na aktywny.
        /// </summary>
        void ZakonczEdycje();
        /// <summary>
        /// Dodaje polecenie operacji do zdjęć wybranych przez użytkownika.
        /// Jeśli stan Edycja jest nieaktywny, to wykonuje operację natychmiast.
        /// </summary>
        /// <param name="operacja">Obiekt polecenia operacji która ma zostać wykonana.</param>
        void DodajOperacje(PolecenieOperacji operacja);
        /// <summary>
        /// Metoda usuwajaca wszystkie operacje na zdjeciu/ach
        /// </summary>
        void UsunWszystkieOperacje();
        /// <summary>
        /// Zdarzenie informujące o wskazaniu nowego zdjęcia przez użytkownika.
        /// Gdy nie jest wybrane żadne zdjęcie, delegaci otrzymują wartość null jako argument.
        /// </summary>
        /// <seealso cref="WybranoZdjecieDelegate"/>
        event WybranoZdjecieDelegate WybranoZdjecie;
        /// <summary>
        /// Powoduje że opakowanie wypełnia się nowym zbiorem zdjęć.
        /// </summary>
        /// <param name="zdjecia">Nowy zbiór zdjec dla opakowania.</param>
        /// <param name="katalogi">Nowy zbior katalogow dla opakowania</param>
        /// <param name="CzyZDrzewa">Czy zdjecia pochodza z drzewa katalogow</param>
        void Wypelnij(IZdjecie[] zdjecia, Katalog[] katalogi, bool CzyZDrzewa);
    }

    public enum RodzajModyfikacjiZdjecia
    {
        Zawartosc,
        Metadane,
        Lokalizacja,
        UsunietoZBazy,
        UsunietoZDysku,
        DodanoDoBazy
    }

    public enum RodzajDecyzji
    {
        Tak,
        TakDlaWszystkich,
        Nie,
        NieDlaWszystkich
    }

    /// <summary>
    /// Delagat zdarzenia modyfikacji zdjęcia.
    /// </summary>
    /// <param name="zdjecie">Zdjęcie które zostało zmodyfikowane.</param>
    /// <param name="kontekst">w jakim kontekscie zdjęcie zostało zdodyfikowane</param>
    /// <param name="rodzaj">jaki rodzaj modyfikacji</param>
    public delegate void ZmodyfikowanoZdjecieDelegate(IKontekst kontekst, IZdjecie zdjecie, RodzajModyfikacjiZdjecia rodzaj);

    /// <summary>
    /// Interfejs opisujący zdjęcie.
    /// </summary>
    public interface IZdjecie
    {
        /// <summary>
        /// Dodaje polecenie operacji do zdjęcia. Lista operacji zostanie wykonana metodą WykonajOperacje.
        /// </summary>
        /// <param name="operacja">Obiekt polecenia operacji do wykonania.</param>
        void DodajOperacje(PolecenieOperacji operacja);
        /// <summary>
        /// Wykonuje listę operacji dodanych metodą DodajOperacje.
        /// </summary>
        void WykonajOperacje();
        /// <summary>
        /// Usuwa wszystkie polecenia operacji z listy.
        /// </summary>
        void UsunWszystkieOperacje();
        /// <summary>
        /// </summary>
        Bitmap Duze
        {
            get;
        }
        /// <summary>
        /// Propercja zwraca lub ustawia miniature zdjecia
        /// </summary>
        Bitmap Miniatura
        {
            get;
            set;
        }
        /// <summary>
        /// Propercja zwraca nazwe pliku
        /// </summary>
        string NazwaPliku
        {
            get;
        }

        /// <summary>
        /// Propercja zwraca rozmiar zdjecia
        /// </summary>
        Size Rozmiar
        {
            get;
        }

        /// <summary>
        /// Zdarzenie informujące o modyfikacji zdjęcia.
        /// </summary>
        /// <seealso cref="ZmodyfikowanoZdjecieDelegate"/>
        event ZmodyfikowanoZdjecieDelegate ZmodyfikowanoZdjecie;
    }

    /// <summary>
    /// Interfejs dla obiektów które chcą być kontekstem w którym pojawia się zdjęcie.
    /// Umożliwia to reakcję na zmiany zachodzące na obiekcie IZdjecie, które znajduje
    /// się w wielu kontekstach przez każdy z kontekstów.
    /// </summary>
    public interface IKontekst
    {
        /// <summary>
        /// Umieszcza obiekt typu IZdjecie w kontekście.
        /// </summary>
        /// <param name="zdjecie">Obiekt który chcemy dodać.</param>
        void DodajDoKontekstu(IZdjecie zdjecie);
        /// <summary>
        /// Usuwa zdjęcie z tego kontekstu.
        /// </summary>
        /// <param name="zdjecie">Obiekt który chcemy usunąć.</param>
        void UsunZKontekstu(IZdjecie zdjecie);
        /// <summary>
        /// Wywoływany w momencie modyfikacji zdjęcia przez któryś z kontekstów.
        /// </summary>
        /// <param name="kontekst">Kontekst który dokonał modyfikacji.</param>
        /// <param name="zdjecie">Zdjęcie które zostało zmodyfikowane.</param>
        /// <param name="rodzaj">Rodzaj modyfikacji.</param>
        void ZmodyfikowanoZdjecie(IKontekst kontekst, IZdjecie zdjecie, RodzajModyfikacjiZdjecia rodzaj);
    }

    /// <summary>
    /// Delegat informujący o zakończeniu wyszukiwania.
    /// </summary>
    /// <param name="zdjecia">tablica zdjęć bedąca wynikiem wyszukiwania.</param>
    /// <param name="CzyZDrzewa">zmienna informująca czy dane są wyświetlane z drzewa katalogów czy nie</param>
    /// <param name="katalogi">tablica katalogów będąca wynikiem wyszukiwania</param>
    public delegate void ZakonczonoWyszukiwanieDelegate(IZdjecie[] zdjecia, Katalog[] katalogi, bool CzyZDrzewa);

    /// <summary>
    /// Delegat informujacy o rozpoczeciu wyszukiwania
    /// </summary>
    /// <param name="wyszukiwanie">Rozpoczete wyszkukiwanie</param>
    public delegate void RozpoczetoWyszukiwanieDelegate(IWyszukiwanie wyszukiwanie);

    //public delegate void ZnalezionoZdjecieDelegate(IZdjecie zdjecie);

    /// <summary>
    /// Delegat informujacy o zmianie zrodla zdjec
    /// </summary>
    /// <param name="dir">Nowe zrodlo zdjec</param>
    public delegate void ZmienionoZrodloDelegate(string dir);

    /// <summary>
    /// Delegat informujacy o zmianie tagow
    /// </summary>
    public delegate void ZmienionoTagiDelegate();

    /// <summary>
    /// Delegat informujacy o zmianie identyfikatora
    /// </summary>
    public delegate void ZmienionoIdsDelegate();

    /// <summary>
    /// Interfejs dla obiektu wyszukującego zdjęcia.
    /// </summary>
    public interface IWyszukiwacz
    {
        /// <summary>
        /// Metoda wykonuje proces wyszukiwania. 
        /// </summary>
        /// <returns></returns>
        IWyszukiwanie Wyszukaj();
        /// <summary>
        /// delegat informuję aplikacje ze wyszukiwanie zdjęć się zakończyło
        /// </summary>
        event ZakonczonoWyszukiwanieDelegate ZakonczonoWyszukiwanie;
        /// <summary>
        /// delegat informuję aplikacje ze wyszukiwanie zdjęć się rozpoczeło
        /// </summary>
        event RozpoczetoWyszukiwanieDelegate RozpoczetoWyszukiwanie;
        //event ZnalezionoZdjecieDelegate ZnalezionoZdjecie;
    }

    /// <summary>
    /// Interfejs dla obiektów wyrażeń wyszukujących, które można bezpośrednio zamienić na 
    /// rezultat (zbiór obiektów typu IZdjęcie) będący wynikiem tego wyrażenia.
    /// Umożliwia składanie wyrażeń spójnikami logicznymi.
    /// </summary>
    public interface IWyszukiwanie
    {
        /// <summary>
        /// Koniunkcja z innym wyrażeniem.
        /// </summary>
        /// <param name="W">IWyszukiwanie będące drugim argumentem koniunkcji.</param>
        void And(IWyszukiwanie W);
        /// <summary>
        /// Alternatywa z innym wyrażeniem.
        /// </summary>
        /// <param name="W">IWyszukiwanie będące drugim argumentem alternatywy.</param>
        void Or(IWyszukiwanie W);
        /// <summary>
        /// Koniunkcja tego wyrażenia z warunkiem dla relacji.
        /// Na przykład: warunek dla 'data_wykonania' w relacji 'zdjecie'.
        /// </summary>
        /// <param name="Relacja">jaka relacja</param>
        /// <param name="Warunek">pod jakim warunkiem</param>
        void And(string Relacja, string Warunek);
        /// <summary>
        /// Alternatywa tego wyrażenia z warunkiem dla relacji.
        /// Na przykład: warunek dla 'data_wykonania' w relacji 'zdjecie'.
        /// </summary>
        /// <param name="Relacja">jaka relacja</param>
        /// <param name="Warunek">pod jakim warunkiem</param>
        void Or(string Relacja, string Warunek);
        /// <summary>
        /// Metoda do tworzenia koniunkcji wyrażenia
        /// </summary>
        /// <param name="Wyrazenie">wyrażenie sql</param>
        void And(string Wyrazenie);
        /// <summary>
        /// Metoda do tworzenia alternatywy wyrażenia
        /// </summary>
        /// <param name="Wyrazenie">wyrażenie sql</param>
        void Or(string Wyrazenie);
        /// <summary>
        /// Zwraca tablicę zdjęc będącą rezultatem tego wyrażenia wyszukującego.
        /// </summary>
        /// <returns></returns>
        IZdjecie[] PodajWynik();
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Data.SQLite;
using System.Data.SqlClient;

namespace Photo
{
    /// <summary>
    /// Główna formatka - Gui za pomocą którego użytkownik wykonuje wszystkie operacje
    /// </summary>
    public partial class PhotoForm : Form
    {
        private Operacje operacje;

        /// <summary>
        /// Konstruktor bezparametryczny
        /// </summary>
        public PhotoForm()
        {
            InitializeComponent();
            this.Location = new Point(10, 10);
            this.Width = Screen.PrimaryScreen.Bounds.Width - 25;
            this.Height = Screen.PrimaryScreen.Bounds.Height - 45;
            /* Inicjalizacja okna głównego.
             */
            SetStyle(ControlStyles.OptimizedDoubleBuffer, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            SetStyle(ControlStyles.EnableNotifyMessage, true);

            /* Inicjalizacja kontrolki DrzewoKatalogow.
             */

            drzewoOpakowane1.fileTree1.Fill();

            //fileTree1.Fill();

            /* Inicjalizacja operacji graficznych.
             */
            operacje = new Operacje();
            operacje.WczytajWbudowane();
            operacje.WczytajPluginy();
            operacje.WrzucDoGui(toolStripOperacje, filtryToolStripMenuItem);
            operacje.ZazadanieOperacji += new ZazadanieOperacjiDelegate(przegladarkaZdjec.DodajOperacje);

            /* Inicjalizacja wyszukiwarki.
             */
            wyszukiwarkaControl1.wyszukiwacz_albumow = listaAlbumowControl;

            /* Delegowanie RozpoczetoWyszukiwanieDelegate.
             */
            drzewoOpakowane1.fileTree1.RozpoczetoWyszukiwanie +=
                new RozpoczetoWyszukiwanieDelegate(statusStrip.RozpoczetoWyszukiwanie);

            drzewoOpakowane1.fileTree1.ZmienionoZrodlo +=
                new ZmienionoZrodloDelegate(statusStrip.ZmienionoZrodlo);

            listaAlbumowControl.ZmienionoZrodlo +=
                new ZmienionoZrodloDelegate(statusStrip.ZmienionoZrodlo);

            /* Delegowanie ZnalezionoZdjecieDelegate.
             */
            /*drzewoOpakowane1.fileTree1.ZnalezionoZdjecie += 
                new ZnalezionoZdjecieDelegate(przegladarkaZdjec.Dodaj);*/

            /* Delegowanie ZakonczonoWyszukiwanieDelegate.
             */
            drzewoOpakowane1.fileTree1.ZakonczonoWyszukiwanie +=
                new ZakonczonoWyszukiwanieDelegate(statusStrip.ZakonczonoWyszukiwanie);

            drzewoOpakowane1.fileTree1.ZakonczonoWyszukiwanie +=
                new ZakonczonoWyszukiwanieDelegate(przegladarkaZdjec.Wypelnij);

            /* Delegowanie RozpoczetoWyszukiwanieDelegate.
             */
            listaAlbumowControl.RozpoczetoWyszukiwanie +=            
                new RozpoczetoWyszukiwanieDelegate(statusStrip.RozpoczetoWyszukiwanie);

            /* Delegowanie ZnalezionoZdjecieDelegate.
             */
            listaAlbumowControl.ZakonczonoWyszukiwanie +=            
                new ZakonczonoWyszukiwanieDelegate(przegladarkaZdjec.Wypelnij);

            /* Delegowanie ZakonczonoWyszukiwanieDelegate.
             */
            listaAlbumowControl.ZakonczonoWyszukiwanie +=            
                new ZakonczonoWyszukiwanieDelegate(statusStrip.ZakonczonoWyszukiwanie);

            //listaAlbumowControl.ZakonczonoWyszukiwanie +=
              //  new ZakonczonoWyszukiwanieDelegate(przegladarkaZdjec.Wypelnij);
            wyszukiwarkaControl1.ZakonczonoWyszukiwanie +=
                new ZakonczonoWyszukiwanieDelegate(przegladarkaZdjec.Wypelnij);
            //fileTree1.ZakonczonoWyszukiwanie +=
                //new ZakonczonoWyszukiwanieDelegate(przegladarkaZdjec.Wypelnij);

            /* Delegowanie WybranoZdjecieDelegate
             */
            przegladarkaZdjec.WybranoZdjecie +=
                new WybranoZdjecieDelegate(informacjeControl1.Zaladuj);

            przegladarkaZdjec.WybranoKatalog +=
                new WybranoKatalogDelegate(drzewoOpakowane1.ZaladujZawartoscKatalogu);
            //listaOpakowanControl.WybranoZdjecie +=
            //new WybranoZdjecieDelegate(informacjeControl.Zaladuj);

            /* Delegowanie ZaznaczonoZdjecieDelegate
             */
            przegladarkaZdjec.ZaznaczonoZdjecie +=
                new ZaznaczonoZdjecieDelegate(informacjeControl1.Zaladuj);

            przegladarkaZdjec.WlaczonoWidokZdjecia +=
                new WlaczonoWidokZdjeciaDelegate(this.OnWlaczonoWidokZdjecia);

            przegladarkaZdjec.WylaczonoWidokZdjecia +=
                new WylaczonoWidokZdjeciaDelegate(this.OnWylaczonoWidokZdjecia);

            przegladarkaZdjec.ZabierzFocus +=
                new ZabierzFocusDelegate(drzewoOpakowane1.Focus);

            drzewoOpakowane1.ZabierzFocus +=
                new ZabierzFocusDelegate(przegladarkaZdjec.WezFocus);

            listaAlbumowControl.ZmienionoTagi +=
                new ZmieninoTagiDelegate(przegladarkaZdjec.Thumbnailview.DodajTagi);

            drzewoOpakowane1.fileTree1.ZmienionoIds +=
                new ZmienionoIdsDelegate(przegladarkaZdjec.Thumbnailview.ZresetujIds);

            drzewoOpakowane1.fileTree1.ZmienionoTagi +=
                new ZmienionoTagiDelegate(przegladarkaZdjec.Thumbnailview.ZresetujTagi);

            przegladarkaZdjec.Imageview.ZmodyfikowanoZdjecie +=
                new ZmodyfikowanoZdjecieDelegate(przegladarkaZdjec.Thumbnailview.ZmodyfikowanoZdjecie);
        }

        private void Alfa_Click(object sender, EventArgs e)
        {
            przegladarkaZdjec.RozpocznijEdycje();
        }

        private void Omega_Click(object sender, EventArgs e)
        {
            przegladarkaZdjec.ZakonczEdycje();
        }

        private void toolStripButton1_Click(object sender, EventArgs e)
        {
            przegladarkaZdjec.SetThumbnailView();
        }

        private void button1_Click(object sender, EventArgs e)
        {

            //fileTree1.Delete();
            //fileTree1.Fill();
            
        }

        private void aboutToolStripMenuItem_Click(object sender, EventArgs e)
        {
            MessageBox.Show("-= O programie IIPhoto =-\nProgramiści:\n<NAME>\n<NAME>");
        }

        private void zakonczToolStripMenuItem_Click(object sender, EventArgs e)
        {
            this.Close();
        }

        private void saveToolStripButton_Click(object sender, EventArgs e)
        {
            przegladarkaZdjec.Thumbnailview.ZapiszWszystkiePliki();
        }

        private void zapiszToolStripMenuItem_Click(object sender, EventArgs e)
        {
            ZapiszPlik();
        }

        private void ZapiszPlik()
        {
            if (przegladarkaZdjec.AktywneOpakowanie == przegladarkaZdjec.Imageview)
            {
                przegladarkaZdjec.Imageview.ZapiszPlik();
            }
            else if (przegladarkaZdjec.AktywneOpakowanie == przegladarkaZdjec.Thumbnailview)
            {
                przegladarkaZdjec.Thumbnailview.ZapiszPlik();
            }
        }



        private void OnWlaczonoWidokZdjecia()
        {
            toolStripComboBox2.Visible = false;
            toolStripComboBox1.Visible = true;
        }

        private void OnWylaczonoWidokZdjecia()
        {
            toolStripComboBox1.Visible = false;
            toolStripComboBox2.Visible = true;
        }

        private void skrótyKlawiaturoweToolStripMenuItem_Click(object sender, EventArgs e)
        {
            SkrotyKlawiaturoweHelp skroty = new SkrotyKlawiaturoweHelp();
            skroty.Show();
        }

        //toolStripComboBox1
        private void toolStripComboBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            double zoom = 1.0;
            switch (((ToolStripComboBox)sender).Text)
            {
                case "10%": zoom = 0.1; break;
                case "25%": zoom = 0.25; break;
                case "50%": zoom = 0.5; break;
                case "75%": zoom = 0.75; break;
                case "100%": zoom = 1.0; break;
                case "150%": zoom = 1.5; break;
                case "Do ekranu": przegladarkaZdjec.Imageview.UstawDopasowanieDoEkranu(); przegladarkaZdjec.Imageview.Focus(); return;
            }
            przegladarkaZdjec.Imageview.Zoom(zoom);
            przegladarkaZdjec.Imageview.Focus();
        }
        
        //toolStripComboBox2
        private void toolStripComboBox2_SelectedIndexChanged(object sender, EventArgs e)
        {
            int size;
            switch (((ToolStripComboBox)sender).Text)
            {
                case "Małe": size = 1; break;
                case "Średnie": size = 2; break;
                case "Duże": size = 3; break;
                default: size = 2; break;
            }
            if (size != Config.RozmiarMiniatury)
            {
                Config.ZmienRozmiarMiniatury(size);
                przegladarkaZdjec.ZmienionoRozmiarMiniatury();
            }
            przegladarkaZdjec.Thumbnailview.Focus();
        }

        private void toolStripComboBox2_KeyPress(object sender, KeyPressEventArgs e)
        {
            e.Handled = true;
        }

        private void toolStripComboBox1_KeyPress(object sender, KeyPressEventArgs e)
        {
            e.Handled = true;
        }

        private void wycofajZmianyToolStripMenuItem_Click(object sender, EventArgs e)
        {
            if (przegladarkaZdjec.Imageview.czyZaladowaneZdjecie == false)
                return;
            przegladarkaZdjec.Imageview.Zdjecie.Dispose();
            przegladarkaZdjec.Imageview.Zdjecie.Edytowano = false;
            przegladarkaZdjec.Thumbnailview.ZmodyfikowanoZdjecie(null, przegladarkaZdjec.Imageview.Zdjecie, RodzajModyfikacjiZdjecia.Zawartosc);
            przegladarkaZdjec.Imageview.Wypelnij(new IZdjecie[] { przegladarkaZdjec.Imageview.Zdjecie});
        }

        private void zapiszButton1_Click(object sender, EventArgs e)
        {
            if (przegladarkaZdjec.AktywneOpakowanie == przegladarkaZdjec.Imageview)
            {
                przegladarkaZdjec.Imageview.ZapiszPlik();
            }
            else if (przegladarkaZdjec.AktywneOpakowanie == przegladarkaZdjec.Thumbnailview)
            {
                przegladarkaZdjec.Thumbnailview.ZapiszPlik();
            }
        }

        private void aktualizacjaBazyToolStripMenuItem_Click(object sender, EventArgs e)
        {
            Db baza = new Db();

            baza.Polacz();

            try
            {
                DataSet ds;
                string pelna_sciezka;

                ds = baza.Select("select sciezka,nazwa_pliku from Zdjecie");

                foreach (DataTable t in ds.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        if (!(r[0] is DBNull))
                        {
                            pelna_sciezka = r[0] + "\\" + r[1];

                            if (System.IO.File.Exists(pelna_sciezka) == true)
                            {
                                Zdjecie z = new Zdjecie(pelna_sciezka);
                                //tutaj musi byc wukorzystana funkcja do zczytania pol i do update bazy                                
                                z.ZweryfikujZdjecie();
                                if (z.CzyUstawioneId() == true)
                                {
                                    z.AktualizujBaze();
                                }
                            }
                        }
                    }
                }
            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad bazy: " + ex.Message);
            }
        }

        private void oznaczeniaToolStripMenuItem_Click(object sender, EventArgs e)
        {
            OznaczeniaHelp oznaczenia = new OznaczeniaHelp();
            oznaczenia.Show();
        }
    }
}<file_sep>﻿using System;
using System.Collections.Generic;
using System.Drawing;
using System.Drawing.Imaging;
using System.Text;
using System.IO;
using System.Windows.Forms;
using System.Data.SQLite;
using System.Data.SqlClient;
using System.Data;


namespace Photo
{
    /// <summary>
    /// Klasa implementujace interfejs IZdjecie. 
    /// Zawierajaca wszystkie potrzebne informacje oraz wykonujaca wszystkie wymagane operacje.
    /// </summary>
    public class Zdjecie : IZdjecie, IDisposable
    {
        private string iiphotoTag;
        Bitmap miniatura;
        Bitmap duze;
        string path;
        int Orientation;
        string format;
        Size size;
        bool edytowano;
        bool tylkoDoOdczytu;
        string autor = "", komentarz = "", orientacja = "";
        int orient = -1;

        /// <summary>
        /// Indeks zdjecia w kolekcji
        /// </summary>
        public int indeks;

        /// <summary>
        /// Zaznaczenie wykonane na zdjeciu
        /// </summary>
        public Rectangle Zaznaczenie;

        List<PolecenieOperacji> operacje = new List<PolecenieOperacji>();
        List<long> tagi = new List<long>();

        /// <summary>
        /// Konstruktor
        /// </summary>
        /// <param name="Path">Lokalizacja zdjecia na dysku</param>
        public Zdjecie(string Path)
        {
            path = Path;
            Zaznaczenie = new Rectangle(0,0,0,0);
            iiphotoTag = "brak";            
            FileInfo fi = new FileInfo(Path);
            tylkoDoOdczytu = fi.IsReadOnly;
            //ZweryfikujZdjecie();
            WypelnijListeTagow();
        }

        /// <summary>
        /// Propercja zwraca lub ustawia IIPhotoTag, zapisany w danych Exif zdjecia
        /// </summary>
        public string Id
        {
            get
            {
                if (iiphotoTag.Equals("brak"))
                {
                    iiphotoTag = "";
                    using (FileStream stream = new FileStream(Path, FileMode.Open, FileAccess.Read))
                    {
                        try
                        {
                            using (Image image = Image.FromStream(stream,
                                /* useEmbeddedColorManagement = */ true,
                                /* validateImageData = */ false))
                            {
                                PropertyItem[] items = image.PropertyItems;
                                foreach (PropertyItem item in items)
                                {
                                    if (item.Id == PropertyTags.IIPhotoTag)
                                    {
                                        iiphotoTag = PropertyTags.ParseProp(item);
                                    }
                                }
                            }
                        }
                        catch (ArgumentException)
                        {
                        }
                    }
                }
                return iiphotoTag;
            }
            set
            {
                if (value != null)
                {
                    iiphotoTag = value;
                    string tempFileName = System.IO.Path.GetTempFileName();
                    using (FileStream stream = new FileStream(Path, FileMode.Open, FileAccess.Read))
                    {
                        try
                        {
                            using (Image image = Image.FromStream(stream, true, false))
                            {
                                System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
                                PropertyItem propItem = image.PropertyItems[0];
                                propItem.Id = PropertyTags.IIPhotoTag;
                                propItem.Type = 2;
                                propItem.Value = encoding.GetBytes(value);
                                propItem.Len = propItem.Value.Length;
                                image.SetPropertyItem(propItem);
                                image.Save(tempFileName, image.RawFormat);
                            }
                        }
                        catch (ArgumentException)
                        {
                            return;
                        }
                    }
                    File.Delete(Path);
                    File.Move(tempFileName, Path);
                }
            }
        }

        /// <summary>
        /// Metoda sprawdza czy zdjecie ma ustawiony IIPhotoTag
        /// </summary>
        /// <returns></returns>
        public bool CzyUstawioneId()
        {
            return !Id.Equals("");
        }

        /// <summary>
        /// Metoda usuwa IIPhotoTag ze zdjecia
        /// </summary>
        public void UsunId()
        {
            if (tylkoDoOdczytu)
                return;
            if (!iiphotoTag.Equals(""))
            {
                iiphotoTag = "";
                string tempFileName = System.IO.Path.GetTempFileName();
                using (FileStream stream = new FileStream(Path, FileMode.Open, FileAccess.Read))
                {
                    try
                    {
                        using (Image image = Image.FromStream(stream, true, false))
                        {
                            image.RemovePropertyItem(PropertyTags.IIPhotoTag);
                            image.Save(tempFileName, image.RawFormat);
                        }
                    }
                    catch (ArgumentException)
                    {
                        return;
                    }
                }
                File.Delete(Path);
                File.Move(tempFileName, Path);
            }
        }

        /// <summary>
        /// Metoda usuwa zdjecie i zwraca wynik czy zdjecie zostalo usuniete
        /// </summary>
        /// <returns>Zmienna typu bool, mowiaca czy zdjecie zostalo poprawnie usuniete</returns>
        public bool Usun()
        {
            if (tylkoDoOdczytu)
            {
                MessageBox.Show("Plik tylko do odczytu! Nie można usunąć.", "Błąd", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                return false;
            }

            if (MessageBox.Show("Czy napewno chcesz usunąć \"" + Path + "\"", "Potwierdzenie usunięcia pliku", MessageBoxButtons.YesNo, MessageBoxIcon.Warning) == DialogResult.No)
                return false;

            if (CzyUstawioneId() == true)
            {
                UsunZdjecieZBazy();
            }

            System.IO.File.Delete(Path);
            return true;
        }

        /// <summary>
        /// Propercja zwraca lub ustawia miniature zdjecia
        /// </summary>
        public Bitmap Miniatura
        {
            set
            {
                miniatura = value;
            }
            get
            {
                if (miniatura != null)
                    return miniatura;
                else
                {
                    if (!System.IO.File.Exists(Path))
                        return null;
                    string folder = Path.Substring(0, Path.LastIndexOf('\\') + 1);
                    using (FileStream stream = new FileStream(Path, FileMode.Open, FileAccess.Read))
                    {
                        try
                        {
                            using (Image image = Image.FromStream(stream,
                                /* useEmbeddedColorManagement = */ true,
                                /* validateImageData = */ false))
                            {
                                int scaledH, scaledW;
                                if (image.Height > image.Width)
                                {
                                    scaledH = Config.RozmiarMiniatury;
                                    scaledW = (int)Math.Round(
                                        (double)(image.Width * scaledH) / image.Height);
                                }
                                else
                                {
                                    scaledW = Config.RozmiarMiniatury;
                                    scaledH = (int)Math.Round(
                                        (double)(image.Height * scaledW) / image.Width);
                                }
                                size = image.Size;
                                format = Zdjecie.sprawdzFormatPliku(image);
                                try
                                {
                                    miniatura = (Bitmap)image.GetThumbnailImage(scaledW, scaledH, new System.Drawing.Image.GetThumbnailImageAbort(ThumbnailCallback), System.IntPtr.Zero);
                                }
                                catch (Exception)
                                {
                                    miniatura = (Bitmap)Properties.Resources.blad.GetThumbnailImage(scaledW, scaledH, new System.Drawing.Image.GetThumbnailImageAbort(ThumbnailCallback), System.IntPtr.Zero);
                                }
                                Orientation = SprawdzOrientacje(image);
                                //UzyjOrientacji(miniatura);
                            }
                        }
                        catch (ArgumentException)
                        {
                            return null;
                        }
                    }

                    return miniatura;
                }
            }
        }

        /// <summary>
        /// Metoda statyczna tworzaca nowa bitmape z podanego obrazu
        /// </summary>
        /// <param name="i">Obraz</param>
        /// <returns>Bitmapa</returns>
        public static Bitmap FromImage(Image i)
        {
            Bitmap from = null;
            try
            {
                from = new Bitmap(i);
            }
            catch (System.Runtime.InteropServices.ExternalException)
            {
                from = new Bitmap(Properties.Resources.blad);
            }
            foreach (PropertyItem pi in i.PropertyItems)
            {
                from.SetPropertyItem(pi);
            }
            return from;
        }

        /// <summary>
        /// Metoda zwraca lub ustawia faktyczne zdjecie
        /// </summary>
        public Bitmap Duze
        {
            get
            {
                if (duze != null)
                    return duze;
                else
                {
                    using (FileStream stream = new FileStream(Path, FileMode.Open, FileAccess.Read))
                    {
                        using (Image image = Image.FromStream(stream,
                            /* useEmbeddedColorManagement = */ true,
                            /* validateImageData = */ false))
                        {
                            duze = Zdjecie.FromImage(image);
                        }
                    }
                    //UzyjOrientacji(duze);
                    return duze;
                }
            }
            set
            {
                duze = value;
            }
        }

        /// <summary>
        /// Metoda zwraca nazwe pliku z ktorego wczytane jest dane zdjecie
        /// </summary>
        public string NazwaPliku
        {
            get
            {
                return path.Substring(path.LastIndexOf('\\') + 1);
            }
        }

        /// <summary>
        /// Propercja zwraca lokalizacje zdjecia na dysku
        /// </summary>
        public string Path
        {
            get
            {
                return path;
            }
            set
            {
                this.path = value;
            }
        }

        /// <summary>
        /// Propercja zwraca/ustawia liste tagow, ktore posiada zdjecie
        /// </summary>
        public List<Int64> Tagi
        {
            get
            {
                return tagi;
            }
            set
            {
                this.tagi = value;
            }
        }

        /// <summary>
        /// Propercja zwraca rozmiar zdjecia
        /// </summary>
        public Size Rozmiar
        {
            get
            {
                return size;
            }
        }

        /// <summary>
        /// Medota zwraca format podanego zdjecia
        /// </summary>
        /// <param name="i">Obraz</param>
        /// <returns>Napis z formatem pliku</returns>
        public static string sprawdzFormatPliku(Image i)
        {
            if (i.RawFormat.Equals(ImageFormat.Jpeg))
                return "Jpeg";
            else
                return "";
        }

        /// <summary>
        /// Propercja zwraca format zdjecia
        /// </summary>
        public string FormatPliku
        {
            get
            {
                if (format == null)
                {
                    if (Miniatura == null)
                        return "Nieznany";
                    else
                        return format;
                }
                return format;
            }
        }

        /// <summary>
        /// Metoda tworzy miniature o podanym maksymalnym rozmiarze
        /// </summary>
        /// <param name="maxSize">Maksymalny rozmiar miniatury</param>
        /// <returns>Miniatura zdjecia</returns>
        public Bitmap stworzMiniaturke(int maxSize)
        {
            int scaledH, scaledW;
            if (Duze.Height > Duze.Width)
            {
                scaledH = maxSize;
                scaledW = (int)Math.Round(
                    (double)(Duze.Width * scaledH) / Duze.Height);
            }
            else
            {
                scaledW = maxSize;
                scaledH = (int)Math.Round(
                    (double)(Duze.Height * scaledW) / Duze.Width);
            }
            return (Bitmap)Duze.GetThumbnailImage(scaledW, scaledH, new System.Drawing.Image.GetThumbnailImageAbort(ThumbnailCallback), System.IntPtr.Zero);
        }

        /// <summary>
        /// Metoda tworzy miniature o podanym maksymalnym rozmiarze z pliku na dysku
        /// </summary>
        /// <param name="fileName">Sciezka do zdjecia</param>
        /// <param name="maxSize">Maksymalny rozmiar miniatury</param>
        /// <returns>Miniatura zdjecia</returns>
        public static Bitmap stworzMiniaturke(string fileName, int maxSize)
        {
            Image i;
            string path = fileName.Substring(0, fileName.LastIndexOf('\\') + 1);
            using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
            {
                using (Image image = Image.FromStream(stream,
                    /* useEmbeddedColorManagement = */ true,
                    /* validateImageData = */ false))
                {
                    int scaledH, scaledW;
                    if (image.Height > image.Width)
                    {
                        scaledH = maxSize;
                        scaledW = (int)Math.Round(
                            (double)(image.Width * scaledH) / image.Height);
                    }
                    else
                    {
                        scaledW = maxSize;
                        scaledH = (int)Math.Round(
                            (double)(image.Height * scaledW) / image.Width);
                    }
                    i = image.GetThumbnailImage(scaledW, scaledH, new System.Drawing.Image.GetThumbnailImageAbort(ThumbnailCallback), System.IntPtr.Zero);
                }
            }
            return (Bitmap)i;
        }

        private static bool ThumbnailCallback()
        {
            return true;
        }


        #region Baza

        /// <summary>
        /// Metoda usuwa tagi zdjecia z bazy danych
        /// </summary>
        public void UsunTagi()
        {
            Db baza = new Db();

            baza.Polacz();
            try
            {
                baza.Delete("TagZdjecia", "id_zdjecia = " + Id + " and id_tagu in (select id_tagu from Tag where album=0)");
            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad sql" + ex.Message);
            }

            baza.Rozlacz();
        }

        /// <summary>
        /// Metoda usuwa zdjecie z albomow w bazie danych
        /// </summary>
        public void UsunAlbumy()
        {
            Db baza = new Db();

            baza.Polacz();
            try
            {
                baza.Delete("TagZdjecia", "id_zdjecia = " + Id + " and id_tagu in (select id_tagu from Tag where album=1)");
            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad sql" + ex.Message);
            }

            baza.Rozlacz();
        }
        
        /// <summary>
        /// Metoda usuwa zdjecie z bazy danych
        /// </summary>
        public void UsunZdjecieZBazy()
        {
            Db baza = new Db();

            baza.Polacz();
            try
            {
                baza.Delete("Zdjecie", "id_zdjecia = " + Id);
                baza.Delete("TagZdjecia", "id_zdjecia = " + Id);
            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad sql" + ex.Message);
            }

            baza.Rozlacz();
        }      

        /// <summary>
        /// Metoda zwraca nazwy tagow z bazy danych
        /// </summary>
        /// <returns>Lista nazw tagow</returns>
        public List<string> ZwrocNazwyTagow()
        {
            Db baza = new Db();
            List<string> lista = new List<string>();
            if (!CzyUstawioneId())
                return lista;

            baza.Polacz();

            try
            {
                DataSet ds = baza.Select("select nazwa from Tag where id_tagu in (select id_tagu from TagZdjecia where id_zdjecia =" + this.Id + ") and album = 0");

                foreach (DataTable t in ds.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        if (!(r[0] is DBNull))
                        {
                            lista.Add((string)r[0]);                            
                        }
                    }
                }                
            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad sql: " + ex.Message);
            }

            baza.Rozlacz();

            return lista;
        }

        /// <summary>
        /// Metoda zwraca date dodania do bazy danych
        /// </summary>
        /// <returns>Data dodania do bazy danych</returns>
        public string ZwrocDateDodaniaDoKolekcji()
        {
            Db baza = new Db();
            string data = "";
            if (!CzyUstawioneId())
                return data;

            baza.Polacz();

            try
            {
                DataSet ds = baza.Select("select data_dodania from Zdjecie where id_zdjecia =" + this.Id);

                foreach (DataTable t in ds.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        if (!(r[0] is DBNull))
                        {
                            data = ((DateTime)r[0]).ToLocalTime().ToString();                            
                        }
                    }
                }
            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad sql: " + ex.Message);
            }

            baza.Rozlacz();

            return data;
        }

        /// <summary>
        /// Metoda zwraca nazwy albomow do ktorych nalezy zdjecie
        /// </summary>
        /// <returns>Lista nazw albomow</returns>
        public List<string> ZwrocNazwyAlbumow()
        {
            Db baza = new Db();
            List<string> lista = new List<string>();
            if (!CzyUstawioneId())
                return lista;

            baza.Polacz();

            try
            {
                DataSet ds = baza.Select("select nazwa from Tag where id_tagu in (select id_tagu from TagZdjecia where id_zdjecia =" + this.Id + ") and album = 1");

                foreach (DataTable t in ds.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        if (!(r[0] is DBNull))
                        {
                            lista.Add((string)r[0]);
                        }
                    }
                }
            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad sql: " + ex.Message);
            }

            baza.Rozlacz();

            return lista;
        }

        /// <summary>
        /// Metoda aktualizuje dane o zdjeciu w bazie danych
        /// </summary>
        public void AktualizujBaze()
        {
            if (CzyUstawioneId())
            {
                Db baza = new Db();

                baza.Polacz();

                try
                {
                    ZczytajPola();
                    baza.Update("Zdjecie", "komentarz=\'" + komentarz + "\', autor=\'" + autor + "\', orientacja=" + orient + " where id_zdjecia=" + Id);
                    //MessageBox.Show("Update3: komentarz=\'" + komentarz + "\', autor=\'" + autor + "\', orientacja=" + orient + " where id_zdjecia=" + Id);
                }
                catch (SqlException ex)
                {
                    MessageBox.Show("blad sql: " + ex.Message);
                }

                baza.Rozlacz();
            }

        }

        /// <summary>
        /// Metoda wypelnia tagi danymi z bazy
        /// </summary>
        public void WypelnijListeTagow()
        {
            if(CzyUstawioneId())
            {
                tagi.Clear();
                Db baza = new Db();
                baza.Polacz();
                try
                {
                    DataSet ds = baza.Select("select id_tagu from TagZdjecia where id_zdjecia=" + this.Id + " and id_tagu in (select id_tagu from Tag where album = 0)");

                    foreach (DataTable t in ds.Tables)
                    {
                        foreach (DataRow r in t.Rows)
                        {
                            if (!(r[0] is DBNull))
                            {
                                tagi.Add((Int64)r[0]);
                                //MessageBox.Show("" + r[0]);
                            }                             
                        }
                    }
                }
                catch(SqlException ex)
                {
                    MessageBox.Show("blad bazy: " + ex.Message);
                }
                baza.Rozlacz();
            }
        }

        /// <summary>
        /// Metoda sprawdza czy jezeli zdejecie mialo tag to czy ten tag skasowac czy nie
        /// </summary>
        public void ZweryfikujZdjecie()
        {
            string sciezka_z_bazy = "", nazwa_pliku_z_bazy = "", sciezka = "", nazwa_pliku = "";
            Db baza = new Db();            

            baza.Polacz();

            if (CzyUstawioneId() == true)
            {
                try
                {
                    DataSet ds = baza.Select("select sciezka, nazwa_pliku from Zdjecie where id_zdjecia=" + Id);

                    foreach (DataTable t in ds.Tables)
                    {
                        foreach (DataRow r in t.Rows)
                        {
                            if (!(r[0] is DBNull))
                            {
                                sciezka_z_bazy = (string)r[0];
                                nazwa_pliku_z_bazy = (string)r[1];
                            }
                        }
                    }

                    if (nazwa_pliku_z_bazy != "" && sciezka_z_bazy != "")
                    {

                        if (path.Equals(sciezka_z_bazy + "\\" + nazwa_pliku_z_bazy) == false)
                        {
                            //sprawdzic czy zdjecie istnieje na dysku tam gdzie powinno
                            //jesli tak i ma id ten sam to kasujemy z obecnego id
                            //jesli nie to uaktualniamy baze
                            sciezka = path.Substring(0, path.LastIndexOf("\\"));
                            if (sciezka.Length == 2)
                                sciezka += "\\";

                            nazwa_pliku = path.Substring(path.LastIndexOf("\\") + 1, path.Length - path.LastIndexOf("\\") - 1);


                            if (System.IO.File.Exists(sciezka_z_bazy + "\\" + nazwa_pliku_z_bazy) == true)
                            {
                                Zdjecie z = new Zdjecie(sciezka_z_bazy + "\\" + nazwa_pliku_z_bazy);
                                //jezeli ma ten sam tag to kasujemy 
                                //jesli inny tag to i w bazie nie ma wartosci dla tego tagu to kasujemy tag
                                //jesli inny tag i w bazie cos jest toaktualizujemy sciezke i nazwe plku

                                if (z.Id == Id)
                                {
                                    //kasuj id z this
                                    this.UsunId();
                                }
                                else
                                {
                                    //aktualizacja bazy dla this czyli sciezke i nazwe pliku                                    
                                    try
                                    {
                                        //ZczytajPola();
                                        baza.Update("Zdjecie", "sciezka=\'" + sciezka + "\', nazwa_pliku=\'" + nazwa_pliku + "\' where id_zdjecia=" + Id);
                                        //, komentarz=\'" + komentarz + "\', autor=\'" + autor + "\', orientacja=" + orient + "
                                        //MessageBox.Show("Update1: sciezka=\'" + sciezka + "\', nazwa_pliku=\'" + nazwa_pliku + "\', komentarz=\'" + komentarz + "\', autor=\'" + autor + "\', orientacja=" + orient + " where id_zdjecia=" + Id);
                                    }
                                    catch (SqlException ex)
                                    {
                                        MessageBox.Show("blad sql: " + ex.Message);
                                    }
                                }
                            }
                            else
                            {
                                //aktualizacja bazy dla this czyli sciezke i nazwe pliku                                
                                try
                                {
                                    baza.Update("Zdjecie", "sciezka=\'" + sciezka + "\', nazwa_pliku=\'" + nazwa_pliku + "\' where id_zdjecia=" + Id);
                                    //ZczytajPola();
                                    //baza.Update("Zdjecie", "sciezka=\'" + sciezka + "\', nazwa_pliku=\'" + nazwa_pliku + "\', komentarz=\'" + komentarz + "\', autor=\'" + autor + "\', orientacja=" + orient + " where id_zdjecia=" + Id);
                                    //MessageBox.Show("Update2: sciezka=\'" + sciezka + "\', nazwa_pliku=\'" + nazwa_pliku + "\', komentarz=\'" + komentarz + "\', autor=\'" + autor + "\', orientacja=" + orient + " where id_zdjecia=" + Id);
                                }
                                catch (SqlException ex)
                                {
                                    MessageBox.Show("blad sql: " + ex.Message);
                                }
                            }
                        }
                        else
                        {//gdy zdjecie zgadza sie ze sciezka to robimy update komentarz, autor itd
                            try
                            {
                                //ZczytajPola();
                                //baza.Update("Zdjecie", "komentarz=\'" + komentarz + "\', autor=\'" + autor + "\', orientacja=" + orient + " where id_zdjecia=" + Id);
                                //MessageBox.Show("Update3: komentarz=\'" + komentarz + "\', autor=\'" + autor + "\', orientacja=" + orient + " where id_zdjecia=" + Id);
                            }
                            catch (SqlException ex)
                            {
                                MessageBox.Show("blad sql: " + ex.Message);
                            }
                        }
                    }
                    else
                    {
                        this.UsunId();
                    }
                }
                catch (SqlException e)
                {
                    MessageBox.Show(e.ToString());
                }
            }
            baza.Rozlacz();
        }

        /// <summary>
        /// Medota zczytuje dane Exif ze zdjecia
        /// </summary>
        private void ZczytajPola()
        {
            Dictionary<string, string> tablica;

            autor = "";
            komentarz = "";            
            orientacja = "";            
            orient = -1;

            try
            {
                tablica = PobierzExifDoBazy();

                if (tablica.ContainsKey("autor"))
                {
                    autor = tablica["autor"];
                }
                if (tablica.ContainsKey("komentarz"))
                {
                    komentarz = tablica["komentarz"];
                }                
                if (tablica.ContainsKey("orientacja"))
                {
                    orientacja = tablica["orientacja"];
                    if (orientacja == "Normal")
                        orient = 0;
                    else
                        orient = 1;
                }
            }
            catch (Exception)
            {

            }
        }

        /// <summary>
        /// Metoda dodaje zdjecie do bazy danych
        /// </summary>
        /// <returns>Czy operacja sie powiodla</returns>
        public bool DodajDoKolekcji()
        {
            if (tylkoDoOdczytu)
                return false;
            Db baza = new Db();            

            baza.Polacz();

            ZweryfikujZdjecie();

            if (CzyUstawioneId() == false)
            {
                //zczytanie z bazy i dodanie tagu do zdjecia
                
                Dictionary<string, string> tablica;

                string autor = "", komentarz = "", data_wykonania = "", orientacja = "", sciezka = "", nazwa_pliku = "";
                int orient = -1;

                try
                {
                    tablica = PobierzExifDoBazy();

                    if (tablica.ContainsKey("autor"))
                    {
                        autor = tablica["autor"];
                    }
                    if (tablica.ContainsKey("komentarz"))
                    {
                        komentarz = tablica["komentarz"];
                    }
                    if (tablica.ContainsKey("data_wykonania"))
                    {
                        data_wykonania = tablica["data_wykonania"];
                    }
                    if (tablica.ContainsKey("orientacja"))
                    {
                        orientacja = tablica["orientacja"];
                        if (orientacja == "Normal")
                            orient = 0;
                        else
                            orient = 1;
                    }

                    sciezka = path.Substring(0, path.LastIndexOf("\\"));
                    if (sciezka.Length == 2)
                        sciezka += "\\";

                    nazwa_pliku = path.Substring(path.LastIndexOf("\\") + 1, path.Length - path.LastIndexOf("\\") - 1);
                    
                    try
                    {
                        baza.Insert_czesci("zdjecie", "sciezka,data_dodania,data_wykonania,komentarz,autor,nazwa_pliku,orientacja", "'" + sciezka + "',current_time,null,'" + komentarz + "','" + autor + "','" + nazwa_pliku + "'," + orient);
                        //MessageBox.Show("dodano do bazy");

                        DataSet ds = baza.Select("select id_zdjecia from Zdjecie where sciezka=\'" + sciezka + "\' and nazwa_pliku=\'" + nazwa_pliku + "\'");

                        foreach (DataTable t in ds.Tables)
                        {
                            foreach (DataRow r in t.Rows)
                            {
                                if (!(r[0] is DBNull))
                                {
                                    Id = "" + r[0];
                                }
                            }
                        }
                    }
                    catch (SqlException)
                    {
                        MessageBox.Show("bladsql");
                    }
                    
                }
                catch (Exception e)
                {
                    MessageBox.Show(e.ToString());
                }                
            }
            
            baza.Rozlacz();
            return true;
        }

        /// <summary>
        /// Metoda zwraca lokalizacje zdjecia na podstawie danych z bazy
        /// </summary>
        private string PathZBazy
        {
            get
            {
                string pathFromDb;
                Db db = new Db();
                db.Polacz();
                DataSet ds = db.Select("select sciezka from Zdjecie where id_zdjecia = " + Id);
                DataRow dr = ds.Tables[0].Rows[0];
                if (!(dr[0] is DBNull))
                {
                    pathFromDb = (string)dr[0];
                }
                else
                {
                    pathFromDb = "";
                }
                db.Rozlacz();
                return pathFromDb;
            }
            set
            {
                Db db = new Db();
                db.Polacz();
                db.Update("Zdjecie", "sciezka = '" + value + "' where id_zdjecia = " + Id);
                db.Rozlacz();
            }
        }

        #endregion

        #region Zdjecie Members

        /// <summary>
        /// Metoda dodaje operacje do wykonania na zdjeciu
        /// </summary>
        /// <param name="polecenie">Nowe polecenie wykonania operacji</param>
        public void DodajOperacje(PolecenieOperacji polecenie)
        {
            operacje.Add(polecenie);
        }

        /// <summary>
        /// Metoda wykonuje wszystkie oczekujace operacje
        /// </summary>
        public void WykonajOperacje()
        {
            if (operacje.Count > 0)
            {
                edytowano = true;
                foreach (PolecenieOperacji polecenie in operacje)
                {
                    polecenie.Wykonaj(this);
                }
                AktualizujMiniature();
                if (ZmodyfikowanoZdjecie != null)
                    ZmodyfikowanoZdjecie(null, this, RodzajModyfikacjiZdjecia.Zawartosc);
            }
        }

        /// <summary>
        /// Metoda aktualuzuje miniature
        /// </summary>
        public void AktualizujMiniature()
        {
            Miniatura = stworzMiniaturke(Config.RozmiarMiniatury);
        }

        /// <summary>
        /// Metoda usuwa wszystkie oczekujace operacje
        /// </summary>
        public void UsunWszystkieOperacje()
        {
            operacje.Clear();
        }

        /// <summary>
        /// Zdarzenie informujace o modyfikacji zdjecia
        /// </summary>
        public event ZmodyfikowanoZdjecieDelegate ZmodyfikowanoZdjecie;

        /// <summary>
        /// Metoda tworzy miniature do Widoku Miniatur i ja zwraca
        /// </summary>
        /// <returns>Miniatura do Widoku Miniatur</returns>
        public Image StworzMiniatureDoWidokuMiniatur()
        {
            int maxSize = Config.RozmiarMiniatury;
            int posX, posY;
            Bitmap newBitmap = new Bitmap(maxSize + 2, maxSize + 2);
            Graphics MyGraphics = Graphics.FromImage(newBitmap);

            if (Miniatura.Height > Miniatura.Width)
            {
                posX = (maxSize - Miniatura.Width) / 2;
                posY = 0;
            }
            else
            {
                posX = 0;
                posY = (maxSize - Miniatura.Height) / 2;
            }

            Rectangle MyRectan = new Rectangle(posX + 1, posY + 1, Miniatura.Width, Miniatura.Height);
            Pen p;
            if (CzyUstawioneId() && tylkoDoOdczytu)
            {
                p = new Pen(Color.LightBlue, 3);
            }
            else if (CzyUstawioneId())
            {
                p = new Pen(Color.Green, 3);
            }
            else if (tylkoDoOdczytu)
            {
                p = new Pen(Color.FromArgb(255,141, 138), 3);
            }
            else
            {
                p = new Pen(Color.LightGray, 1);
            }

            MyGraphics.DrawRectangle(p, 0, 0, maxSize + 1, maxSize + 1);
            p.Dispose();
            MyGraphics.DrawImage(Miniatura, MyRectan);
            MyGraphics.Dispose();
            return newBitmap;
        }

        #endregion

        #region Meta

        /// <summary>
        /// Metoda sprawdza orientacje w danych Exif zdjecia
        /// </summary>
        /// <param name="srcImg">Zdjecie z ktorego ma zostac odczytana orientacja</param>
        /// <returns>Wartosc okreslajaca orientacje zdjecia</returns>
        public static int SprawdzOrientacje(Image srcImg)
        {
            foreach (int id in srcImg.PropertyIdList)
            {
                if (id == PropertyTags.Orientation)
                {
                    return BitConverter.ToUInt16(srcImg.GetPropertyItem(id).Value, 0);
                }
            }
            return 1;
        }

        /// <summary>
        /// Metoda obraca zdjecie zgodnie z orientacja zapisana w danych Exif
        /// </summary>
        /// <param name="i"></param>
        public void UzyjOrientacji(Bitmap i)
        {
                    switch (Orientation)
                    {
                        case 2:
                            i.RotateFlip(RotateFlipType.RotateNoneFlipY);
                            break;
                        case 3:
                            i.RotateFlip(RotateFlipType.Rotate180FlipNone);
                            break;
                        case 4:
                            i.RotateFlip(RotateFlipType.RotateNoneFlipX);
                            break;
                        case 5:
                            i.RotateFlip(RotateFlipType.Rotate90FlipY);
                            break;
                        case 6:
                            i.RotateFlip(RotateFlipType.Rotate90FlipNone);
                            break;
                        case 7:
                            i.RotateFlip(RotateFlipType.Rotate270FlipY);
                            break;
                        case 8:
                            i.RotateFlip(RotateFlipType.Rotate270FlipNone);
                            break;
                    }
        }

        /// <summary>
        /// Metoda zwraca tablice z danymi Exif zdjecia
        /// </summary>
        /// <param name="fileName">Sciezka zdjecia</param>
        /// <returns>Tablica z danymi Exif</returns>
        public static PropertyItem[] PobierzDaneExif(string fileName)
        {
            using (FileStream stream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
            {
                try
                {
                    using (Image image = Image.FromStream(stream, true, false))
                    {
                        return image.PropertyItems;
                    }
                }
                catch (ArgumentException)
                {
                    return new PropertyItem[0];
                }
            }            
        }

        /// <summary>
        /// Metoda zwraca tablice z danymi Exif zdjecia
        /// </summary>
        /// <returns>Tablica z danymi Exif</returns>
        public PropertyItem[] PobierzDaneExif()
        {
            using (FileStream stream = new FileStream(Path, FileMode.Open, FileAccess.Read))
            {
                try
                {
                    using (Image image = Image.FromStream(stream,
                        /* useEmbeddedColorManagement = */ true,
                        /* validateImageData = */ false))
                    {
                        return image.PropertyItems;
                    }
                }
                catch (ArgumentException)
                {
                    iiphotoTag = "";
                }
            }
            return null;
        }

        /// <summary>
        /// Metoda zwraca slownik z danymi Exif, ktore zostana wpisane do bazy danych
        /// </summary>
        /// <returns>Slownik z danymi Exif</returns>
        public Dictionary<string, string> PobierzExifDoBazy()
        {
            PropertyItem[] propertyItems = Zdjecie.PobierzDaneExif(Path);
            Dictionary<int, string> defaults = PropertyTags.defaultExifDoBazy;
            Dictionary<string, string> d = new Dictionary<string,string>();
            string propertyValue;

            foreach (PropertyItem pItem in propertyItems)
            {
                if (defaults.ContainsKey(pItem.Id))
                {
                    propertyValue = PropertyTags.ParseProp(pItem);
                    if (!d.ContainsKey(defaults[pItem.Id]) && !propertyValue.Equals(""))
                    {
                        d.Add(defaults[pItem.Id], propertyValue);
                    }
                }
            }
            return d;
        }

        #endregion

        /// <summary>
        /// Propercja ustawiajaca/sprawdzajaca czy zdjecie bylo edytowane
        /// </summary>
        public bool Edytowano
        {
            get
            {
                return edytowano;
            }
            set
            {
                edytowano = value;
            }
        }

        /// <summary>
        /// Metoda zapisujaca zdjecie na dysku
        /// </summary>
        public void Zapisz()
        {
            if (duze == null || Edytowano == false)
                return;
            if (tylkoDoOdczytu)
            {
                SaveFileDialog sfd = new SaveFileDialog();
                sfd.Filter = "JPEG Images (*.jpg,*.jpeg)|*.jpg;*.jpeg";
                if (sfd.ShowDialog() == DialogResult.OK)
                {
                    string strImgName = sfd.FileName;
                    if (strImgName.EndsWith("jpg") || strImgName.EndsWith("jpeg"))
                    {
                        Duze.Save(strImgName, ImageFormat.Jpeg);
                        edytowano = false;
                    }
                }
            }
            else
            {
                Duze.Save(Path, ImageFormat.Jpeg);
                edytowano = false;
            }
        }

        /// <summary>
        /// Metoda usuwajaca bitmape zdjecia z pamieci
        /// </summary>
        public void DisposeDuze() 
        {
            if (duze != null)
            {
                duze.Dispose();
                duze = null;
            }
        }

        /// <summary>
        /// Metoda usuwajaca bitmape miniatury zdjecia z pamieci
        /// </summary>
        public void DisposeMini()
        {
            if (miniatura != null)
            {
                miniatura.Dispose();
                miniatura = null;
            }
        }

        #region IDisposable Members

        /// <summary>
        /// Metoda usuwajaca bitmapy zdjecia z pamieci
        /// </summary>
        public void Dispose()
        {
            DisposeMini();
            DisposeDuze();
        }

        #endregion

        /// <summary>
        /// Metoda resetujaca identyfikator
        /// </summary>
        public void ResetujId() 
        {
            iiphotoTag = "brak";
        }

        /// <summary>
        /// Metoda odswiezajaca tagi zdjecia
        /// </summary>
        public void ResetujTagi()
        {
            WypelnijListeTagow();
        }

        /// <summary>
        /// Metoda usuwajaca zdjecie o podanym identyfikatorze z albumu
        /// </summary>
        /// <param name="id">Identyfikator zdjecia</param>
        internal static void UsunZAlbumu(long id)
        {
            Db baza = new Db();
            baza.Polacz();
            try
            {
                baza.Delete("TagZdjecia", "id_zdjecia=" + id + " and id_tagu in (select id_tagu from Tag where album=1)");

            }
            catch (SqlException ex)
            {
                MessageBox.Show("blad sql: " + ex.Message);
            }
            baza.Rozlacz();            
        }

        /// <summary>
        /// Metoda wywoluje DialogBox z pytaniem do uzytkownika czy ma zapisac zdjecie
        /// </summary>
        public RodzajDecyzji ZapisanieNiezapisanych()
        {
            DialogBoxes.CzyZapisac CzyZapisac = new Photo.DialogBoxes.CzyZapisac(this.Path);
            CzyZapisac.ShowDialog();
            RodzajDecyzji decyzja = CzyZapisac.Decyzja;
            CzyZapisac.Dispose();
            return decyzja;
        }
    }
}
<file_sep>
using System;
using System.Drawing;
using System.Drawing.Drawing2D;
using System.Drawing.Imaging;
using System.Windows.Forms;
using System.Collections.Generic;
using System.DirectoryServices;
using System.Reflection;

namespace Photo
{
    /// <summary>
    /// Klasa opisująca polecenie operacji graficznej.
    /// </summary>
    public class PolecenieOperacji
    {
        /// <summary>
        /// Obiekt klasy IOperacja, która zostanie użyta do wykonania operacji.
        /// </summary>
        private IOperacja Operacja;
        /// <summary>
        /// Stos argumentów dla wykonania operacji z pola Operacja.
        /// </summary>
        private Stack<object> Argumenty = new Stack<object>();

        /// <summary>
        /// </summary>
        /// <param name="Operacja">Operacja jaka ma być wykonana.</param>
        /// <param name="Argumenty">Lista argumentów dla operacji.</param>
        public PolecenieOperacji(IOperacja Operacja, object[] Argumenty)
        {
            this.Operacja = Operacja;
            foreach (object arg in Argumenty)
            {
                this.Argumenty.Push(arg);
            }
        }

        /// <summary>
        /// Powoduje wykonanie operacji opisanej przez to polecenie na bitmapie.
        /// </summary>
        /// <param name="bitmap">Bitmapa na której wykonywana jest operacja.</param>
        public void Wykonaj(Bitmap bitmap)
        {
            Operacja.Wykonaj(bitmap, Argumenty);
        }
    }

    public delegate void ZazadanieOperacjiDelegate(PolecenieOperacji polecenie);

    class Operacje
    {
        private List<IOperacja> operacje = new List<IOperacja>();
        public event ZazadanieOperacjiDelegate ZazadanieOperacji;

        public void WczytajPluginy()
        {
            Assembly asm = Assembly.LoadFile(System.IO.Path.GetFullPath("..\\..\\..\\Wyostrzenie\\bin\\Debug\\Wyostrzenie.dll"));
            foreach (Type type in asm.GetTypes())
            {
                ConstructorInfo ci = type.GetConstructor(new Type[] { });
                if (ci != null)
                {
                    IOperacja o = (IOperacja)ci.Invoke(new object[] { });
                    operacje.Add(o);
                }
            }
        }

        public void WczytajWbudowane()
        {
            operacje.Add(new XOR());
        }

        public void WrzucNaToolBar(ToolStrip tool)
        {
            foreach (IOperacja operacja in operacje)
            {
                ToolStripButton button = new ToolStripButton(operacja.NazwaOperacji, operacja.Ikona);
                button.Tag = operacja;
                button.Click += new EventHandler(button_Click);
                tool.Items.Add(button);
            }
        }

        void button_Click(object sender, EventArgs e)
        {
            ToolStripButton button = (ToolStripButton)sender;
            IOperacja operacja = (IOperacja)button.Tag;
            PolecenieOperacji polecenie = new PolecenieOperacji(operacja, operacja.PodajArgumenty().ToArray());
            ZazadanieOperacji(polecenie);
        }
    }

    class XOR : IOperacja
    {
        private int kodOperacji;

        #region IOperacja Members

        public string NazwaOperacji
        {
            get { return "XOR"; }
        }

        int IOperacja.KodOperacji
        {
            get
            {
                return kodOperacji;
            }
            set
            {
                kodOperacji = value;
            }
        }

        public Image Ikona
        {
            get
            {
                return new Bitmap("..\\..\\icons\\xor.png");
            }
        }

        public string Autor
        {
            get { throw new System.Exception("The method or operation is not implemented."); }
        }

        public string Wersja
        {
            get { throw new System.Exception("The method or operation is not implemented."); }
        }

        public string Kontakt
        {
            get { throw new System.Exception("The method or operation is not implemented."); }
        }

        public void Wykonaj(System.Drawing.Bitmap Bitmap, System.Collections.Generic.Stack<object> Argumenty)
        {
            Rectangle rect = new Rectangle(new Point(0, 0), Bitmap.Size);
            BitmapData bd = Bitmap.LockBits(rect, ImageLockMode.ReadWrite, Bitmap.PixelFormat);
            int bytes = bd.Width * bd.Height * 3;
            byte[] rgbValues = new byte[bytes];
            System.Runtime.InteropServices.Marshal.Copy(bd.Scan0, rgbValues, 0, bytes);
            for (int i = 0; i < bytes; i++)
            {
                rgbValues[i] = (byte)((int)rgbValues[i] ^ 0xff);
            }
            System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, bd.Scan0, bytes);
            Bitmap.UnlockBits(bd);
        }

        public Stack<object> PodajArgumenty()
        {
            return new Stack<object>();
        }

        #endregion
    }

    class Grayscale : IOperacja
    {
        #region IOperacja Members

        private int kodOperacji;

        public string NazwaOperacji
        {
            get { return "Grayscale"; }
        }

        public int KodOperacji
        {
            get
            {
                return kodOperacji;
            }
            set
            {
                kodOperacji = value;
            }
        }

        public Image Ikona
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public string Autor
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public string Wersja
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public string Kontakt
        {
            get { throw new Exception("The method or operation is not implemented."); }
        }

        public Stack<object> PodajArgumenty()
        {
            return new Stack<object>();
        }

        public void Wykonaj(Bitmap Bitmap, Stack<object> Argumenty)
        {
            BitmapData data;
            data = Bitmap.LockBits(new Rectangle(0, 0, Bitmap.Width, Bitmap.Height), ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
            unsafe
            {
                byte tempC;
                byte* imgPtr = (byte*)(data.Scan0);
                for (int i = 0; i < data.Height; i++)
                {
                    for (int j = 0; j < data.Width; j++)
                    {
                        tempC = (byte)(((int)*(imgPtr) + (int)*(imgPtr + 1) + (int)*(imgPtr + 2)) / 3);
                        *(imgPtr++) = tempC;
                        *(imgPtr++) = tempC;
                        *(imgPtr++) = tempC;
                    }
                }
            }
            Bitmap.UnlockBits(data);
        }

        #endregion
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Collections;

namespace WindowsApplication3
{
    public partial class Form1 : Form
    {
        private FileTree tr;

        public Form1()
        {
            InitializeComponent();
            Init_Tree();            
        }

        private void Init_Tree()
        {
            tr = new FileTree();            
            tr.Height = tabPage1.Height;
            tr.Width = tabPage1.Width;
            tr.Visible = true;
            tabPage1.Controls.Add(tr);  
            tr.AfterSelect += new TreeViewEventHandler(tr_AfterSelect);
            //this.toolStripComboBox1.Click += new System.EventHandler(this.toolStripComboBox1_Click);
        }

        private void toolStripContainer1_LeftToolStripPanel_Click(object sender, EventArgs e)
        {

        }

        

        private void zapiszToolStripMenuItem_Click(object sender, EventArgs e)
        {

        }

        private void contextMenuStrip1_Opening(object sender, CancelEventArgs e)
        {

        }

        private void toolStripComboBox1_Click(object sender, EventArgs e)
        {

        }

        private void treeView1_AfterSelect(object sender, TreeViewEventArgs e)
        {

        }
        private void tr_AfterSelect(object sender, TreeViewEventArgs e)
        {
            //MessageBox.Show(e.Node.ToString);//e.Node);
            MessageBox.Show(""+e.Node.FullPath); //sender.ToString
        }

       
    }

    
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.Data;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    public partial class InformacjeControl : UserControl
    {
        public InformacjeControl()
        {
            InitializeComponent();

            Tags.Columns.Add("Nazwa");
            Tags.Columns.Add("Wartość");
            Exif.Columns.Add("Nazwa");
            Exif.Columns.Add("Wartość");

            /*Tags.Items.Add(new ListViewItem(new string[] { "Brak","informacji"}));
            Exif.Items.Add(new ListViewItem(new string[] { "Brak","informacji"}));*/
        }

        public void Zaladuj(IZdjecie zdjecie)
        {
            Tags.Items.Clear();
            Exif.Items.Clear();
            if (zdjecie != null)
            {
                fillTags((Zdjecie)zdjecie);
                fillExif((Zdjecie)zdjecie);
            }
            else
            {
                Tags.Items.Add(new ListViewItem(new string[] { "Brak", "informacji" }));
                Exif.Items.Add(new ListViewItem(new string[] { "Brak", "informacji" }));
            }
        }

        private void fillExif(Zdjecie zdjecie)
        {
            Dictionary<string, int> d = PropertyTags.defaultExifIds;
            string propertyValue;

            foreach (KeyValuePair<string,int> kv in d)
            {
                propertyValue = zdjecie.GetProperty(kv.Value);
                if (!propertyValue.Equals(""))
                    Exif.Items.Add(new ListViewItem(new string[] { kv.Key, propertyValue }));
            }
        }

        private void fillTags(Zdjecie zdjecie)
        {
            Tags.Items.Add(new ListViewItem(new string[] { "Lokalizacja", zdjecie.Path.Substring(0, zdjecie.Path.LastIndexOf('\\') + 1) }));
            Tags.Items.Add(new ListViewItem(new string[] { "Nazwa", zdjecie.NazwaPliku }));
            Tags.Items.Add(new ListViewItem(new string[] { "Szerokość", zdjecie.Duze.Width.ToString() }));
            Tags.Items.Add(new ListViewItem(new string[] { "Wysokość", zdjecie.Duze.Height.ToString() }));
            Tags.Items.Add(new ListViewItem(new string[] { "Format", zdjecie.FormatPliku}));
        }

    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Text;

namespace Photo
{
    class PropertyTags
    {
        public const int GpsVer = 0;
        public const int GpsLatitudeRef = 1;
        public const int GpsLatitude = 2;
        public const int GpsLongitudeRef = 3;
        public const int GpsLongitude = 4;
        public const int GpsAltitudeRef = 5;
        public const int GpsAltitude = 6;
        public const int GpsGpsTime = 7;
        public const int GpsGpsSatellites = 8;
        public const int GpsGpsStatus = 9;
        public const int GpsGpsMeasureMode = 10;
        public const int GpsGpsDop = 11;
        public const int GpsSpeedRef = 12;
        public const int GpsSpeed = 13;
        public const int GpsTrackRef = 14;
        public const int GpsTrack = 15;
        public const int GpsImgDirRef = 16;
        public const int GpsImgDir = 17;
        public const int GpsMapDatum = 18;
        public const int GpsDestLatRef = 19;
        public const int GpsDestLat = 20;
        public const int GpsDestLongRef = 21;
        public const int GpsDestLong = 22;
        public const int GpsDestBearRef = 23;
        public const int GpsDestBear = 24;
        public const int GpsDestDistRef = 25;
        public const int GpsDestDist = 26;
        public const int NewSubfileType = 254;
        public const int SubfileType = 255;
        public const int ImageWidth = 256;
        public const int ImageHeight = 257;
        public const int BitsPerSample = 258;
        public const int Compression = 259;
        public const int PhotometricInterp = 262;
        public const int ThreshHolding = 263;
        public const int CellWidth = 264;
        public const int CellHeight = 265;
        public const int FillOrder = 266;
        public const int DocumentName = 269;
        public const int ImageDescription = 270;
        public const int EquipMake = 271;
        public const int EquipModel = 272;
        public const int StripOffsets = 273;
        public const int Orientation = 274;
        public const int SamplesPerPixel = 277;
        public const int RowsPerStrip = 278;
        public const int StripBytesCount = 279;
        public const int MinSampleValue = 280;
        public const int MaxSampleValue = 281;
        public const int XResolution = 282;
        public const int YResolution = 283;
        public const int PlanarConfig = 284;
        public const int PageName = 285;
        public const int XPosition = 286;
        public const int YPosition = 287;
        public const int FreeOffset = 288;
        public const int FreeByteCounts = 289;
        public const int GrayResponseUnit = 290;
        public const int GrayResponseCurve = 291;
        public const int T4Option = 292;
        public const int T6Option = 293;
        public const int ResolutionUnit = 296;
        public const int PageNumber = 297;
        public const int TransferFunction = 301;
        public const int SoftwareUsed = 305;
        public const int DateTime = 306;
        public const int Artist = 315;
        public const int HostComputer = 316;
        public const int Predictor = 317;
        public const int WhitePoint = 318;
        public const int PrimaryChromaticities = 319;
        public const int ColorMap = 320;
        public const int HalftoneHints = 321;
        public const int TileWidth = 322;
        public const int TileLength = 323;
        public const int TileOffset = 324;
        public const int TileByteCounts = 325;
        public const int InkSet = 332;
        public const int InkNames = 333;
        public const int NumberOfInks = 334;
        public const int DotRange = 336;
        public const int TargetPrinter = 337;
        public const int ExtraSamples = 338;
        public const int SampleFormat = 339;
        public const int SMinSampleValue = 340;
        public const int SMaxSampleValue = 341;
        public const int TransferRange = 342;
        public const int JPEGProc = 512;
        public const int JPEGInterFormat = 513;
        public const int JPEGInterLength = 514;
        public const int JPEGRestartInterval = 515;
        public const int JPEGLosslessPredictors = 517;
        public const int JPEGPointTransforms = 518;
        public const int JPEGQTables = 519;
        public const int JPEGDCTables = 520;
        public const int JPEGACTables = 521;
        public const int YCbCrCoefficients = 529;
        public const int YCbCrSubsampling = 530;
        public const int YCbCrPositioning = 531;
        public const int REFBlackWhite = 532;
        public const int Gamma = 769;
        public const int ICCProfileDescriptor = 770;
        public const int SRGBRenderingIntent = 771;
        public const int ImageTitle = 800;
        public const int ResolutionXUnit = 20481;
        public const int ResolutionYUnit = 20482;
        public const int ResolutionXLengthUnit = 20483;
        public const int ResolutionYLengthUnit = 20484;
        public const int PrintFlags = 20485;
        public const int PrintFlagsVersion = 20486;
        public const int PrintFlagsCrop = 20487;
        public const int PrintFlagsBleedWidth = 20488;
        public const int PrintFlagsBleedWidthScale = 20489;
        public const int HalftoneLPI = 20490;
        public const int HalftoneLPIUnit = 20491;
        public const int HalftoneDegree = 20492;
        public const int HalftoneShape = 20493;
        public const int HalftoneMisc = 20494;
        public const int HalftoneScreen = 20495;
        public const int JPEGQuality = 20496;
        public const int GridSize = 20497;
        public const int ThumbnailFormat = 20498;
        public const int ThumbnailWidth = 20499;
        public const int ThumbnailHeight = 20500;
        public const int ThumbnailColorDepth = 20501;
        public const int ThumbnailPlanes = 20502;
        public const int ThumbnailRawBytes = 20503;
        public const int ThumbnailSize = 20504;
        public const int ThumbnailCompressedSize = 20505;
        public const int ColorTransferFunction = 20506;
        public const int ThumbnailData = 20507;
        public const int ThumbnailImageWidth = 20512;
        public const int ThumbnailImageHeight = 20513;
        public const int ThumbnailBitsPerSample = 20514;
        public const int ThumbnailCompression = 20515;
        public const int ThumbnailPhotometricInterp = 20516;
        public const int ThumbnailImageDescription = 20517;
        public const int ThumbnailEquipMake = 20518;
        public const int ThumbnailEquipModel = 20519;
        public const int ThumbnailStripOffsets = 20520;
        public const int ThumbnailOrientation = 20521;
        public const int ThumbnailSamplesPerPixel = 20522;
        public const int ThumbnailRowsPerStrip = 20523;
        public const int ThumbnailStripBytesCount = 20524;
        public const int ThumbnailResolutionX = 20525;
        public const int ThumbnailResolutionY = 20526;
        public const int ThumbnailPlanarConfig = 20527;
        public const int ThumbnailResolutionUnit = 20528;
        public const int ThumbnailTransferFunction = 20529;
        public const int ThumbnailSoftwareUsed = 20530;
        public const int ThumbnailDateTime = 20531;
        public const int ThumbnailArtist = 20532;
        public const int ThumbnailWhitePoint = 20533;
        public const int ThumbnailPrimaryChromaticities = 20534;
        public const int ThumbnailYCbCrCoefficients = 20535;
        public const int ThumbnailYCbCrSubsampling = 20536;
        public const int ThumbnailYCbCrPositioning = 20537;
        public const int ThumbnailRefBlackWhite = 20538;
        public const int ThumbnailCopyRight = 20539;
        public const int LuminanceTable = 20624;
        public const int ChrominanceTable = 20625;
        public const int FrameDelay = 20736;
        public const int LoopCount = 20737;
        public const int GlobalPalette = 20738;
        public const int IndexBackground = 20739;
        public const int IndexTransparent = 20740;
        public const int PixelUnit = 20752;
        public const int PixelPerUnitX = 20753;
        public const int PixelPerUnitY = 20754;
        public const int PaletteHistogram = 20755;
        public const int Copyright = 33432;
        public const int ExifExposureTime = 33434;
        public const int ExifFNumber = 33437;
        public const int ExifIFD = 34665;
        public const int ICCProfile = 34675;
        public const int ExifExposureProg = 34850;
        public const int ExifSpectralSense = 34852;
        public const int GpsIFD = 34853;
        public const int ExifISOSpeed = 34855;
        public const int ExifOECF = 34856;
        public const int ExifVer = 36864;
        public const int ExifDTOrig = 36867;
        public const int ExifDTDigitized = 36868;
        public const int ExifCompConfig = 37121;
        public const int ExifCompBPP = 37122;
        public const int ExifShutterSpeed = 37377;
        public const int ExifAperture = 37378;
        public const int ExifBrightness = 37379;
        public const int ExifExposureBias = 37380;
        public const int ExifMaxAperture = 37381;
        public const int ExifSubjectDist = 37382;
        public const int ExifMeteringMode = 37383;
        public const int ExifLightSource = 37384;
        public const int ExifFlash = 37385;
        public const int ExifFocalLength = 37386;
        public const int ExifMakerNote = 37500;
        public const int ExifUserComment = 37510;
        public const int ExifDTSubsec = 37520;
        public const int ExifDTOrigSS = 37521;
        public const int ExifDTDigSS = 37522;
        public const int Title = 40091;
        public const int Comments = 40092;
        public const int Author = 40093;
        public const int Keywords = 40094;
        public const int Subject = 40095;
        public const int IIPhotoTag = 40096;
        public const int ExifFPXVer = 40960;
        public const int ExifColorSpace = 40961;
        public const int ExifPixXDim = 40962;
        public const int ExifPixYDim = 40963;
        public const int ExifRelatedWav = 40964;
        public const int ExifInterop = 40965;
        public const int ExifFlashEnergy = 41483;
        public const int ExifSpatialFR = 41484;
        public const int ExifFocalXRes = 41486;
        public const int ExifFocalYRes = 41487;
        public const int ExifFocalResUnit = 41488;
        public const int ExifSubjectLoc = 41492;
        public const int ExifExposureIndex = 41493;
        public const int ExifSensingMethod = 41495;
        public const int ExifFileSource = 41728;
        public const int ExifSceneType = 41729;
        public const int ExifCfaPattern = 41730;

        private PropertyTags() { }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Data.SQLite;
using System.Data.SqlClient;

namespace Photo
{
    /// <summary>
    /// Klasa tworząca formatka do dodawania albumu do drzewa albumów
    /// </summary>
    public partial class Dodaj_Album : Form
    {
        private ListaAlbumowControl listaAlbumow;

        /// <summary>
        /// Konstruktor
        /// </summary>
        public Dodaj_Album(ListaAlbumowControl la)
        {
            InitializeComponent();
            listaAlbumow = la;
        }

        /// <summary>
        /// Metoda dodająca nazwe albumu do bazy
        /// </summary>
        private void DodajAlbumDoBazy()
        {
            string nazwa;

            if (textBox1.Text != "" && textBox1.Text.Length < 100)
            {
                nazwa = textBox1.Text;

                Db baza = new Db();

                baza.Polacz();

                try
                {
                    baza.Insert_czesci("Tag", "nazwa,album", "\'" + nazwa + "\',1");

                    listaAlbumow.lista_nazw_albumow.Add(nazwa);

                    DataSet ds = baza.Select("select max(id_tagu) from Tag where nazwa=\'" + nazwa + "\' and album=1");

                    foreach (DataTable t in ds.Tables)
                    {
                        foreach (DataRow r in t.Rows)
                        {
                            if (!(r[0] is DBNull))
                            {
                                listaAlbumow.lista_albumow.Add((Int64)r[0]);
                            }
                        }
                    }

                }
                catch (SQLiteException)
                {
                    MessageBox.Show("Taka Nazwa Albumu juz instnieje");
                }

                baza.Rozlacz();

                listaAlbumow.odswiez();

                this.Dispose();
            }
            else if (textBox1.Text == "")
            {
                MessageBox.Show("Wpisz nazwe albumu");                
            }
            else
            {
                MessageBox.Show("Za długa nazwa");
            }

        }

        /// <summary>
        /// Metoda wykonywana po kliknięciu przycisku zatwierdzającego("OK" lub nacisniecie "ENTER"). Uruchamia metody dodawania albumu
        /// </summary>
        private void button1_Click(object sender, EventArgs e)
        {
            DodajAlbumDoBazy();            
        }

        /// <summary>
        /// Metoda wywołuje metode DodajAlbumDoBazy gdy użytkownik naciśnie Enter. Uruchamia metody dodawania albumu
        /// </summary>
        private void textBox1_KeyPress(object sender, KeyPressEventArgs e)
        {
            Keys k = (Keys)e.KeyChar;
            if (k == Keys.Enter)
            {
                DodajAlbumDoBazy();
            }
        }
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    public partial class ListaMiniaturControl : UserControl, IOpakowanieZdjec, IKontekst
    {
        public ListaMiniaturControl()
        {
            InitializeComponent();
        }

        private void miniatura_Click(object sender, EventArgs e)
        {
            listBox1.Items.Insert(0, System.Reflection.MethodInfo.GetCurrentMethod().ToString());
            if (WybranoZdjecie != null)
                WybranoZdjecie((IZdjecie)sender);
        }

        public void RozmiescZdjecia()
        {
            flowLayoutPanel1.Controls.Clear();
            foreach (IZdjecie zdjecie in zdjecia)
            {
                flowLayoutPanel1.Controls.Add((MiniaturaControl)zdjecie);
            }
            flowLayoutPanel1.Invalidate();
        }

        private bool Edycja;

        #region OpakowanieZdjec Members

        public event WybranoZdjecieDelegate WybranoZdjecie;

        private List<MiniaturaControl> zdjecia = new List<MiniaturaControl>();

        public IZdjecie this[int numer]
        {
            get
            {
                return zdjecia[numer];
            }
        }

        public int Ilosc
        {
            get
            {
                return zdjecia.Count;
            }
        }

        public void Dodaj(IZdjecie zdjecie)
        {
            MiniaturaControl mini = new MiniaturaControl(zdjecie);
            Dodaj(mini);
        }

        public void Dodaj(MiniaturaControl zdjecie)
        {
            DodajDoKontekstu(zdjecie);
            zdjecie.Click += new EventHandler(miniatura_Click);
            zdjecia.Add(zdjecie);
        }

        public void Usun(IZdjecie zdjecie)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public void Oproznij()
        {
            zdjecia.Clear();
            RozmiescZdjecia();
        }

        public void RozpocznijEdycje()
        {
            listBox1.Items.Insert(0, System.Reflection.MethodInfo.GetCurrentMethod().ToString());
            Edycja = true;
        }

        public void ZakonczEdycje()
        {
            Edycja = false;
            foreach (IZdjecie zdjecie in zdjecia)
            {
                zdjecie.WykonajOperacje();
                zdjecie.UsunWszystkieOperacje();
            }
            listBox1.Items.Insert(0, System.Reflection.MethodInfo.GetCurrentMethod().ToString());
        }

        public void DodajOperacje(PolecenieOperacji operacja)
        {
            listBox1.Items.Insert(0, System.Reflection.MethodInfo.GetCurrentMethod().ToString());
            if (Edycja == false)
            {
                RozpocznijEdycje();
                foreach (IZdjecie zdjecie in zdjecia)
                {
                    zdjecie.DodajOperacje(operacja);
                }
                ZakonczEdycje();
            }
            else
            {
                foreach (IZdjecie zdjecie in zdjecia)
                {
                    zdjecie.DodajOperacje(operacja);
                }
            }
        }

        public void UsunWszystkieOperacje()
        {
            foreach (IZdjecie zdjecie in zdjecia)
            {
                zdjecie.UsunWszystkieOperacje();
            }
        }

        public IZdjecie[] WybraneZdjecia()
        {
            return new IZdjecie[] { };
        }

        public void Wypelnij(IZdjecie[] zdjecia)
        {
            listBox1.Items.Insert(0, System.Reflection.MethodInfo.GetCurrentMethod().ToString());
            Oproznij();
            foreach (IZdjecie zdjecie in zdjecia)
            {
                Dodaj((MiniaturaControl)zdjecie);
            }
            RozmiescZdjecia();
            if (WybranoZdjecie != null)
                WybranoZdjecie(null);
        }

        #endregion

        #region IKontekst Members

        public void DodajDoKontekstu(IZdjecie zdjecie)
        {
            zdjecie.ZmodyfikowanoZdjecie += new ZmodyfikowanoZdjecieDelegate(ZmodyfikowanoZdjecie);
        }

        public void UsunZKontekstu(IZdjecie zdjecie)
        {
            zdjecie.ZmodyfikowanoZdjecie -= new ZmodyfikowanoZdjecieDelegate(ZmodyfikowanoZdjecie);
        }

        public void ZmodyfikowanoZdjecie(IKontekst kontekst, IZdjecie zdjecie, RodzajModyfikacjiZdjecia rodzaj)
        {
            listBox1.Items.Insert(0, System.Reflection.MethodInfo.GetCurrentMethod().ToString());
            Invalidate(true);
        }

        #endregion
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Drawing;
using System.Text;

namespace Photo
{
    public class Miniatura : IMiniatura
    {
        Bitmap bitmap;
        List<PolecenieOperacji> operacje = new List<PolecenieOperacji>();

        public MiniaturaTag tag;

        public Miniatura()
        {
        }

        public Miniatura(string filename) : this()
        {
            this.bitmap = new Bitmap(filename);
        }

        public Bitmap Bitmap
        {
            set
            {
                bitmap.Tag = this;
                bitmap = Bitmap;
            }
            get
            {
                return bitmap;
            }
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;

namespace Properties
{
    class MyBitmap
    {
        public Bitmap image;

        public MyBitmap(string fileName)
        {
            image = new Bitmap(fileName);
        }

        public void Save(string ImgName, ImageFormat format)
        {
            image.Save(ImgName, format);
        }

        public void Dispose()
        {
            image.Dispose();
        }

        public void SetIIPhotoProperty(string value) {
            System.Text.ASCIIEncoding encoding = new System.Text.ASCIIEncoding();
            PropertyItem propItem = image.PropertyItems[0];
            propItem.Id = PropertyTags.IIPhotoTag;
            propItem.Type = 2;
            propItem.Value = encoding.GetBytes(value);
            propItem.Len = propItem.Value.Length;
            image.SetPropertyItem(propItem);
        }

        public string GetProperty(int propID) {
            PropertyItem i;
            try
            {
                string val;
                i = image.GetPropertyItem(propID);
                switch (i.Type)
                {
                    case 1: val = Encoding.Unicode.GetString(i.Value); break;
                    case 2: val = Encoding.ASCII.GetString(i.Value); break;
                    case 3: val = BitConverter.ToUInt16(i.Value, 0).ToString(); break;
                    default: val = "Value not supported"; break;
                }
                return val;
            }
            catch
            {
                return "";
            } 
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace Photo
{
    public class Config
    {
        string katalogDanychIIPhoto;

        string plikBazyDanych;

        public Config()
        {
            plikBazyDanych = "iiphoto.db3";
            katalogDanychIIPhoto = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\IIPhoto";
            if (!Directory.Exists(katalogDanychIIPhoto))
            {
                DirectoryInfo di = Directory.CreateDirectory(katalogDanychIIPhoto);
            }
        }

        public string katalogDanych 
        {
            get
            {
                return katalogDanychIIPhoto;
            }
        }

        public string plikBazy
        {
            get
            {
                return plikBazyDanych;
            }
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    public partial class DrzewoOpakowane : UserControl
    {
        public DrzewoOpakowane()
        {
            InitializeComponent();
        }               

        private void button1_Click_1(object sender, EventArgs e)
        {
            fileTree1.Delete();
            fileTree1.Fill();  
        }
    }
}
<file_sep>using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Collections.Generic;
using System.Text;
//using Photo;

namespace Wyostrzenie
{
    /// <summary>
    /// Prykładowa implementacja operacji graficznej.
    /// Do referencji projektu należy dołączyć plik exe programu przeglądarki.
    /// Następnie należy zaimplementować interfejs GUI.IOperacja.
    /// </summary>
    public class Wyostrzenie : Photo.IOperacja
    {
        private int kodOperacji;

        #region IOperacja Members

        public string NazwaOperacji
        {
            get { return "Wyostrzenie"; }
        }

        int Photo.IOperacja.KodOperacji
        {
            get
            {
                return kodOperacji;
            }
            set
            {
                kodOperacji = value;
            }
        }

        public Image Ikona
        {
            get
            {
                return Properties.Resources.filtr;
            }
        }

        public string Autor
        {
            get { throw new System.Exception("The method or operation is not implemented."); }
        }

        public string Wersja
        {
            get { throw new System.Exception("The method or operation is not implemented."); }
        }

        public string Kontakt
        {
            get { throw new System.Exception("The method or operation is not implemented."); }
        }

        public void Wykonaj(Photo.Zdjecie z, System.Collections.Generic.Stack<object> Argumenty)
        {
            if (z.Zaznaczenie.IsEmpty)
            {
                Photo.BitmapFilter.Sharpen(z.Duze, 10);
            }
            else
            {
                if (z.Zaznaczenie.Width < 0)
                {
                    z.Zaznaczenie.X += z.Zaznaczenie.Width;
                    z.Zaznaczenie.Width *= -1;
                }
                if (z.Zaznaczenie.Height < 0)
                {
                    z.Zaznaczenie.Y += z.Zaznaczenie.Height;
                    z.Zaznaczenie.Height *= -1;
                }
                Bitmap sharpened = new Bitmap(Math.Abs(z.Zaznaczenie.Width), Math.Abs(z.Zaznaczenie.Height), z.Duze.PixelFormat);
                Graphics g = Graphics.FromImage(sharpened);
                g.DrawImage(z.Duze, new Rectangle(0, 0, sharpened.Width, sharpened.Height), z.Zaznaczenie, GraphicsUnit.Pixel);
                g.Dispose();
                Photo.BitmapFilter.Sharpen(sharpened, 10);
                g = Graphics.FromImage(z.Duze);
                g.DrawImage(sharpened, z.Zaznaczenie);
                g.Dispose();
            }
        }

        public Stack<object> PodajArgumenty()
        {
            return new Stack<object>();
        }

        public bool CzyNaToolbar()
        {
            return false;
        }

        #endregion
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.IO;
using System.Collections;
using Photo;

namespace Photo
{
    public class FileTree : TreeView, IWyszukiwacz
    {
        public FileTree()
        {
            GenerateImage();
            //Fill();
            this.BackColor = Color.Beige;
        }

        public void GenerateImage()
        {
            ImageList list = new ImageList();
            list.Images.Add(Properties.Resources.Dysk);
            list.Images.Add(Properties.Resources.folder);
            list.Images.Add(Properties.Resources.Dyskietka);
            list.Images.Add(Properties.Resources.Cdrom);
            list.Images.Add(Properties.Resources.Cdrom_z);
            list.Images.Add(Properties.Resources.Dyskietka_z);
            ImageList = list;
        }

        public void Fill()
        {
            BeginUpdate();
            string[] drives = Directory.GetLogicalDrives();

            //string[] tempString = Directory.GetLogicalDrives();

            //DriveInfo tempInfo = new DriveInfo("", 0, "My Computer");
            //availableDrives.Add(tempInfo);

            foreach (string tempDrive in drives)
            {
                /* int tempType = getDriveType(tempDrive);
                 string tempName = GetDriveName(tempDrive);
                 tempInfo = new DriveInfo(tempDrive, tempType, tempName);
                 availableDrives.Add(tempInfo);
                 */
                //string tempName = GetDriveName(tempDrive);

                DirTreeNode dn = new DirTreeNode(tempDrive);

                //dn.Text = tempName + "(" + tempDrive + ")";
                Nodes.Add(dn);

            }

            //Directory.g

            //for (int i = 0; i < drives.Length; i++)
            //{
            //drives[i].GetType

            //}
            EndUpdate();

            BeforeExpand += new TreeViewCancelEventHandler(prepare);
            AfterCollapse += new TreeViewEventHandler(clear);
        }

        public void Open(string path)
        {
            TreeNodeCollection nodes = Nodes;
            DirTreeNode subnode = null;
            int i, n;



            path = path.ToLower();
            nodes = Nodes;
            while (nodes != null)
            {
                n = nodes.Count;
                for (i = 0; i < n; i++)
                {
                    subnode = (DirTreeNode)nodes[i];
                    if (path == subnode.Path)
                    {
                        subnode.Expand();
                        return;
                    }
                    if (path.StartsWith(subnode.Path))
                    {
                        subnode.Expand();
                        break;
                    }
                }
                if (i == n)
                    return;
                nodes = subnode.Nodes;
            }
        }
        void prepare(object sender, TreeViewCancelEventArgs e)
        {
            BeginUpdate();
            DirTreeNode tn = (DirTreeNode)e.Node;
            try
            {
                tn.populate();
                EndUpdate();
            }
            catch (Exception ex)
            {

                MessageBox.Show(ex.Message);
                //tn.Nodes.Add(new TreeNode());
                //tn.Nodes.Clear();
                tn.Collapse();
                //tn.Parent.Collapse();
                //tn.Nodes.Clear();
                tn.Collapse();
                e.Node.Remove();
                //tn.
                //Nodes.Add(tn);
                Nodes.Insert(tn.Index, tn);


                EndUpdate();

            }
        }
        void clear(object sender, TreeViewEventArgs e)
        {
            BeginUpdate();
            DirTreeNode tn = (DirTreeNode)e.Node;
            tn.setLeaf(true);
            EndUpdate();
        }

        public void Delete()
        {
            BeginUpdate();
            Nodes.RemoveAt(0);
            Nodes.Clear();
            EndUpdate();
        }

        public class DirTreeNode : TreeNode
        {
            string path;
            int type;
            public virtual string Path { get { return path; } }

            public DirTreeNode(string s)
                : base(s)
            {
                if (s.CompareTo("A:\\") == 0 || s.CompareTo("B:\\") == 0)
                {
                    //dn = new DirTreeNode(tempDrive, tempDrive + " [Floppy]");
                    // if (GetDriveName(s) != "")
                    //{
                    // Text = s + " [Floppy]";
                    //Text = s + " [" + GetDriveName(s) + "]";
                    // ImageIndex = Dyskietka_z;
                    // SelectedImageIndex = Dyskietka_z;
                    // }
                    // else
                    // {
                    Text = s + " [Floppy]";
                    ImageIndex = Dyskietka;
                    SelectedImageIndex = Dyskietka;
                    // }                    
                }
                else
                {
                    Text = s + " [" + GetDriveName(s) + "]";
                    //dn = new DirTreeNode(tempDrive, tempDrive + " [" + GetDriveName(tempDrive) + "]");
                    if (GetDriveName(s) != "" && getDriveType(s) == Cdrom)
                    {
                        ImageIndex = Cdrom_z;
                        SelectedImageIndex = Cdrom_z;
                    }
                    else
                    {
                        ImageIndex = getDriveType(s);
                        SelectedImageIndex = getDriveType(s);
                    }
                }

                path = s.ToLower();
                setLeaf(true);
                //type = Dysk;
                //ImageIndex = type;
                //SelectedImageIndex = type;
            }
            public DirTreeNode(string s, string label)
                : this(s)
            {
                Text = label;
            }
            public DirTreeNode(string s, int aType)
                : base(new FileInfo(s).Name)
            {
                path = s.ToLower();
                type = aType;
                ImageIndex = type;
                SelectedImageIndex = type;
                try
                {
                    string[] n = Directory.GetDirectories(path);

                    if (type == FOLDER && n.Length != 0)
                        setLeaf(true);
                }
                catch (Exception)
                {
                }
            }

            const int Dysk = 0;
            const int FOLDER = 1;
            const int Dyskietka = 2;
            const int Cdrom = 3;
            const int Cdrom_z = 4;
            const int Dyskietka_z = 5;

            //private IWyszukiwanie Wsad;




            [DllImport("kernel32.dll")]
            public static extern long GetDriveType(string driveLetter);
            [DllImport("Kernel32.dll", CharSet = CharSet.Auto, SetLastError = true)]
            extern static bool GetVolumeInformation(
                                    string RootPathName,
                                    StringBuilder VolumeNameBuffer,
                                    int VolumeNameSize,
                                    out uint VolumeSerialNumber,
                                    out uint MaximumComponentLength,
                                    out uint FileSystemFlags,
                                    StringBuilder FileSystemNameBuffer,
                                    int nFileSystemNameSize);



            public int getDriveType(string drive)
            {
                if ((GetDriveType(drive) & 5) == 5) return Cdrom;//cd
                if ((GetDriveType(drive) & 3) == 3) return Dysk;//fixed
                if ((GetDriveType(drive) & 2) == 2) return Dysk;//removable
                if ((GetDriveType(drive) & 4) == 4) return Dyskietka;//remote disk
                if ((GetDriveType(drive) & 6) == 6) return Dyskietka;//ram disk
                return 0;
            }

            public string GetDriveName(string drive)
            {
                //receives volume name of drive
                StringBuilder volname = new StringBuilder(256);
                //receives serial number of drive,not in case of network drive(win95/98)
                uint sn;
                uint maxcomplen;//receives maximum component length
                uint sysflags;//receives file system flags
                StringBuilder sysname = new StringBuilder(256);//receives the file system name
                bool retval;//return value

                retval = GetVolumeInformation(drive, volname, 256, out sn, out maxcomplen,
                                              out sysflags, sysname, 256);

                if (retval == true) return volname.ToString();
                else return "";
            }

            public string Etykieta(string drive)
            {
                return GetDriveName(drive);
            }

            internal void populate()
            {
                ArrayList folder = new ArrayList();

                //string

                string[] files = Directory.GetDirectories(Path);
                Array.Sort(files);

                if (files.Length == 0 && type == Dysk)
                    return;

                for (int i = 0; i < files.Length; i++)
                {
                    folder.Add(new DirTreeNode(files[i], FOLDER));
                }

                Nodes.Clear();
                foreach (DirTreeNode dtn in folder)
                {
                    Nodes.Add(dtn);
                }

                //wyjate


            }

            bool isLeaf = true;
            internal void setLeaf(bool b)
            {
                Nodes.Clear();
                isLeaf = b;
                if (IsExpanded)
                    return;
                if (!isLeaf)
                    return;
                Nodes.Add(new TreeNode());
            }

        }

        #region IWyszukiwacz Members

        public IWyszukiwanie Wyszukaj()
        {
            throw new Exception("The method or operation is not implemented.");
        }

        public event ZakonczonoWyszukiwanieDelegate ZakonczonoWyszukiwanie;
        public event ZnalezionoZdjecieDelegate ZnalezionoZdjecie;
        public event RozpoczetoWyszukiwanieDelegate RozpoczetoWyszukiwanie;

        #endregion


        protected override void OnBeforeSelect(TreeViewCancelEventArgs e)
        {
            base.OnBeforeSelect(e);
            //MessageBox.Show("numer: " + e.Node.SelectedImageIndex);

        }

        protected override void OnAfterSelect(TreeViewEventArgs e)
        {
            base.OnAfterSelect(e);

            if (RozpoczetoWyszukiwanie != null)
                RozpoczetoWyszukiwanie(null);

            BackgroundWorker bw = new BackgroundWorker();
            bw.WorkerReportsProgress = true;
            bw.DoWork += new DoWorkEventHandler(bw_DoWork);
            bw.ProgressChanged += new ProgressChangedEventHandler(bw_ProgressChanged);
            bw.RunWorkerCompleted += new RunWorkerCompletedEventHandler(bw_RunWorkerCompleted);
            bw.RunWorkerAsync(e.Node);

            DirTreeNode dn = new DirTreeNode("napis");

            if (e.Node.Text.IndexOf("A:\\") == 0 && e.Node.Text.LastIndexOf("\\") < 4)
            {
                e.Node.Text = "A:\\ " + "[" + dn.Etykieta(e.Node.Text.Substring(0, 3)) + "]";
                e.Node.ImageIndex = 5;
                e.Node.SelectedImageIndex = 5;
            }
            else if (e.Node.Text.IndexOf("B:\\") == 0 && e.Node.Text.LastIndexOf("\\") < 4)
            {
                e.Node.Text = "B:\\ " + "[" + dn.Etykieta(e.Node.Text.Substring(0, 3)) + "]";
                e.Node.ImageIndex = 5;
                e.Node.SelectedImageIndex = 5;
            }
        }

        void bw_ProgressChanged(object sender, ProgressChangedEventArgs e)
        {
            if (ZnalezionoZdjecie != null)
                ZnalezionoZdjecie((Zdjecie)e.UserState);
        }

        void bw_RunWorkerCompleted(object sender, RunWorkerCompletedEventArgs e)
        {
            if (ZakonczonoWyszukiwanie != null)
            {
                ZakonczonoWyszukiwanie((IZdjecie[])e.Result);
            }
            
            this.Refresh();
        }

        void bw_DoWork(object sender, DoWorkEventArgs args)
        {
            DirTreeNode Node = (DirTreeNode)args.Argument;
            BackgroundWorker bw = sender as BackgroundWorker;
            args.Result = ZnajdzPlikiWKatalogu(bw, Node);
        }

        private Zdjecie[] ZnajdzPlikiWKatalogu(BackgroundWorker bw, DirTreeNode Node)
        {
            List<Zdjecie> zdjecia = new List<Zdjecie>();

            try
            {
                string[] files = Directory.GetFiles(Node.Path, "*.jpg");
                string[] files2 = Directory.GetFiles(Node.Path, "*.jpeg");
                string[] files3 = Directory.GetFiles(Node.Path, "*.tif");
                string[] files4 = Directory.GetFiles(Node.Path, "*.tiff");

                string[] f1 = new string[files.Length];
                string[] f2 = new string[files2.Length];
                string[] f3 = new string[files3.Length];
                string[] f4 = new string[files4.Length];


                int i = 0;

                int z_f1 = 0;
                for (i = 0; i < files.Length; i++)
                {
                    if (files[i].ToLower().LastIndexOf(".jpg") == (files[i].Length - 4))
                    {
                        f1[z_f1] = files[i];
                        z_f1++;
                    }
                }
                int z_f2 = 0;
                for (i = 0; i < files2.Length; i++)
                {
                    //string str = files2[i].ToLower();
                    if (files2[i].ToLower().LastIndexOf(".jpeg") == (files2[i].Length - 5))
                    {
                        f2[z_f2] = files2[i];
                        z_f2++;
                    }
                }
                int z_f3 = 0;
                for (i = 0; i < files3.Length; i++)
                {
                    if (files3[i].ToLower().LastIndexOf(".tif") == (files3[i].Length - 4))
                    {
                        f3[z_f3] = files3[i];
                        z_f3++;
                    }
                }

                int z_f4 = 0;
                for (i = 0; i < files4.Length; i++)
                {
                    if (files4[i].ToLower().LastIndexOf(".tiff") == (files4[i].Length - 5))
                    {
                        f4[z_f4] = files4[i];
                        z_f4++;
                    }
                }

                zdjecia = new List<Zdjecie>(z_f1 + z_f2 + z_f3 + z_f4);

                int ile = 0;
                for (i = 0; i < z_f1; i++)
                {
                    try
                    {
                        Zdjecie z = new Zdjecie(f1[i]);
                        bw.ReportProgress(0, z);
                        zdjecia.Add(z);
                    }
                    catch (ArgumentException)
                    {
                        //MessageBox.Show("testowo: plik nie jest w poprawnym formacie ");
                        MessageBox.Show("Plik: \"" + files[i].Substring(files[i].LastIndexOf("\\") + 1) + "\" mimo poprawnego rozszezenie nie zawiera zdjÍcia", files[i], MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    }
                }
                ile = i;
                for (i = 0; i < z_f2; i++)
                {
                    try
                    {
                        Zdjecie z = new Zdjecie(f2[i]);
                        bw.ReportProgress(0, z);
                        zdjecia.Add(z);
                    }
                    catch (ArgumentException)
                    {
                        //MessageBox.Show("testowo: plik nie jest w poprawnym formacie ");

                        MessageBox.Show("Plik: \"" + files2[i].Substring(files2[i].LastIndexOf("\\") + 1) + "\" mimo poprawnego rozszezenie nie zawiera zdjÍcia", files2[i], MessageBoxButtons.OK, MessageBoxIcon.Warning);

                    }
                }
                ile += i;
                for (i = 0; i < z_f3; i++)
                {
                    try
                    {
                        Zdjecie z = new Zdjecie(f3[i]);
                        bw.ReportProgress(0, z);
                        zdjecia.Add(z);
                    }
                    catch (ArgumentException)
                    {
                        //MessageBox.Show("testowo: plik nie jest w poprawnym formacie ");
                        MessageBox.Show("Plik: \"" + files3[i].Substring(files3[i].LastIndexOf("\\") + 1) + "\" mimo poprawnego rozszezenie nie zawiera zdjÍcia", files3[i], MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    }
                }
                ile += i;
                for (i = 0; i < z_f4; i++)
                {
                    try
                    {
                        Zdjecie z = new Zdjecie(f4[i]);
                        bw.ReportProgress(0, z);
                        zdjecia.Add(z);
                    }
                    catch (ArgumentException)
                    {
                        //MessageBox.Show("testowo: plik nie jest w poprawnym formacie ");
                        MessageBox.Show("Plik: \"" + files4[i].Substring(files4[i].LastIndexOf("\\") + 1) + "\" mimo poprawnego rozszezenie nie zawiera zdjÍcia", files4[i], MessageBoxButtons.OK, MessageBoxIcon.Warning);
                    }
                }
            }
            catch (Exception e)
            {
                MessageBox.Show(e.Message + " - Odmowa dostÍpu", Node.Text, MessageBoxButtons.OK, MessageBoxIcon.Error);
                /*if (e.Node.Text.Length == 3)
                {
                    if (e.Node.Text.CompareTo("A:\\") == 0 || e.Node.Text.CompareTo("B:\\") == 0 )
                    {

                    }
                    MessageBox.Show("numer: "+e.Node.SelectedImageIndex);
                    //e.Node.ImageIndex = getDriveType(e.Node.Text);

                    this.Refresh();
                    //this.


                }*/

                DirTreeNode dd = new DirTreeNode("napis");

                this.SelectedNode = dd;


            }

            return zdjecia.ToArray();
        }

        protected override void OnAfterExpand(TreeViewEventArgs e)
        {
            base.OnAfterExpand(e);


            DirTreeNode dn = new DirTreeNode("napis");

            if (e.Node.Text.IndexOf("A:\\") == 0 && e.Node.Text.LastIndexOf("\\") < 4)
            {
                e.Node.Text = "A:\\ " + "[" + dn.Etykieta(e.Node.Text.Substring(0, 3)) + "]";
                e.Node.ImageIndex = 5;
                e.Node.SelectedImageIndex = 5;
            }
            else if (e.Node.Text.IndexOf("B:\\") == 0 && e.Node.Text.LastIndexOf("\\") < 4)
            {
                e.Node.Text = "B:\\ " + "[" + dn.Etykieta(e.Node.Text.Substring(0, 3)) + "]";
                e.Node.ImageIndex = 5;
                e.Node.SelectedImageIndex = 5;
            }
        }

        private void InitializeComponent()
        {
            this.SuspendLayout();
            // 
            // FileTree
            // 
            this.LabelEdit = true;
            this.ResumeLayout(false);

        }
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Data;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    public partial class WyszukiwarkaControl : UserControl, IWyszukiwacz
    {
        public WyszukiwarkaControl()
        {
            InitializeComponent();
        }

        public IWyszukiwacz wyszukiwacz_albumow;

        private void button1_Click(object sender, EventArgs e)
        {
            Wyszukiwanie wynik = new Wyszukiwanie();
            if (checkBox1.Checked)
            {
                wynik.And(wyszukiwacz_albumow.Wyszukaj());
            }
            wynik.And(Wyszukaj());
            if (ZakonczonoWyszukiwanie != null)
            {
                ZakonczonoWyszukiwanie(wynik.PodajWynik());
            }
        }

        #region Wyszukiwacz Members

        public event ZakonczonoWyszukiwanieDelegate ZakonczonoWyszukiwanie;

        public IWyszukiwanie Wyszukaj()
        {
            Wyszukiwanie wynik = new Wyszukiwanie();
            wynik.And("..\\..\\img\\wyszuk1.bmp");
            return wynik;
        }

        #endregion
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Text;
using System.IO;

namespace Photo
{
    /// <summary>
    /// Klasa dostarcza podstawowe dane, jak zmienne srodowiskowe, aktualna konfiguracja.
    /// </summary>
    public class Config
    {
        private static int rozmiarMiniatury = 100;

        /// <summary>
        /// Metoda sprawdza czy sa spelnione wszystkie warunki do pracy programu,
        /// a jesli nie, to stara sie je zapewnic
        /// </summary>
        public static void sprawdzWarunkiPoczatkowe()
        {
            if (!Directory.Exists(katalogAplikacji))
            {
                DirectoryInfo di = Directory.CreateDirectory(katalogAplikacji);
            }
        }

        /// <summary>
        /// Zwraca katalog z pluginami
        /// </summary>
        public static string katalogPluginow
        {
            get
            {
                return System.IO.Path.GetFullPath("plugins");
            }
        }

        /// <summary>
        /// Zwraca katalog domowy aplikacji
        /// </summary>
        public static string katalogAplikacji
        {
            get
            {
                return Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData) + "\\IIPhoto";
            }
        }

        /// <summary>
        /// Zwraca katalog "Moje Dokumenty" aktualnego uzytkownika
        /// </summary>
        public static string katalogMojeDokumenty
        {
            get
            {
                return Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
            }
        }

        /// <summary>
        /// Zwraca katalog "Moje Obrazy" aktualnego uzytkownika
        /// </summary>
        public static string katalogMojeObrazy
        {
            get
            {
                return Environment.GetFolderPath(Environment.SpecialFolder.MyPictures);
            }
        }

        /// <summary>
        /// Zwraca katalog "Pulpit" aktualnego uzytkownika
        /// </summary>
        public static string katalogPulpit
        {
            get
            {
                return Environment.GetFolderPath(Environment.SpecialFolder.Desktop);
            }
        }

        /// <summary>
        /// Zwraca aktualny rozmiar miniatur
        /// </summary>
        public static int RozmiarMiniatury
        {
            get
            {
                return rozmiarMiniatury;
            }
        }

        /// <summary>
        /// Umozliwia zmiane rozmiaru miniatur
        /// </summary>
        /// <param name="size"></param>
        public static void ZmienRozmiarMiniatury(int size)
        {
            switch (size)
            {
                case 1: rozmiarMiniatury = 75; break;
                case 2: rozmiarMiniatury = 90; break;
                case 3: rozmiarMiniatury = 120; break;
                default: rozmiarMiniatury = 90; break;
            }
        }

        /// <summary>
        /// Nazwa pliku z baza danych SQLite
        /// </summary>
        public static string plikBazy = "iiphoto.db3";
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Drawing;
using System.Drawing.Imaging;
using System.Data;
using System.Text;
using System.Windows.Forms;

namespace Photo
{
    public partial class PrzegladarkaZdjec : UserControl, IOpakowanieZdjec
    {
        public PrzegladarkaZdjec()
        {
            InitializeComponent();
            SetThumbnailView();
        }
        public void SetThumbnailView()
        {
            if (thumbnailView1.Visible == false)
            {
                // zamykanie dytora
            }
            thumbnailView1.Visible = true;
            imageView1.Visible = false;
        }
        public void SetImageView()
        {
            imageView1.Visible = true;
            thumbnailView1.Visible = false;
        }
        public WidokMiniatur Thumbnailview
        {
            get
            {
                return thumbnailView1;
            }
        }
        public WidokZdjecia Imageview
        {
            get
            {
                return imageView1;
            }
        }
        IOpakowanieZdjec AktywneOpakowanie
        {
            get
            {
                if (imageView1.Visible == true)
                {
                    return thumbnailView1;
                }
                else
                {
                    return thumbnailView1;
                }
            }
        }

        /*public void Zoom(double zoom)
        {
            if (imageView1.Visible == true)
            {
                imageView1.Zoom(zoom);
            }
            else if (thumbnailView1.Visible == true)
            {
                thumbnailView1.ShowImages(zoom);
            }
        }*/

        /*public void Crop()
        {
            if (imageView1.Visible == true)
            {
                imageView1.Crop();
            }
        }*/

        /*public void toGrayScale()
        {
            if (imageView1.Visible == true)
            {
                imageView1.toGrayScale();
            }
        }*/

        private void mouseDoubleClick(object sender, MouseEventArgs e)
        {
            ListViewItem listViewItem = ((WidokMiniatur)sender).FocusedItem;
            Zdjecie z = (Zdjecie)thumbnailView1[listViewItem.ImageIndex];
            this.imageView1.setImage(z);
            this.SetImageView();
            if (WybranoZdjecie != null)
                WybranoZdjecie(z);
        }

        #region IOpakowanieZdjec Members

        public IZdjecie this[int numer]
        {
            get { return AktywneOpakowanie[numer]; }
        }

        public int Ilosc
        {
            get { return AktywneOpakowanie.Ilosc; }
        }

        public void Dodaj(IZdjecie zdjecie)
        {
            AktywneOpakowanie.Dodaj(zdjecie);
        }

        public void Usun(IZdjecie zdjecie)
        {
            AktywneOpakowanie.Usun(zdjecie);
        }

        public void Oproznij()
        {
            AktywneOpakowanie.Oproznij();
        }

        public IZdjecie[] WybraneZdjecia()
        {
            return AktywneOpakowanie.WybraneZdjecia();
        }

        public void RozpocznijEdycje()
        {
            AktywneOpakowanie.RozpocznijEdycje();
        }

        public void ZakonczEdycje()
        {
            AktywneOpakowanie.ZakonczEdycje();
        }

        public void DodajOperacje(PolecenieOperacji operacja)
        {
            AktywneOpakowanie.DodajOperacje(operacja);
        }

        public void UsunWszystkieOperacje()
        {
            AktywneOpakowanie.UsunWszystkieOperacje();
        }

        public void Wypelnij(IZdjecie[] zdjecia)
        {
            this.SetThumbnailView();
            AktywneOpakowanie.Wypelnij(zdjecia);
        }

        #endregion
    }
}
<file_sep>using System;
using System.Drawing;
using System.Drawing.Imaging;
using System.Collections.Generic;
using System.Text;
using Photo;

namespace Wyostrzenie
{
    /// <summary>
    /// Prykładowa implementacja operacji graficznej.
    /// Do referencji projektu należy dołączyć plik exe programu przeglądarki.
    /// Następnie należy zaimplementować interfejs GUI.IOperacja.
    /// </summary>
    public class Wyostrzenie : Photo.IOperacja
    {
        private int kodOperacji;

        #region IOperacja Members

        public string NazwaOperacji
        {
            get { return "Wyostrzenie"; }
        }

        int Photo.IOperacja.KodOperacji
        {
            get
            {
                return kodOperacji;
            }
            set
            {
                kodOperacji = value;
            }
        }

        public Image Ikona
        {
            get
            {
                return Properties.Resources.filtr;
            }
        }

        public string Autor
        {
            get { throw new System.Exception("The method or operation is not implemented."); }
        }

        public string Wersja
        {
            get { throw new System.Exception("The method or operation is not implemented."); }
        }

        public string Kontakt
        {
            get { throw new System.Exception("The method or operation is not implemented."); }
        }

        public void Wykonaj(System.Drawing.Bitmap Bitmap, System.Collections.Generic.Stack<object> Argumenty)
        {
            Rectangle rect = new Rectangle(new Point(0,0), Bitmap.Size);
            BitmapData bd = Bitmap.LockBits(rect, ImageLockMode.ReadWrite, Bitmap.PixelFormat);
            int bytes = bd.Width * bd.Height * 3;
            byte[] rgbValues = new byte[bytes];
            System.Runtime.InteropServices.Marshal.Copy(bd.Scan0, rgbValues, 0, bytes);
            for (int i = 0; i < bytes; i++)
            {
                rgbValues[i] = (byte)((int)rgbValues[i] & 0x7f);
            }
            System.Runtime.InteropServices.Marshal.Copy(rgbValues, 0, bd.Scan0, bytes);
            Bitmap.UnlockBits(bd);
        }

        public Stack<object> PodajArgumenty()
        {
            return new Stack<object>();
        }

        #endregion
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Text;

namespace Photo
{
    public class ZdjecieTag
    {
        string filename;

        public ZdjecieTag(string file)
        {
            this.filename = file;
        }
        public string Filename
        {
            get
            {
                return filename;
            }
            set
            {
                this.filename = value;
            }
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.Text;
using System.Drawing;
using System.Drawing.Imaging;
using System.Windows.Forms;
using System.Threading;
using System.IO;

namespace Photo
{
    /// <summary>
    /// Kontrolka dziedziczaca po ListView, do wyswietlania miniatur zdjec.
    /// </summary>
    public class WidokMiniatur : ListView, IOpakowanieZdjec, IKontekst
    {
        private bool Edycja;
        private Bitmap katalog;
        private Bitmap katalog_do_gory;
        private WypelnijMiniaturyThread wypelnijThreadClass;
        private Thread t;
        private Semaphore sem;

        private List<IZdjecie> WyswietloneZdjecia;
        private List<IZdjecie> WszystkieZdjecia;
        private Katalog[] katalogi;
        private List<long> tagi;

        /// <summary>
        /// Pole informujace czy miniatury pochodza z drzewa katalogow,
        /// czy z innego zrodla
        /// </summary>
        public bool MiniaturyZDrzewa;

        /// <summary>
        /// Wyliczenie informujace czy ListViewItem jest zdjeciem czy katalogiem
        /// </summary>
        public enum listViewTag
        {
            katalog,
            zdjecie
        }

        /// <summary>
        /// Konstruktor bezparametryczny
        /// </summary>
        public WidokMiniatur()
        {
            WyswietloneZdjecia = new List<IZdjecie>();
            WszystkieZdjecia = new List<IZdjecie>();
            katalogi = new Katalog[0];
            tagi = new List<long>();
            LargeImageList = new ImageList();
            LargeImageList.ColorDepth = System.Windows.Forms.ColorDepth.Depth32Bit;
            LargeImageList.Tag = "100%";
            LargeImageList.TransparentColor = System.Drawing.Color.Transparent;
            LargeImageList.ImageSize = new Size(Config.RozmiarMiniatury + 2, Config.RozmiarMiniatury + 2);

            //Activate double buffering

            //Enable the OnNotifyMessage event so we get a chance to filter out 
            // Windows messages before they get to the form's WndProc
            this.SetStyle(ControlStyles.OptimizedDoubleBuffer | ControlStyles.AllPaintingInWmPaint, true);
            this.SetStyle(ControlStyles.EnableNotifyMessage, true);

            katalog = Properties.Resources.katalog;
            katalog_do_gory = Properties.Resources.katalog_do_gory;
            Edycja = false;
            
            sem = new Semaphore(0, 1);
            sem.Release();
        }

        protected override void OnNotifyMessage(Message m)
        {
            //Filter out the WM_ERASEBKGND message
            if (m.Msg != 0x14)
            {
                base.OnNotifyMessage(m);
            }
        }

        /// <summary>
        /// Metoda zmieniajaca rozmiar wyswietlanych miniatur
        /// </summary>
        /// <param name="size">Nowy rozmiar</param>
        public void ZmienRozmiarMiniatur(int size)
        {
            LargeImageList.ImageSize = new Size(size + 2, size + 2);
        }

        #region IOpakowanieZdjec Members

        /// <summary>
        /// Propercja zwracajaca zdjecie sposrod wyswietlanych zdjec
        /// </summary>
        /// <param name="numer">Indeks zdjecia do pobrania</param>
        /// <returns>Zwroca obiekt implementujacy interfejs IZdjecie</returns>
        public IZdjecie this[int numer]
        {
            get { return WyswietloneZdjecia[numer]; }
        }

        /// <summary>
        /// Propercja zwracajaca ilosc wyswietlanych elementow
        /// </summary>
        public int Ilosc
        {
            get { return WyswietloneZdjecia.Count + katalogi.Length ; }
        }

        /// <summary>
        /// Propercja zwracajaca ilosc wyswietlanych zdjec
        /// </summary>
        public int IloscZdjec
        {
            get { return WyswietloneZdjecia.Count; }
        }

        /// <summary>
        /// Propercja zwracajaca ilosc wyswietlanych katalogow
        /// </summary>
        public int IloscKatalogow
        {
            get { return katalogi.Length; }
        }

        /// <summary>
        /// Propercja zwracajaca aktualnie wyswietlane katalogi 
        /// </summary>
        public Katalog[] Katalogi
        {
            get { return katalogi; }
        }

        /// <summary>
        /// Metoda dodajaca zdjecie do wyswietlenia
        /// </summary>
        /// <param name="zdjecie">Zdjecie do wyswietlenia</param>
        public void Dodaj(IZdjecie zdjecie)
        {
            if (zdjecie.Miniatura == null)
                return;
            if (!((Zdjecie)zdjecie).FormatPliku.Equals("Jpeg"))
            {
                return;
            }

            zdjecie.ZmodyfikowanoZdjecie += new ZmodyfikowanoZdjecieDelegate(ZmodyfikowanoZdjecie);
            if (CzyWyswietlic(zdjecie))
            {
                ((Zdjecie)zdjecie).indeks = LargeImageList.Images.Count;
                WyswietloneZdjecia.Add(zdjecie);
                WszystkieZdjecia.Add(zdjecie);
                LargeImageList.Images.Add(((Zdjecie)zdjecie).StworzMiniatureDoWidokuMiniatur());
                ListViewItem listViewItem = new ListViewItem(zdjecie.NazwaPliku);
                listViewItem.ImageIndex = LargeImageList.Images.Count - 1;
                listViewItem.Tag = WidokMiniatur.listViewTag.zdjecie;
                this.Items.Add(listViewItem);
            }
            else
            {
                WszystkieZdjecia.Add(zdjecie);
            }
        }

        /*public void OdswiezZdjecie(IZdjecie zdjecie)
        {
            LargeImageList.Images[((Zdjecie)zdjecie).indeks] = ((Zdjecie)zdjecie).StworzMiniatureDoWidokuMiniatur();
            Refresh();
        }*/

        /// <summary>
        /// Metoda usuwajaca zdjecie z kolekcji zdjec do wyswietlenia
        /// </summary>
        /// <param name="zdjecie">Zdjecie do usuniecia</param>
        public void Usun(IZdjecie zdjecie)
        {
            WyswietloneZdjecia.Remove(zdjecie);
            WszystkieZdjecia.Remove(zdjecie);
        }

        /// <summary>
        /// Metoda odswiezajaca widok miniatur
        /// </summary>
        public void Odswiez()
        {
            Wypelnij(WszystkieZdjecia.ToArray(), katalogi, MiniaturyZDrzewa);
        }

        /// <summary>
        /// Metoda czyszczaca obszar wyswietlania
        /// </summary>
        public void Oproznij()
        {
            katalogi = new Katalog[0];
            LargeImageList.Images.Clear();
            this.Items.Clear();
        }

        /// <summary>
        /// Propercja zwracajaca kolekcje wyswietlanych zdjec 
        /// </summary>
        public IZdjecie[] Zdjecia
        {
            get
            {
                return WyswietloneZdjecia.ToArray();
            }
        }

        /// <summary>
        /// Metoda zwracajaca zdjecie, ktorego pole "indeks" jest rowne podanej wartosci
        /// </summary>
        /// <param name="i">Indeks szukanego zdjecia</param>
        /// <returns>Obiekt implementujacy interfejs IZdjecie</returns>
        public IZdjecie ZdjecieZIndeksem(int i)
        {
            foreach (Zdjecie z in WyswietloneZdjecia)
            {
                if (z.indeks == i)
                    return z;
            }
            return null;
        }

        /// <summary>
        /// Propercja zwraca wybrane (zaznaczone) zdjecia 
        /// </summary>
        public IZdjecie[] WybraneZdjecia
        {
            get
            {
                List<Zdjecie> zdjecia = new List<Zdjecie>();
                for (int i = 0; i < SelectedItems.Count; i++)
                {
                    if (SelectedItems[i].ImageIndex - katalogi.Length >= 0)
                        zdjecia.Add((Zdjecie)this[SelectedItems[i].ImageIndex - katalogi.Length]);
                }
                return zdjecia.ToArray();
            }
        }

        /// <summary>
        /// Metoda rozpoczynajaca tryb szybkiej edycji
        /// </summary>
        public void RozpocznijEdycje()
        {
            Edycja = true;
        }

        /// <summary>
        /// Metoda konczaca tryb szybkiej edycji - wykonujaca wszystkie oczekujace operacje
        /// </summary>
        public void ZakonczEdycje()
        {
            Edycja = false;
            foreach (IZdjecie zdjecie in WyswietloneZdjecia)
            {
                zdjecie.WykonajOperacje();
                zdjecie.UsunWszystkieOperacje();
            }
        }


        /// <summary>
        /// Metoda dodajaca operacje do wykonania na zdjeciu/ach
        /// </summary>
        /// <param name="operacja">Obiekt bedacy poleceniem operacji</param>
        public void DodajOperacje(PolecenieOperacji operacja)
        {
            if (Edycja == false)
            {
                RozpocznijEdycje();
                foreach (IZdjecie zdjecie in WybraneZdjecia)
                {
                    zdjecie.DodajOperacje(operacja);
                }
                ZakonczEdycje();
            }
            else
            {
                foreach (IZdjecie zdjecie in WybraneZdjecia)
                {
                    zdjecie.DodajOperacje(operacja);
                }
            }
        }

        /// <summary>
        /// Metoda usuwajaca wszystkie operacje na zdjeciu/ach z wybranych (zaznaczonych) zdjec
        /// </summary>
        public void UsunWszystkieOperacje()
        {
            foreach (IZdjecie zdjecie in WybraneZdjecia)
            {
                zdjecie.UsunWszystkieOperacje();
            }
        }

        /// <summary>
        /// Zdarzenie informujace o wybraniu zdjecia z kolekcji
        /// </summary>
        public event WybranoZdjecieDelegate WybranoZdjecie;

        /// <summary>
        /// Metoda sprawdzajaca czy podane zdjecie spelnia kryteria filtracji tagami
        /// </summary>
        /// <param name="zdjecie">Zdjecie do przefitlrowania</param>
        /// <returns>Wartosc boolowska informujaca czy zdjecie nalezy wyswietlic czy nie</returns>
        public bool CzyWyswietlic(IZdjecie zdjecie)
        {
            if (tagi.Count == 0)
                return true;

            bool wyswietlic = true;
            foreach (long l in tagi) 
            {
                if (!((Zdjecie)zdjecie).Tagi.Contains(l))
                    wyswietlic = false;
            }
            return wyswietlic;
        }

        /// <summary>
        /// Metoda wypelniajaca zdjeciami i katalogami widok miniatur.
        /// </summary>
        /// <param name="zdjecia">Tablica obiektow do wyswietlenia</param>
        /// <param name="katalogi">Tablica katalogow do wyswietlenia</param>
        /// <param name="CzyZDrzewa">Zmienna informujaca czy podane dane pochodza z drzewa katalogow czy nie</param>
        public void Wypelnij(IZdjecie[] zdjecia, Katalog[] katalogi, bool CzyZDrzewa)
        {
            MiniaturyZDrzewa = CzyZDrzewa;
            if (t != null && t.IsAlive)
            {
                if (wypelnijThreadClass != null)
                {
                    wypelnijThreadClass.Stop();
                }
            }
            wypelnijThreadClass = new WypelnijMiniaturyThread(this, zdjecia, katalogi);
            t = new System.Threading.Thread(new System.Threading.ThreadStart(wypelnijThreadClass.ThreadFunc));
            t.IsBackground = true;
            t.Start();
        }

        #endregion

        /// <summary>
        /// Metoda ustawiajaca nowe tagi do filtrowania i przeladowujaca kontrolke
        /// </summary>
        /// <param name="t">Nowa lista tagow</param>
        public void DodajTagi(List<long> t)
        {
            tagi = t;
            Wypelnij(WszystkieZdjecia.ToArray(), katalogi, MiniaturyZDrzewa);
        }

        #region IKontekst Members

        /// <summary>
        /// Metoda nieuzywana
        /// </summary>
        public void DodajDoKontekstu(IZdjecie zdjecie)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        /// <summary>
        /// Metoda nieuzywana
        /// </summary>
        public void UsunZKontekstu(IZdjecie zdjecie)
        {
            throw new Exception("The method or operation is not implemented.");
        }

        /// <summary>
        /// Metoda zmieniajaca miniature zdjecia, na ktorym wykonano modyfikacje
        /// </summary>
        /// <param name="kontekst">Nieuzywany</param>
        /// <param name="zdjecie">Zdjecie na ktorym wykonano modyfikacje</param>
        /// <param name="rodzaj">Rodzaj modyfikacji</param>
        public void ZmodyfikowanoZdjecie(IKontekst kontekst, IZdjecie zdjecie, RodzajModyfikacjiZdjecia rodzaj)
        {
            int indx = ((Zdjecie)zdjecie).indeks - katalogi.Length;
            if (indx < 0 || indx > WyswietloneZdjecia.Count)
                return;
            IZdjecie z = WyswietloneZdjecia[indx];
            if (z == zdjecie)
            {
                LargeImageList.Images[((Zdjecie)zdjecie).indeks] = ((Zdjecie)zdjecie).StworzMiniatureDoWidokuMiniatur();
                Refresh();
            }
        }

        #endregion

        /// <summary>
        /// Metoda dodajaca miniature katalogu do wyswietlenia
        /// </summary>
        /// <param name="k">Katalog do wyswietlenia</param>
        public void DodajKatalog(Katalog k)
        {
            string podpis;
            int maxSize = Config.RozmiarMiniatury;
            int pos;
            Bitmap newBitmap, tempDir;
            Graphics MyGraphics;
            Rectangle MyRectan;
            int scaledD;
            ListViewItem listViewItem;

            newBitmap = new Bitmap(maxSize, maxSize);
            MyGraphics = Graphics.FromImage(newBitmap);

            scaledD = Config.RozmiarMiniatury / 2;

            using (Pen p = new Pen(Brushes.LightGray))
            {
                MyGraphics.DrawRectangle(p, 0, 0, maxSize - 1, maxSize - 1);
            }

            if (k.CzyDoGory == true)
            {
                if (katalog_do_gory.Width > scaledD)
                {
                    tempDir = (Bitmap)katalog_do_gory.GetThumbnailImage(scaledD, scaledD, new System.Drawing.Image.GetThumbnailImageAbort(ThumbnailCallback), System.IntPtr.Zero);
                    pos = (maxSize - scaledD) / 2;
                }
                else
                {
                    tempDir = katalog_do_gory;
                    scaledD = katalog_do_gory.Width;
                }
                listViewItem = new ListViewItem("..");
            }
            else
            {
                if (katalog.Width > scaledD)
                {
                    tempDir = (Bitmap)katalog.GetThumbnailImage(scaledD, scaledD, new System.Drawing.Image.GetThumbnailImageAbort(ThumbnailCallback), System.IntPtr.Zero);
                }
                else
                {
                    tempDir = katalog;
                    scaledD = katalog.Width;
                }
                podpis = k.Path.Substring(k.Path.LastIndexOf('\\') + 1);
                if (podpis.Equals(""))
                    podpis = k.Path;
                listViewItem = new ListViewItem(podpis);
            }
            pos = (maxSize - scaledD) / 2;
            MyRectan = new Rectangle(pos, pos, scaledD, scaledD);
            MyGraphics.DrawImage(tempDir, MyRectan);
            LargeImageList.Images.Add(newBitmap);
            listViewItem.ImageIndex = LargeImageList.Images.Count - 1;
            listViewItem.Tag = WidokMiniatur.listViewTag.katalog;
            this.Items.Add(listViewItem);
            this.Refresh();
        }

        private static bool ThumbnailCallback()
        {
            return true;
        }

        /// <summary>
        /// Metoda zapisujaca na dysku wybrane zdjecie
        /// </summary>
        public void ZapiszPlik()
        {
            Zdjecie z;
            ListViewItem listViewItem = this.FocusedItem;
            if (listViewItem == null || (WidokMiniatur.listViewTag)listViewItem.Tag == WidokMiniatur.listViewTag.katalog)
                return;
            z = (Zdjecie)this[listViewItem.ImageIndex - katalogi.Length];
            try
            {
                z.Zapisz();
            }
            catch (DirectoryNotFoundException)
            {
                MessageBox.Show("Wybrana scieżka nie istnieje!", "Błąd!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
            }
        } 

        /// <summary>
        /// Klasa wykonujaca wypelnianie elementami widoku miniatur, poprzez osobny watek
        /// </summary>
        internal class WypelnijMiniaturyThread
        {
            WidokMiniatur widokMiniatur;
            IZdjecie[] zdjecia;
            Katalog[] katalogi;
            bool stop;

            public WypelnijMiniaturyThread(WidokMiniatur wm, IZdjecie[] z, Katalog[] k)
            {
                widokMiniatur = wm;
                zdjecia = z;
                katalogi = k;
                stop = false;
            }

            public delegate void WyswietlZdjecie(Zdjecie z);
            public delegate void WyswietlKatalog(Katalog k);
            public delegate void OproznijWidokMiniatur();
            public delegate RodzajDecyzji ZapiszZdjecieDelegate();

            public void ThreadFunc()
            {
                widokMiniatur.sem.WaitOne();
                bool takDlaWszystkich = false;
                foreach (Zdjecie z in widokMiniatur.Zdjecia)
                {
                    if (z.Edytowano == true)
                    {
                        if (takDlaWszystkich)
                        {
                            z.Zapisz();
                        }
                        else
                        {
                            RodzajDecyzji decyzja = (RodzajDecyzji)widokMiniatur.Invoke(new ZapiszZdjecieDelegate(z.ZapisanieNiezapisanych));
                            if (decyzja == RodzajDecyzji.Tak)
                            {
                                z.Zapisz();
                            }
                            else if (decyzja == RodzajDecyzji.TakDlaWszystkich)
                            {
                                takDlaWszystkich = true;
                                z.Zapisz();
                            }
                            else if (decyzja == RodzajDecyzji.NieDlaWszystkich)
                            {
                                break;
                            }
                        }

                    }
                }

                widokMiniatur.Invoke(new OproznijWidokMiniatur(widokMiniatur.Oproznij));
                widokMiniatur.katalogi = katalogi;

                for (int i = 0; i < katalogi.Length; i++)
                {
                    if (stop)
                        break;
                    widokMiniatur.Invoke(new WyswietlKatalog(widokMiniatur.DodajKatalog), katalogi[i]);
                }

                widokMiniatur.WyswietloneZdjecia.Clear();
                widokMiniatur.WszystkieZdjecia.Clear();

                for (int i = 0; i < zdjecia.Length; i++)
                {
                    if (stop)
                        break;
                    widokMiniatur.Invoke(new WyswietlZdjecie(widokMiniatur.Dodaj),zdjecia[i]);
                }
                widokMiniatur.sem.Release();
            }

            internal void Stop()
            {
                stop = true;
            }
        }

        /// <summary>
        /// Metoda zapisujaca zmiany na wszystkich wyswietlanych aktualnie zdjeciach, na ktorych zostaly wykonane modyfikacje
        /// </summary>
        internal void ZapiszWszystkiePliki()
        {
            foreach (Zdjecie z in WyswietloneZdjecia)
            {
                try
                {
                    z.Zapisz();
                }
                catch (DirectoryNotFoundException)
                {
                    MessageBox.Show("Wybrana scieżka nie istnieje!", "Błąd!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
                }
            }
        }

        /// <summary>
        /// Metoda resetujaca i odswiezajaca identyfikatory aktualnie wyswietlonych zdjec
        /// </summary>
        public void ZresetujIds()
        {
            foreach (Zdjecie z in WyswietloneZdjecia)
            {
                z.ResetujId();
            }
        }

        /// <summary>
        /// Metoda resetujaca i odswiezajaca tagi aktualnie wyswietlonych zdjec
        /// </summary>
        public void ZresetujTagi()
        {
            foreach (Zdjecie z in WyswietloneZdjecia)
            {
                z.ResetujTagi();
            }
            Odswiez();
        }
    }
}
<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;

namespace Listview2
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
            imageViewer1.SetThumbnailView();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            imageViewer1.SetThumbnailView();
            List<Bitmap> images = new List<Bitmap>();
            Bitmap tempBitmap;

            for (int i = 1; i < 11; i++)
            {
                tempBitmap = new Bitmap(@"img\\small_img" + i.ToString() + ".jpg");
                tempBitmap.Tag = new ThumbnailTag(@"img\\img" + i.ToString() + ".jpg");
                images.Add(tempBitmap);
            }
            imageViewer1.Thumbnailview.AddImages(images);
            imageViewer1.Thumbnailview.ShowImages(1.0);
            
        }

        private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            switch (comboBox1.SelectedItem.ToString())
            {
                case "50%": imageViewer1.Zoom(0.5); break;
                case "75%": imageViewer1.Zoom(0.75); break;
                case "100%": imageViewer1.Zoom(1.0); break;
                case "150%": imageViewer1.Zoom(1.5); break;
                default: break;
            }
        }

        private void button2_Click(object sender, EventArgs e)
        {
            imageViewer1.SetThumbnailView();
        }

        private void button3_Click(object sender, EventArgs e)
        {
            imageViewer1.Crop();
        }

        private void button4_Click(object sender, EventArgs e)
        {
            imageViewer1.toGrayScale();
        }
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Data.SQLite;
using System.Data.SqlClient;

namespace Photo
{
    /// <summary>
    /// Klasa tworząca formatke do dodawania tagu do drzewa albumów i do bazy
    /// </summary>
    public partial class Dodaj_Tag : Form
    {
        private ListaAlbumowControl listaAlbumow;

        /// <summary>
        /// Konstruktor 
        /// </summary>
        /// <param name="la">obiekt listy albumów żeby wykorzystać niektóre jego metody</param>
        public Dodaj_Tag(ListaAlbumowControl la)
        {
            InitializeComponent();
            listaAlbumow = la;
        }

        /// <summary>
        /// Metoda dodająca nazwe tagu do bazy i do drzewa albumów i aktualizująca drzewko 
        /// </summary>
        private void DodajTagDoBazy()
        {
            string nazwa;

            if (textBox1.Text != "" && textBox1.Text.Length < 100)
            {
                nazwa = textBox1.Text;

                Db baza = new Db();

                baza.Polacz();

                try
                {
                    baza.Insert_czesci("Tag", "nazwa,album", "\'" + nazwa + "\',0");
                    listaAlbumow.lista_nazw_tagow.Add(nazwa);

                    DataSet ds = baza.Select("select max(id_tagu) from Tag where nazwa=\'" + nazwa + "\' and album=0");

                    foreach (DataTable t in ds.Tables)
                    {
                        foreach (DataRow r in t.Rows)
                        {
                            if (!(r[0] is DBNull))
                            {
                                listaAlbumow.lista_tagow.Add((Int64)r[0]);
                                //MessageBox.Show("nazwa: " + nazwa + " id_tagu: " + r[0]);
                            }
                        }
                    }
                }
                catch (SQLiteException)
                {
                    MessageBox.Show("Taka Nazwa Tag juz instnieje");
                }

                baza.Rozlacz();

                listaAlbumow.odswiez();

                this.Dispose();
            }
            else if (textBox1.Text == "")
            {
                MessageBox.Show("Wpisz nazwe tagu"); 
            }
            else
            {
                MessageBox.Show("Za długa nazwa");                
            }

        }

        /// <summary>
        /// Metoda wywołana gdy użytkownik naciśnie przycisk akceptujący i wywołuje metode DodajTagDoBazy
        /// </summary>
        private void button1_Click(object sender, EventArgs e)
        {
            DodajTagDoBazy();
        }

        /// <summary>
        /// Metoda wywołana gdy użytkownik naciśnie klawisz Enter i wywołuje metode DodajTagDoBazy
        /// </summary>
        private void textBox1_KeyPress(object sender, KeyPressEventArgs e)
        {
            Keys k = (Keys)e.KeyChar;
            if (k == Keys.Enter)
            {
                DodajTagDoBazy();
            }
        }
    }
}<file_sep>using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Text;
using System.Windows.Forms;
using System.Data.SQLite;
using System.Data.SqlClient;

namespace Photo
{
    /// <summary>
    /// Klasa tworząca formatke do dodawania katalogu do kolekcji jak i do albumu
    /// </summary>
    public partial class Dodaj_katalog_do_bazy : Form
    {

        private string sciezka;
        private FileTree drzewo;
        private PrzegladarkaZdjec przegladarka;
        
        private int opcja = 0; //1 - dodawanie z katalogu  // 2 - dodawanie z miniaturek
        /// <summary>
        /// Konstruktor wywołany gdy wywołana jest formatka z drzewa katalogów
        /// </summary>
        /// <param name="s">sciezka do pliku</param>
        /// <param name="tr">obiekt drzewa katalogów aby wywołać metody z tego obiekru</param>
        public Dodaj_katalog_do_bazy(string s, FileTree tr)
        {
            InitializeComponent();

            drzewo = tr;            

            this.button1.Enabled = false;
            sciezka = s;

            Wypelnij();
            opcja = 1;            
        }

        /// <summary>
        /// Konstruktor wywołany gdy wywołana jest formatka z przeglądarki zdjęć
        /// </summary>
        /// <param name="s">sciezka do pliku</param>
        /// <param name="pr">obiekt przeglądarki zdjęć aby wywołać metody z tego obiekru</param>
        public Dodaj_katalog_do_bazy(string s, PrzegladarkaZdjec pr)
        {
            InitializeComponent();
            przegladarka = pr;

            this.button1.Enabled = false;
            //sciezka = s;
            sciezka = s.Substring(0, s.LastIndexOf("\\"));
            if (sciezka.Length == 2)
                sciezka += "\\";

            Wypelnij();
            opcja = 2;

        }

        /// <summary>
        /// Metoda wypełniająca listBox nazwami albumów które są w bazie
        /// </summary>        
        private void Wypelnij()
        {
            List<string> lista= new List<string>();

            Db baza = new Db();

            baza.Polacz();

            try
            {
                DataSet dataSet = baza.Select("select nazwa from tag where album=1"); ;

                foreach (DataTable t in dataSet.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        lista.Add((string)r[0]);                        
                    }
                }      
                lista.Sort();

                foreach(string t in lista)
                {
                    this.comboBox1.Items.Add(t);
                }
            }
            catch (SqlException e)
            {
                MessageBox.Show(e.ToString() + e.Message);
            }
            baza.Rozlacz();
        }

        private void comboBox1_SelectedIndexChanged(object sender, EventArgs e)
        {
            //MessageBox.Show("SelectedIndexChanged");
            this.button1.Enabled = true;

        }
        /// <summary>
        /// Metoda dodająca zdjęcia z katalogu do albumu
        /// </summary>
        private void dodaj_do_albumu()
        {
            string nazwa = (string)this.comboBox1.SelectedItem;
            Int64 id_tagu = -1;

            Db baza = new Db();

            baza.Polacz();

            try
            {
                DataSet dataSet = baza.Select("select id_tagu from Tag where album=1 and nazwa=\'"+nazwa+"\';"); 

                foreach (DataTable t in dataSet.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        id_tagu = (Int64)r[0];                        
                    }
                }                

                dataSet = baza.Select("select id_zdjecia from Zdjecie where sciezka=\'" + sciezka + "\'"); ;

                foreach (DataTable t in dataSet.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        //tu maja byc fastinsert
                        baza.Insert("TagZdjecia", r[0] + "," + id_tagu);
                    }
                }
            }
            catch (SqlException e)
            {
                MessageBox.Show(e.ToString() + e.Message);
            }
            baza.Rozlacz();
        }

        /// <summary>
        /// Metoda dodająca zdjęcia z listy do albumu
        /// </summary>
        /// <param name="lista">lista scieżek do dodania do bazy</param>
        private void dodaj_do_albumu(List<string> lista)
        {
            string nazwa = (string)this.comboBox1.SelectedItem;
            Int64 id_tagu = -1;
            string nazwa_pliku;

            Db baza = new Db();

            baza.Polacz();

            try
            {
                DataSet dataSet = baza.Select("select id_tagu from Tag where album=1 and nazwa=\'" + nazwa + "\';");

                foreach (DataTable t in dataSet.Tables)
                {
                    foreach (DataRow r in t.Rows)
                    {
                        id_tagu = (Int64)r[0];
                    }
                }

                foreach (string n in lista)
                {

                    nazwa_pliku = n.Substring(n.LastIndexOf("\\") + 1, n.Length - n.LastIndexOf("\\") - 1);

                    dataSet = baza.Select("select max(id_zdjecia) from Zdjecie where sciezka=\'" + sciezka + "\' and nazwa_pliku=\'"+nazwa_pliku+"\'"); ;
                    //int i = 0;

                    foreach (DataTable t in dataSet.Tables)
                    {
                        foreach (DataRow r in t.Rows)
                        {
                            //tu maja byc fastinsert
                            baza.Insert("TagZdjecia", r[0] + "," + id_tagu);
                            //MessageBox.Show("i: "+i);
                            //i++;
                        }
                    }
                }

            }
            catch (SqlException e)
            {
                MessageBox.Show(e.ToString() + e.Message);
            }
            baza.Rozlacz();

        }

        /// <summary>
        /// Metoda wywołana gdy zostanie przyciśniety przycisk zatwierdzająca formatke. Uruchamia metody dodawania albumu
        /// </summary>
        private void button1_Click(object sender, EventArgs e)
        {                
            if (opcja == 1)
            {                
                drzewo.d_d_a(sciezka);

                dodaj_do_albumu();
            }
            else if (opcja == 2)
            {
                List<string> lista = przegladarka.dodaj_kolekcje_do_bazy();

                if(lista.Count != 0)
                {                    
                    dodaj_do_albumu(lista);
                }                
            }

            this.Dispose();
        }
    }
}