//konstruktor wczytujący kalendarz z pliku
public Aplikacja()
{
kalendarz = new Kalendarz();
data = new Data_dzien();
while (data.DzienTygodnia() != DniTygodnia.poniedziałek) { data--; }
//inicjalizacja OpenFileDialog
otwórz_plik = new OpenFileDialog();
otwórz_plik.InitialDirectory = "c:\\";
otwórz_plik.FileName = "";
otwórz_plik.Filter = "pliki Kalendarza (*.kalen)|*.kalen|All files (*.*)|*.*";
otwórz_plik.FilterIndex = 2;
otwórz_plik.RestoreDirectory = true;
//**************KONIEC INICJALIZACJI OpenFileDialog**************
//inicjalizacja SaveFileDialog
zapisz_plik = new SaveFileDialog();
zapisz_plik.AddExtension = true;
zapisz_plik.FileName = "";
zapisz_plik.InitialDirectory = "c:\\";
zapisz_plik.Filter = "pliki Kalendarza (*.kalen)|*.kalen|All files (*.*)|*.*";
zapisz_plik.FilterIndex = 1;
zapisz_plik.RestoreDirectory = true;
//**************KONIEC INICJALIZACJI SaveFileDialog**************
if (otwórz_plik.ShowDialog() == DialogResult.OK)
{
Stream plik = otwórz_plik.OpenFile();
kalendarz.Wczytaj(plik);
plik.Flush();
plik.Close();
}
}
public Data_dzien Dodaj(Wpis wpis)
{
Data_dzien poczatek = new Data_dzien(wpis.Poczatek()); //@!! C# lubi referencje, więc bez użycia new poczatek był typu Data!
if (kalendarz.ContainsKey(poczatek)) //jeżeli wpis danego dnia już istnieje
{
List<Wpis> wpisy_dnia = kalendarz[poczatek];
foreach (var tmp_wpis in wpisy_dnia) //sprawdź czy taki wpis już istnieje
{
if (tmp_wpis.Poczatek() == wpis.Poczatek() && tmp_wpis.Koniec() == wpis.Koniec()) //jeżeli istnieje to
{
tmp_wpis.Tytul(wpis.Tytul()); //zmień nazwę
return poczatek;
}
}
//***********SORTOWANIE WPISÓW***********
int i = 0;
/*while(wpis > tmp_wpis2) //@CO TO JEST?!
{
i++;
}*/
for(;i<wpisy_dnia.Count;i++)
if(wpis<wpisy_dnia[i])
break;
kalendarz[poczatek].Insert(i, wpis);
//***********KONIEC SORTOWANIA***********
}
else
{
kalendarz.Add(poczatek, new List<Wpis>() {wpis}); //jeżeli danego dnia nie ma jeszcze wpisów to stwórz nową liste wpisów i dodaj wpis
}
return poczatek;
}
public void Wczytaj(string plik)
{
StreamReader sr = new StreamReader(plik);
string linia;
while ((linia = sr.ReadLine()) != null)
{
//wczytywanie daty
int rok = Convert.ToInt32(linia);
int miesiac = Convert.ToInt32(sr.ReadLine());
int dzien = Convert.ToInt32(sr.ReadLine());
Data_dzien tmp_dzien = new Data_dzien(rok, miesiac, dzien); //tworzenie daty
//wczytywanie listy zdażeń
List<Wpis> tmp_list = new List<Wpis>() { };
while ((linia = sr.ReadLine()) != "-=NASTĘPNY WPIS=-")
{
string tytuł = linia;
int godz_p = Convert.ToInt32(sr.ReadLine()); //godzina - początek zdażenia
int min_p = Convert.ToInt32(sr.ReadLine()); //minuty - początek zdażenia
Data data_pocz = new Data(rok, miesiac, dzien, godz_p, min_p);
int godz_k = Convert.ToInt32(sr.ReadLine()); //godzina - koniec zdażenia
int min_k = Convert.ToInt32(sr.ReadLine()); //minuty - koniec zdażenia
Data data_kon = new Data(rok, miesiac, dzien, godz_k, min_k);
tmp_list.Add(new Wpis(data_pocz, data_kon, tytuł));
}
kalendarz.Add(tmp_dzien, tmp_list);
}
}
//konstruktor wczytujący kalendarz z pliku
public Aplikacja()
{
kalendarz = new Kalendarz();
data = new Data_dzien();
while (data.DzienTygodnia() != DniTygodnia.poniedziałek) { data--; }
dokonanoZmian=false;
}
public static Data operator -(Data x, int n)
{
Data_dzien nowy=new Data_dzien(x.rok,x.miesiac,x.dzien);
while (n > 0)
{
nowy--;
n -= 1;
}
return new Data(nowy.Rok(), nowy.Miesiac(), nowy.Dzien(), x.godzina, x.minuta);
}
public static Data_dzien operator -(Data_dzien x, int n)
{
Data_dzien nowy=new Data_dzien(x.rok,x.miesiac,x.dzien);
while (n > 0)
{
nowy.OdejmijDzien();
n -= 1;
}
return nowy;
}
public void przycisk_Click(object sender, EventArgs e)
{
Button przycisk=(Button)sender;
int numer=Convert.ToInt32(przycisk.Name);
wyswietlanyDzien=aplikacja.Data()+numer;
poczatek=new Data(wyswietlanyDzien.Rok(), wyswietlanyDzien.Miesiac(), wyswietlanyDzien.Dzien(),7,0);
koniec=new Data(poczatek);
OdswiezPoczatek();
OdswiezKoniec();
WyswietlWpisy();
}
//funkcja usuwająca pierwszy wpis o podanym tytule w danym dniu
public void Usun(Data_dzien dzien, string tytul)
{
if(kalendarz.ContainsKey(dzien))
{
var wpisy=kalendarz[dzien];
for(int i=0;i<wpisy.Count;i++)
if(wpisy[i].Tytul()==tytul)
{
kalendarz[dzien].RemoveAt(i);
break;
}
}
}
//metoda zwracająca bitmapę(być może w praniu zmienimy to na coś innego) wybranego dnia. Podobnie jak powyżej, ale z napisanymi godzinami i tytułami wpisów
public Bitmap Dzien(Data_dzien data, int szerokosc, int wysokosc)
{
List<Wpis> listaWpisw = kalendarz.WpisyDnia(data);
Bitmap dzien=new Bitmap(10,1440);
for (int i = 0; i < listaWpisw.Count; i++) //@FIX:a co jeśli nie ma wpisów? Powinno rysować wtedy biały obrazek
{
Wpis wpis = listaWpisw[i];
Data dat_pocz=wpis.Poczatek();
int poczatek=dat_pocz.Godzina()*60+dat_pocz.Minuta();
Data dat_kon=wpis.Koniec();
int koniec=dat_kon.Godzina()*60+dat_kon.Minuta();
string tytul = wpis.Tytul();
int R = new Random().Next(1, 255);
int G = new Random().Next(1, 255);
int B = new Random().Next(1, 255);
Color kolorDnia = Color.FromArgb(R, G, B);
string napis = wpis.Tytul() + "/n" + wpis.Poczatek() + "-" + wpis.Koniec();
Bitmap Tekst = new Bitmap(10,koniec-poczatek);
Graphics grafikaTekst = Graphics.FromImage(Tekst);
grafikaTekst.DrawString(napis, new Font("Arial", 10), Brushes.Black, new Point(0, 0));
Tekst = new Bitmap(10, koniec - poczatek, grafikaTekst);
for (int j = 0; j < Tekst.Height; j++)
{
for (int k = 0; k < Tekst.Width; k++)
{
if (Tekst.GetPixel(k, j) != Color.Black)
{
Tekst.SetPixel(k, j, kolorDnia);
}
for (int l = poczatek; l < koniec; l++)
{
for (int m = 0; m < 10; m++)
{
dzien.SetPixel(m, l, Tekst.GetPixel(k, j));
}
}
}
}
}
return dzien;
}
public Form1()
{
aplikacja=new Aplikacja();
poczatek=new Data();
koniec=new Data();
wyswietlanyDzien=new Data_dzien();
InitializeComponent();
GenerujMiesiac();
button_mieciac_tyl.BackgroundImage=gr._1.Properties.Resources.strzałka_lewo;
button_miesiac_nap.BackgroundImage=gr._1.Properties.Resources.strzałka_prawo;
nazwa_miesiaca.Font=new Font("Tahoma", nazwa_miesiaca.Height-10,GraphicsUnit.Pixel);
WyswietlWpisy();
panel_grafika.Controls.Add(numer_roku);
for (var i = aplikacja.Data().Rok()-1; i < aplikacja.Data().Rok()+5; i++)
{
ustawienia_rok_poczatek.Items.Add(i);
ustawienia_roku_koniec.Items.Add(i);
}
for (var i = 0; i < 24; i++)
{
ustawienie_godziny_koniec.Items.Add(i);
ustawienie_godziny_poczatek.Items.Add(i);
}
for (var i = 0; i < 60; i++)
{
ustawienie_minuty_koniec.Items.Add(i);
ustawienie_minuty_poczatek.Items.Add(i);
}
GenerujObraz();
OdswiezDni();
OdswiezPoczatek();
OdswiezKoniec();
}
//przejście do następnego miesiąca
public void Naprzod()
{
data += 7;
while (data.Dzien() != 1) data++;
while (data.DzienTygodnia() != DniTygodnia.poniedziałek) data--;
}
public Data_dzien(Data_dzien kopia)
{
rok = kopia.rok;
miesiac = kopia.miesiac;
dzien = kopia.dzien;
}
//zapis okresu do pliku. Musi zapytać gdzie zapisać
public void Eksport(Data_dzien poczatek, Data_dzien koniec)
{
if (zapisz_plik.ShowDialog() == DialogResult.OK)
{
Stream plik = zapisz_plik.OpenFile();
kalendarz.Zapisz(plik);
plik.Flush();
plik.Close();
}
}
//zapis okresu do pliku. Musi zapytać gdzie zapisać
public void Eksport(Data_dzien poczatek, Data_dzien koniec)
{
throw new System.Exception("Not implemented");
}
public List<Wpis> WpisyDnia(Data_dzien dzien)
{
return kalendarz[dzien];
}
//przejście do poprzedniego miesiąca
public void Wstecz()
{
data -= 7;
while (data.Dzien() != 1) data--;
while (data.DzienTygodnia() != DniTygodnia.poniedziałek) data--;
}
//metoda zwracająca bitmapę(być może w praniu zmienimy to na coś innego) wybranego dnia.
public unsafe Bitmap Dzien(Data_dzien data, int szerokosc, int wysokosc)
{
List<Wpis> lista_wpisow = kalendarz.WpisyDnia(data);
List<List<int> > lista_kolorow=new List<List<int>>(wysokosc); //Tu będziemy zapisywać jakich kolorów należy używać na danej wysokości obrazu
for(int y=0;y<wysokosc;y++)
lista_kolorow.Add(new List<int>());
//Tworzymy czystą bitmapę
Bitmap bitmapa=new Bitmap(szerokosc,wysokosc);
//I od razu dobieramy siędo wskaźników. SetPixel jest zdecydowanie za wolny
System.Drawing.Imaging.BitmapData bitmapaD = bitmapa.LockBits(new Rectangle(0,0,szerokosc,wysokosc), System.Drawing.Imaging.ImageLockMode.ReadWrite, bitmapa.PixelFormat);
//Malujemy na biało
for (int i=0;i<szerokosc*wysokosc*4;i+=4)
{
pixel* pix=(pixel*)(bitmapaD.Scan0+i).ToPointer();
pix->A=255;
pix->R=255;
pix->G=255;
pix->B=255;
}
//zapełnianie listy_kolorow
if (lista_wpisow !=null)
for(int i=0; i<lista_wpisow.Count;i++)
{
var wpis=lista_wpisow[i];
Data pocz =wpis.Poczatek(); //@Tu może być bez new, bo nic nie zmieniamy
float pocz_w_minutach = pocz.Godzina() * 60 + pocz.Minuta();
pocz_w_minutach/=1440; //tyle jest minut w dobie. otrzymujemy procent doby
pocz_w_minutach*=wysokosc;
Data kon = wpis.Koniec();
float kon_w_minutach = kon.Godzina() * 60 + kon.Minuta();
kon_w_minutach/=1440;
kon_w_minutach*=wysokosc;
for(int y=Convert.ToInt32(pocz_w_minutach);y<Convert.ToInt32(kon_w_minutach);y++)
lista_kolorow[y].Add(i); //do listy kolorów dodajemy numer wydarzenia w tym dniu
}
//kolorowanie wpisami
for(int y=0;y<lista_kolorow.Count;y++) //idziemy w dół obrazka
{
for (int index_wpisu=0;index_wpisu<lista_kolorow[y].Count;index_wpisu++) //Jeśli nie ma wpisów na tej wysokości, to nic nie robimy
{
int szerokosc_koloru=szerokosc/lista_kolorow[y].Count; //szerokość wpisu zależy od ilości wpisów w tym samym czasie
for(int x=index_wpisu*szerokosc_koloru;x<(index_wpisu+1)*szerokosc_koloru;x++)
{
Color k= kolorek(lista_kolorow[y][index_wpisu]);
pixel* pix=(pixel*)(bitmapaD.Scan0+x*4+y*szerokosc*4).ToPointer();
pix->R=k.R;
pix->G=k.G;
pix->B=k.B;
// bitmapa.SetPixel(x,y,kolorek(lista_kolorow[y][index_wpisu])); //wybrany kolor zależy od indeksu wpisu
}
}
}
bitmapa.UnlockBits(bitmapaD);
int rozmiar=wysokosc/50; //liczymy rozmiar czcionki
//tworzymy napisy z godzinami
Graphics g=Graphics.FromImage(bitmapa);
for(int h=1;h<24;h++)
{
float y=h*60f*wysokosc/1440f-rozmiar/2;
Point p=new Point(0,Convert.ToInt32(y));
g.DrawString(h.ToString(), new Font("Tahoma",rozmiar), Brushes.Black,p);
p.X=szerokosc-rozmiar*2;
g.DrawString(h.ToString(), new Font("Tahoma",rozmiar), Brushes.Black,p);
}
//piszemy tytuły i godziny wpisów
if(lista_wpisow!=null) //foreach jednak nie działa dla null :(
foreach(var wpis in lista_wpisow)
{
rozmiar=Math.Min(wpis.Dlugosc()*wysokosc/1440/3,wysokosc/50-1); //ustalamy wysokość czcionki. Uwzględniając przypadek krrótkiego wpisu
int yp=wpis.Poczatek().Godzina()*60+wpis.Poczatek().Minuta(); //y początku wpisu
yp*=wysokosc;
yp/=1440;
int xp=wysokosc/50*2; //Jeśli nie będzie wiecej wpisów w tym samym czasie, to niech się wypisze z lewej strony, ale tak, by nie zasłaniać godzin
for(int index=0;index<lista_kolorow[yp].Count;index++) //szukamy indeksu wpisu, który wypełniamy
if(lista_wpisow[lista_kolorow[yp][index]]==wpis)
{
float szerokosc_wpisu=szerokosc/lista_kolorow[yp].Count;
xp=Convert.ToInt32(index*szerokosc_wpisu);
if(xp==0)xp=wysokosc/50*2; //tak jak wyżej, żeby nie zamalowało godzin
break;
}
Point p_poczatek=new Point(xp,yp); //tworzymy sobie punkt
//analogicznie jak wyżej
int yk=wpis.Koniec().Godzina()*60+wpis.Koniec().Minuta(); //y końca wpisu
yk*=wysokosc;
yk/=1440;
yk-=2*rozmiar; //koniec trzeba podciągnąć do góry, żeby nie wyjechał poza wpis
int xk=wysokosc/50*2;
for(int index=0;index<lista_kolorow[yk].Count;index++)
if(lista_wpisow[lista_kolorow[yk][index]]==wpis)
{
float szerokosc_wpisu=szerokosc/lista_kolorow[yk].Count;
xk=Convert.ToInt32(index*szerokosc_wpisu);
if(xk==0)xk=wysokosc/50*2;
break;
}
Point p_koniec=new Point(xk,yk);
//godizna początku
g.DrawString(wpis.Poczatek().Godzina()+":"+wpis.Poczatek().Minuta(),new Font("Tahoma", rozmiar),Brushes.White, p_poczatek);
//poniżej tytuł
p_poczatek.Y+=rozmiar+1;
g.DrawString(wpis.Tytul(),new Font("Tahoma", rozmiar+1),Brushes.White, p_poczatek);
//i na końcu zakończenie
g.DrawString(wpis.Koniec().Godzina()+":"+wpis.Koniec().Minuta(),new Font("Tahoma", rozmiar), Brushes.White, p_koniec);
}
return bitmapa;
}
//metoda zwracająca miesiąc (tyle ile będzie przycisków w gui) bitmap, które potem będą skalowane na przyciskach. Niech nie-zajęte godziny nie zajmują zbyt dużo miejsca. Godziny zajęte powinny zajmować przestrzeń proporcjonalną do czasu ich trwania. Wystarczą same kolory, bez tytułów.
public List<Bitmap> Miesiac(Data_dzien pierwszy, int szerokosc, int wysokosc)
{
//@TODO:przerobić, żeby od razu generowało obrazki o podanej szerokości i wysokości
List<Bitmap> lista_bitmap = new List<Bitmap> { };
for (int i = 0; i < 35; i++)
{
List<Wpis> lista_tmp = kalendarz.WpisyDnia(pierwszy + i);
if (lista_tmp != null)
{
Bitmap bitmapa = new Bitmap(1, 1440);
foreach (var wpis in lista_tmp)
{
Data pocz = wpis.Poczatek();
int pocz_w_minutach = pocz.Godzina() * 60 + pocz.Minuta();
Data kon = wpis.Koniec();
int kon_w_minutach = kon.Godzina() * 60 + kon.Minuta();
int r = new Random().Next(0, 255);
int g = new Random().Next(0, 255);
int b = new Random().Next(0, 255);
Color wypełnienie = Color.FromArgb(r, g, b);
for (int y = pocz_w_minutach; y < kon_w_minutach + 1; y++)
bitmapa.SetPixel(0, y, wypełnienie);
}
lista_bitmap.Add(bitmapa);
}
else
{
Bitmap bitmapa=new Bitmap(1,1440);
Color bialy=Color.White;
for(int j=0;j<1440;j++)
bitmapa.SetPixel(0,j,bialy);
lista_bitmap.Add(bitmapa);
}
}
return lista_bitmap;
}
void Usun_wpisClick(object sender, EventArgs e)
{
int rok=ToIntRok(ustawienia_rok_poczatek.Text);
int miesiac=ToIntMiesiac(ustawienie_miesiaca_poczatek.Text);
int dzien=Convert.ToInt32(ustawienia_dnia_poczatek.Text);
Data_dzien data=new Data_dzien(rok,miesiac,dzien);
aplikacja.Usun(data, ustawienie_tytul_wydarzenia.Text);
poczatek=new Data();
OdswiezDni();
OdswiezPoczatek();
OdswiezKoniec();
Odswiez();
}
//metoda zwracająca bitmapę(być może w praniu zmienimy to na coś innego) wybranego dnia. Podobnie jak powyżej, ale z napisanymi godzinami i tytułami wpisów
public Bitmap Dzien(Data_dzien data)
{
throw new System.Exception("Not implemented");
}
//zapis okresu do pliku. Musi zapytać gdzie zapisać
public void Eksport(Data_dzien poczatek, Data_dzien koniec)
{
SaveFileDialog plik=new SaveFileDialog();
plik.InitialDirectory = ".";
plik.FileName = "";
plik.Filter = "pliki Kalendarza (*.kalen)|*.kalen|All files (*.*)|*.*";
plik.FilterIndex = 1;
plik.RestoreDirectory = true;
if (plik.ShowDialog() == DialogResult.OK)
{
Stream plik_stream=plik.OpenFile();
kalendarz.Zapisz(plik_stream);
plik_stream.Flush();
plik_stream.Close();
}
}
//metoda zwracająca miesiąc (tyle ile będzie przycisków w gui) bitmap, które potem będą skalowane na przyciskach. Niech nie-zajęte godziny nie zajmują zbyt dużo miejsca. Godziny zajęte powinny zajmować przestrzeń proporcjonalną do czasu ich trwania. Wystarczą same kolory, bez tytułów.
public List<Bitmap> Miesiac(Data_dzien pierwszy)
{
throw new System.Exception("Not implemented");
}
public void Usun(Data_dzien data, string tytul)
{
kalendarz.Usun(data,tytul);
dokonanoZmian=true;
}
public List<Wpis> WpisyDnia(Data_dzien dzien)
{
if (kalendarz.ContainsKey(dzien))
{
return kalendarz[dzien];
}
return null;
}
