Generator dimenzija pravougaonih dvodimenzionalnih elemena

Preuzmi program na sledećem linku: Generator dimenzija pravougaonih dvodimenzionalnih elemenata.7z 

/*****************************************************************************************************

 * Program name  : Generator dimenzija pravougaonih dvodimenzionalnih elemenata                      *

 * Program ver.  : 3.1 Finalna verzija                                                               *

 * Created by    : SharpDevelop                                                                      *

 * Code author   : Perić Željko                                                                      *

 * Code language : C#                                                                                *

 * Date created  : 20.08.2013                                                                        *

 * Time created  : 21:22                                                                             *

 *                                                                                                   *

 *                                                                                                   *

 * Program Description : Program je kreiran za potrebe testiranja programa za uklapanje              *

 *                       pravougaonih dvodimenzionalnih elemenata na ortogonalnoj tabli.             *

 *                                                                                                   *

 *                       Pravougaoni dvodimenzionalni element karakterišu 'DUŽINA' i 'ŠIRINA'.       *

 *                       Ove dve karakteristike sa svojim vrednostima se nazivaju 'DIMENZIJE'.       *

 *                       Program generiše traženi par vrednosti, za dimenzije elemenata,             *

 *                       uz pomoć programske funkcije za generisanje slučajnih brojeva.              *

 *                       Vrednosti za dužinu i širinu mogu biti različite ili iste.                  *

 *                       Sam pojam dužina ne podrazumeva veću vrednost u odnosu na širinu.           *

 *                       Vrednosti su pozitivni celi brojevi deljivi brojem deset.                   *

 *                                                                                                   *

 *                                                                                                   *

 *                       Opcije koje kontrolišu način generisanja dimezija su :                      *

 *                                                                                                   *

 *                          1 - 'Rotacija elementa'                                                  *

 *                                                                                                   *

 *                          2 - 'Kopije elemenata'                                                   *

 *                                                                                                   *

 *                          3 - 'Dozvoljena oscilacija dimenzija'                                    *

 *                                                                                                   *

 *                                                                                                   *

 *                       Prva opcija se odnosi na mogućnost da se već generisane vrednosti za        *

 *                       dužinu i širinu elementa međusobno zamene i na taj način dobije novi        *

 *                       par vrednosti koji bi bio upamćen kao dimenzije novog elementa.             *

 *                                                                                                   *

 *                       Primer :                                                                    *

 *                                                                                                   *

 *                       Element br.( dužina, širina )                                               *

 *                                                                                                   *

 *                       Element 1 ( 100, 50 ) rotiranjem se dobija Element 2 ( 100, 50 )            *

 *                                                                                                   *

 *                                                                                                   *

 *                       Kopija elementa je onaj element koji ima iste vrednosti za dužinu i         *

 *                       širinu kao i neki drugi element.                                            *

 *                                                                                                   *

 *                       Primer :                                                                    *

 *                                                                                                   *

 *                       Element 1 ( 100, 50 ) jeste kopija Elementa 2 ( 100, 50 )                   *

 *                       Element 1 ( 100, 50 ) nije  kopija Elementa 2 ( 50, 100 )                   *

 *                                                                                                   *

 *                       Druga opcija sprečava generisanje istih vrednosti za dužinu i širinu        *

 *                       elemenata, odnosno onemogućava pojavu kopija elemenata.                     *

 *                       U nekim slučajevima ova opcija je onemogućena jer zavisi od izbora          *

 *                       ostalih opcija u programu, druga i treća opcija su isključive.              *

 *                       Broj dimenzija koje se mogu generisati kada je ova opcija uključena         *

 *                       zavisi od odnosa odabranih vrednosti za opsege najmanje i najveće           *

 *                       širine i dužine elemenata i mogućnosti rotacije elemenata.                  *

 *                       Ako je odnos vrednosti nepovoljan, u zadatim opsezima nije moguće           *

 *                       generisati željeni broj jedinstvenih dimenzija.                             *

 *                                                                                                   *

 *                                                                                                   *

 *                       Treća opcija kontroliše razliku u dimenzijama između elemenata tako što     *

 *                       određuje maksimalnu razliku u dimenzijama, između elementa koji je već      *

 *                       generisan i elementa koji tek treba da se generiše. Na ovaj način se        *

 *                       dobijaju ujednačene dimenzija elemenata, i mnogo veći broj istih            *

 *                       dimenzija. Uključenjem treće opcije isključuje se druga opcija.             *

 *                                                                                                   *

 *                                                                                                   *

 *                       Generisane dimenzije su pored prikaza u tabeli, snimljene u tekstualnom     *

 *                       dokumentu 'Dimenzije elemenata.txt' u fascikli gde se nalazi izvršna        *

 *                       verzija programa.                                                           *

 *                                                                                                   *

 *                                                                                                   *

 *                       Broj dimenzija elemenata koje program može da generiše u zavisnosti od      *

 *                       odabranih opcija je prikazan u polju 'Max. broj elemenata'                  *

 *                                                                                                   *

 *                                                                                                   *

 * Notice : Dozvoljeni opsezi vrednosti za promenljive unutar programa koje korisnik sam unosi       *

 *          preko odgovarajaćih polja grafičkog korisničkog interfejsa su međusobno zavisne:         *

 *                                                                                                   *

 *               Polje                     Min                      Maks                             *

 *                                                                                                   *

 *          'Broj elemenata'                1                      10000                             *

 *                                                                                                   *

 *          'Najmanja dužina'              10                'Najveća dužina' - 10                   *

 *          'Najmanja širina'              10                'Najveća širina' - 10                   *

 *                                                                                                   *

 *          'Najveća dužina'      'Najmanja dužina' + 10           10000                             *

 *          'Najveća širina'      'Najmanja širina' + 10           10000                             *

 *                                                                                                   *

 *          'Oscilacija dužine'            0         'Najveća dužina' - 'Najmanja dužina'            *

 *          'Oscilacija širine'            0         'Najveća širina' - 'Najmanja širina'            *

 *                                                                                                   *

 *                                                                                                   *

 *                                                                                                   *

 *                                                                              Sve najbolje,        *

 *                                                                              Autor                *

 *                                                                                                   *

 *****************************************************************************************************/

using System;

using System.ComponentModel;

using System.IO;

using System.Text;

using System.Windows.Forms;

namespace Generator_dimenzija_pravougaonih_dvodimenzionalnih_elemenata

{

    public partial class MainForm : Form

    {

        public MainForm()

        {

            InitializeComponent();

            // Izbriši sadržaj tabele elemenata

            Tabela_Dimenzije_Elemenata.Rows.Clear();

            Tabela_Dimenzije_Elemenata.RowCount = 100;

            Tabela_Dimenzije_Elemenata.Enabled = false;

        }

        #region -   Metode 'Generiši Dimenzije', za generisanje vrednosti dimenzija   -

        void Generiši_Dimenzije_Bez_Kopija()

        {

            #region - Deklaracija i inicijalizacija promenljivih -

            const string naziv_dokumenta = "Dimenzije elemenata.txt";

            string linija = string.Empty;

            StreamWriter snimi = new StreamWriter(naziv_dokumenta,false,Encoding.UTF8);

            Random slučajan_broj = new Random();

            int željeni_broj_elemenata = (int)Željeni_Broj_Elemenata_Polje.Value;

            int mogući_broj_dimenzija = 0;

            int najmanja_dužina = (int)Najmanja_Dužina_Polje.Value;

            int najmanja_širina = (int)Najmanja_Širina_Polje.Value;

            int najveća_dužina = (int)Najveća_Dužina_Polje.Value;

            int najveća_širina = (int)Najveća_Širina_Polje.Value;

            int opseg_dužine = 0;

            int opseg_širine = 0;

            int dužina = 0;

            int širina = 0;

            int i = 0;

            int j = 0;

            int k = 0;

            int brojač = 0;

            int [] iste_vrednosti_oba_opsega;

            int [] različite_vrednosti_opsega_dužina;

            int [] različite_vrednosti_opsega_širina;

            int [,] dimenzije;

            int z = 0;

            int d = 0;

            int š = 0;

            bool različito = true;

            #endregion

            //

            // Izračunaj mogući broj jedinstvenih dimenzija elemenata,

            // pri zadatim vrednostima opsega

            // za najveću i najmanju vrednost dužine i širine elementa

            // u zavisnosti od dozvoljene ili ne dozoljene rotacije elemenata

            //

            #region - Metoda -

            opseg_dužine = (najveća_dužina - najmanja_dužina)/10 + 1;

            opseg_širine = (najveća_širina - najmanja_širina)/10 + 1;

            for(i=najmanja_dužina;i<=najveća_dužina;i+=10)

            {

                for(j=najmanja_širina;j<=najveća_širina;j+=10)

                {

                    if(i==j)

                    {

                        k++; // broj istih vrednosti dva opsega

                    }

                }

            }

            i = opseg_dužine - k; // broj različitih vrednosti za opseg dužine

            j = opseg_širine - k; // broj različitih vrednosti za opseg širine

            //

            // Mogući broj jedinstvenih dimenzija elemenata

            //

            // Ako je dozvoljena rotacija elemenata

            if(Dozvoljena_Rotacija_Elementa_Izbor.Checked)

            {

                mogući_broj_dimenzija = (k*k) + (k*i*2) + (k*j*2) + (i*j*2);

            }

            // Ako je rotacija elemenata ne dozvoljena

            else

            {

                mogući_broj_dimenzija = (k*k) + (k*i) + (k*j) + (i*j);

            }

            dimenzije = new int[mogući_broj_dimenzija,2];

            Tabela_Dimenzije_Elemenata.Rows.Clear();

            Tabela_Dimenzije_Elemenata.RowCount = željeni_broj_elemenata;

            #endregion

            //

            // Pronađi sve moguće dimenzije

            // s jedinstvenim parovima vrednosti za dužinu i širinu

            //

            #region - Metode -

            // Prvi slučaj :

            // Vrednosti opsega za dužinu i širinu su potpuno različite

            // Granice opsega se ne preklapaju

            #region - Metoda -

            if(k==0)

            {

                i = 0;

                j = 0;

                brojač = 0;

                dužina = 0;

                širina = 0;

                for(i=najmanja_dužina;i<=najveća_dužina;i+=10)

                {

                    for(j=najmanja_širina;j<=najveća_širina;j+=10)

                    {

                        dužina = i;

                        širina = j;

                        // Upamti vrednosti za dužinu i širinu

                        dimenzije[brojač,0] = dužina;

                        dimenzije[brojač,1] = širina;

                        brojač++;

                        // Ako je dozvoljena rotacija elemenata

                        if(Dozvoljena_Rotacija_Elementa_Izbor.Checked)

                        {

                            // Zameni vrednosti za dužinu i širinu

                            dužina = j;

                            širina = i;

                            // Upamti vrednosti za dužinu i širinu

                            dimenzije[brojač,0] = dužina;

                            dimenzije[brojač,1] = širina;

                            brojač++;

                        }

                    }

                }

            }

            #endregion

            // Drugi slučaj :

            // Opsezi za dužinu i širinu imaju istih vrednosti

            // Granice opsega se preklapaju

            #region - Metoda -

            else if(k>0)

            {

                i = 0;

                j = 0;

                brojač = 0;

                z = k;

                d = opseg_dužine - k;

                š = opseg_širine - k;

                dužina = 0;

                širina = 0;

                iste_vrednosti_oba_opsega = new int[z];

                različite_vrednosti_opsega_dužina = new int[d];

                različite_vrednosti_opsega_širina = new int[š];

                // Uporedi vrednosti oba opsega

                // i razdvoji vrednosti po određenom kriterijumu

                #region - Metoda -

                // Izdvoji iste vrednosti iz oba opsega

                z = 0;

                for(i=najmanja_dužina;i<=najveća_dužina;i+=10)

                {

                    for(j=najmanja_širina;j<=najveća_širina;j+=10)

                    {

                        if(i==j)

                        {

                            iste_vrednosti_oba_opsega[z] = i;

                            z++;

                        }

                    }

                }

                // Izdvoji različite vrednosti iz opsega dužine

                d = 0;

                for(i=najmanja_dužina;i<=najveća_dužina;i+=10)

                {

                    različito = true;

                    for(j=0;j<z;j++)

                    {

                        if(i==iste_vrednosti_oba_opsega[j])

                        {

                            različito = false;

                            break;

                        }

                    }

                    if(različito)

                    {

                        različite_vrednosti_opsega_dužina[d] = i;

                        d++;

                    }

                }

                // Izdvoji različite vrednosti iz opsega širine

                š = 0;

                for(i=najmanja_širina;i<=najveća_širina;i+=10)

                {

                    različito = true;

                    for(j=0;j<z;j++)

                    {

                        if(i==iste_vrednosti_oba_opsega[j])

                        {

                            različito = false;

                            break;

                        }

                    }

                    if(različito)

                    {

                        različite_vrednosti_opsega_širina[š] = i;

                        š++;

                    }

                }

                #endregion

                // Generiši dimenzije iz niza istih vrednosti oba opsega

                #region- Metoda -

                for(i=0;i<z;i++)

                {

                    for(j=0;j<z;j++)

                    {

                        dužina = iste_vrednosti_oba_opsega[i];

                        širina = iste_vrednosti_oba_opsega[j];

                        // Upamti vrednosti za dužinu i širinu

                        dimenzije[brojač,0] = dužina;

                        dimenzije[brojač,1] = širina;

                        brojač++;

                    }

                }

                #endregion

                // Generiši dimenzije iz niza različitih vrednosti za opseg dužina

                // i niza istih vrednosti oba opsega

                #region- Metoda -

                for(i=0;i<d;i++)

                {

                    for(j=0;j<z;j++)

                    {

                        dužina = različite_vrednosti_opsega_dužina[i];

                        širina = iste_vrednosti_oba_opsega[j];

                        // Upamti vrednosti za dužinu i širinu

                        dimenzije[brojač,0] = dužina;

                        dimenzije[brojač,1] = širina;

                        brojač++;

                        // Ako je dozvoljena rotacija elemenata

                        if(Dozvoljena_Rotacija_Elementa_Izbor.Checked)

                        {

                            // Zameni vrednosti za dužinu i širinu

                            dužina = iste_vrednosti_oba_opsega[j];

                            širina = različite_vrednosti_opsega_dužina[i];

                            // Upamti vrednosti za dužinu i širinu

                            dimenzije[brojač,0] = dužina;

                            dimenzije[brojač,1] = širina;

                            brojač++;

                        }

                    }

                }

                #endregion

                // Generiši dimenzije iz niza različitih vrednosti za opseg širina

                // i niza istih vrednosti oba opsega

                #region- Metoda -

                for(i=0;i<š;i++)

                {

                    for(j=0;j<z;j++)

                    {

                        // Ako je dozvoljena rotacija elemenata

                        if(Dozvoljena_Rotacija_Elementa_Izbor.Checked)

                        {

                            dužina = različite_vrednosti_opsega_širina[i];

                            širina = iste_vrednosti_oba_opsega[j];

                            // Upamti vrednosti za dužinu i širinu

                            dimenzije[brojač,0] = dužina;

                            dimenzije[brojač,1] = širina;

                            brojač++;

                        }

                        // Zameni vrednosti za dužinu i širinu

                        dužina = iste_vrednosti_oba_opsega[j];

                        širina = različite_vrednosti_opsega_širina[i];

                        // Upamti vrednosti za dužinu i širinu

                        dimenzije[brojač,0] = dužina;

                        dimenzije[brojač,1] = širina;

                        brojač++;

                    }

                }

                #endregion

                // Generiši dimenzije iz niza različitih vrednosti za opseg dužina i

                // niza različitih vrednosti za opseg širina

                #region - Metoda -

                for(i=0;i<d;i++)

                {

                    for(j=0;j<š;j++)

                    {

                        dužina = različite_vrednosti_opsega_dužina[i];

                        širina = različite_vrednosti_opsega_širina[j];

                        // Upamti vrednosti za dužinu i širinu

                        dimenzije[brojač,0] = dužina;

                        dimenzije[brojač,1] = širina;

                        brojač++;

                        // Ako je dozvoljena rotacija elemenata

                        if(Dozvoljena_Rotacija_Elementa_Izbor.Checked)

                        {

                            // Zameni vrednosti za dužinu i širinu

                            dužina = različite_vrednosti_opsega_širina[j];

                            širina = različite_vrednosti_opsega_dužina[i];

                            // Upamti vrednosti za dužinu i širinu

                            dimenzije[brojač,0] = dužina;

                            dimenzije[brojač,1] = širina;

                            brojač++;

                        }

                    }

                }

                #endregion

            }

            #endregion

            #endregion

            //

            // Prepiši dimenzije za željeni broj elemenata u tabelu Dimenzije Elemenata

            // po slučajnom izboru elemenata

            //

            #region - Metoda -

            dužina = 0;

            širina = 0;

            brojač = 0;

            i = 0;

            if(mogući_broj_dimenzija>željeni_broj_elemenata)

            {

                while(brojač<željeni_broj_elemenata)

                {

                    i = slučajan_broj.Next(0,mogući_broj_dimenzija);

                    if(dimenzije[i,0]>0)

                    {

                        dužina = dimenzije[i,0];

                        širina = dimenzije[i,1];

                        Tabela_Dimenzije_Elemenata[0,brojač].Value = dužina.ToString();

                        Tabela_Dimenzije_Elemenata[1,brojač].Value = širina.ToString();

                        dimenzije[i,0] = -1;

                        brojač++;

                    }

                }

            }

            else

            {

                while(brojač<željeni_broj_elemenata)

                {

                    dužina = dimenzije[brojač,0];

                    širina = dimenzije[brojač,1];

                    Tabela_Dimenzije_Elemenata[0,brojač].Value = dužina.ToString();

                    Tabela_Dimenzije_Elemenata[1,brojač].Value = širina.ToString();

                    brojač++;

                }

            }

            #endregion

            //

            // Sortiraj dimenzije na osnovu vrednosti dužine i širine elementata

            //

            Prilagodi_Format_Podataka_U_Tabeli_Za_Sortiranje();

            Tabela_Dimenzije_Elemenata.Sort(Column1, ListSortDirection.Descending);

            Prilagodi_Format_Vrednostima_U_Tabeli_Za_Potrebe_Pregleda();

            //

            // Snimi dimenzije u fajl 'Dimenzije elemenata.txt'

            //

            #region - Metoda -

            dužina = 0;

            širina = 0;

            brojač = 0;

            while (brojač<Tabela_Dimenzije_Elemenata.RowCount)

            {

                dužina = int.Parse(Tabela_Dimenzije_Elemenata[0,brojač].Value.ToString());

                širina = int.Parse(Tabela_Dimenzije_Elemenata[1,brojač].Value.ToString());

                linija = dužina.ToString() + "," + širina.ToString();

                snimi.WriteLine(linija);

                brojač++;

            }

            snimi.Close();

            snimi.Dispose();

            #endregion

        }

        void Generiši_Dimenzije_Sa_Dozvoljenom_Oscilacijom_Dimenzija()

        {

            #region - Deklaracija i inicijalizacija promenljivih -

            const string naziv_dokumenta = "Dimenzije elemenata.txt";

            string linija = string.Empty;

            StreamWriter snimi = new StreamWriter(naziv_dokumenta,false,Encoding.UTF8);

            Random slučajan_broj = new Random();

            int željeni_broj_elemenata = (int)Željeni_Broj_Elemenata_Polje.Value;

            int najmanja_dužina = (int)Najmanja_Dužina_Polje.Value;

            int najmanja_širina = (int)Najmanja_Širina_Polje.Value;

            int najveća_dužina = (int)Najveća_Dužina_Polje.Value+1;

            int najveća_širina = (int)Najveća_Širina_Polje.Value+1;

            int dozvoljena_najmanja_dužina = najmanja_dužina;

            int dozvoljena_najmanja_širina = najmanja_širina;

            int dozvoljena_najveća_dužina = najveća_dužina;

            int dozvoljena_najveća_širina = najveća_širina;

            int željena_oscilacija_dužine = (int)Oscilacija_Dužine_Polje.Value;

            int željena_oscilacija_širine = (int)Oscilacija_Širine_Polje.Value;

            int brojač = 0;

            int dužina = 0;

            int širina = 0;

            Tabela_Dimenzije_Elemenata.Rows.Clear();

            Tabela_Dimenzije_Elemenata.RowCount = željeni_broj_elemenata;

            #endregion

            //

            // Generiši dimenzije prvog elementa

            //

            #region - Metoda -

            dužina = slučajan_broj.Next(dozvoljena_najmanja_dužina,dozvoljena_najveća_dužina);

            // Vrednost mora biti deljiva brojem deset

            while((dužina%10) != 0)

            {

                dužina = slučajan_broj.Next(dozvoljena_najmanja_dužina,dozvoljena_najveća_dužina);

            }

            širina = slučajan_broj.Next(dozvoljena_najmanja_širina,dozvoljena_najveća_širina);

            // Vrednost mora biti deljiva brojem deset

            while((širina%10) != 0)

            {

                širina = slučajan_broj.Next(dozvoljena_najmanja_širina,dozvoljena_najveća_širina);

            }

            Tabela_Dimenzije_Elemenata[0,brojač].Value = dužina.ToString();

            Tabela_Dimenzije_Elemenata[1,brojač].Value = širina.ToString();

            brojač++;

            //Ako je dozvoljena rotacija elemenata

            if(Dozvoljena_Rotacija_Elementa_Izbor.Checked)

            {

                //Zameni i upamti vrednosti za dužinu i širinu

                Tabela_Dimenzije_Elemenata[0,brojač].Value = širina.ToString();

                Tabela_Dimenzije_Elemenata[1,brojač].Value = dužina.ToString();

                brojač++;

            }

            #endregion

            //

            // Generiši dimenzije ostalih elemenata

            // uz primenu dozvoljene oscilacije dimenzija predhodnog elementa

            //

            #region - Metoda -

            while (brojač<željeni_broj_elemenata)

            {

                if(Oscilacija_Dužine_Izbor.Checked)

                {

                    dozvoljena_najmanja_dužina = dužina - željena_oscilacija_dužine;

                    if(dozvoljena_najmanja_dužina<najmanja_dužina)

                    {

                        dozvoljena_najmanja_dužina = najmanja_dužina;

                    }

                    dozvoljena_najveća_dužina = dužina + željena_oscilacija_dužine;

                    if(dozvoljena_najveća_dužina>najveća_dužina)

                    {

                        dozvoljena_najveća_dužina = najveća_dužina;

                    }

                }

                if(Oscilacija_Širine_Izbor.Checked)

                {

                    dozvoljena_najmanja_širina = širina - željena_oscilacija_širine;

                    if(dozvoljena_najmanja_širina<najmanja_širina)

                    {

                        dozvoljena_najmanja_širina = najmanja_širina;

                    }

                    dozvoljena_najveća_širina = širina + željena_oscilacija_širine;

                    if(dozvoljena_najveća_širina>najveća_širina)

                    {

                        dozvoljena_najveća_širina = najveća_širina;

                    }

                }

                dužina = slučajan_broj.Next(dozvoljena_najmanja_dužina,dozvoljena_najveća_dužina);

                // Vrednost mora biti deljiva brojem deset

                while((dužina%10) != 0)

                {

                    dužina = slučajan_broj.Next(dozvoljena_najmanja_dužina,dozvoljena_najveća_dužina);

                }

                širina = slučajan_broj.Next(dozvoljena_najmanja_širina,dozvoljena_najveća_širina);

                // Vrednost mora biti deljiva brojem deset

                while((širina%10) != 0)

                {

                    širina = slučajan_broj.Next(dozvoljena_najmanja_širina,dozvoljena_najveća_širina);

                }

                Tabela_Dimenzije_Elemenata[0,brojač].Value = dužina.ToString();

                Tabela_Dimenzije_Elemenata[1,brojač].Value = širina.ToString();

                brojač++;

                //Ako je dozvoljena rotacija elemenata

                if(Dozvoljena_Rotacija_Elementa_Izbor.Checked && brojač<željeni_broj_elemenata)

                {

                    //Zameni i upamti vrednosti za dužinu i širinu

                    Tabela_Dimenzije_Elemenata[0,brojač].Value = širina.ToString();

                    Tabela_Dimenzije_Elemenata[1,brojač].Value = dužina.ToString();

                    brojač++;

                }

            }

            #endregion

            //

            // Sortiraj dimenzije na osnovu vrednosti dužine i širine elementata

            //

            Prilagodi_Format_Podataka_U_Tabeli_Za_Sortiranje();

            Tabela_Dimenzije_Elemenata.Sort(Column1, ListSortDirection.Descending);

            Prilagodi_Format_Vrednostima_U_Tabeli_Za_Potrebe_Pregleda();

            //

            // Snimi dimenzije u fajl 'Dimenzije elemenata.txt'

            //

            #region - Metoda -

            dužina = 0;

            širina = 0;

            brojač = 0;

            while (brojač<željeni_broj_elemenata)

            {

                dužina = int.Parse(Tabela_Dimenzije_Elemenata[0,brojač].Value.ToString());

                širina = int.Parse(Tabela_Dimenzije_Elemenata[1,brojač].Value.ToString());

                linija = dužina.ToString() + "," + širina.ToString();

                snimi.WriteLine(linija);

                brojač++;

            }

            snimi.Close();

            snimi.Dispose();

            #endregion

        }

        void Generiši_Dimenzije_Bez_Ograničenja()

        {

            #region - Deklaracija i inicijalizacija promenljivih -

            const string naziv_dokumenta = "Dimenzije elemenata.txt";

            string linija = string.Empty;

            StreamWriter snimi = new StreamWriter(naziv_dokumenta,false,Encoding.UTF8);

            Random slučajan_broj = new Random();

            int željeni_broj_elemenata = (int)Željeni_Broj_Elemenata_Polje.Value;

            int najmanja_dužina = (int)Najmanja_Dužina_Polje.Value;

            int najmanja_širina = (int)Najmanja_Širina_Polje.Value;

            int najveća_dužina = (int)Najveća_Dužina_Polje.Value+1;

            int najveća_širina = (int)Najveća_Širina_Polje.Value+1;

            int brojač = 0;

            int dužina = 0;

            int širina = 0;

            Tabela_Dimenzije_Elemenata.Rows.Clear();

            Tabela_Dimenzije_Elemenata.RowCount = željeni_broj_elemenata;

            #endregion

            //

            // Generiši željeni broj dimenzija elemenata

            //

            #region - Metoda -

            while (brojač<željeni_broj_elemenata)

            {

                dužina = slučajan_broj.Next(najmanja_dužina,najveća_dužina);

                // Vrednost mora biti deljiva brojem deset

                while((dužina%10) != 0)

                {

                    dužina = slučajan_broj.Next(najmanja_dužina,najveća_dužina);

                }

                širina = slučajan_broj.Next(najmanja_širina,najveća_širina);

                // Vrednost mora biti deljiva brojem deset

                while((širina%10) != 0)

                {

                    širina = slučajan_broj.Next(najmanja_širina,najveća_širina);

                }

                Tabela_Dimenzije_Elemenata[0,brojač].Value = dužina.ToString();

                Tabela_Dimenzije_Elemenata[1,brojač].Value = širina.ToString();

                brojač++;

                //Ako je dozvoljena rotacija elemenata

                if(Dozvoljena_Rotacija_Elementa_Izbor.Checked && brojač<željeni_broj_elemenata)

                {

                    //Zameni i upamti vrednosti za dužinu i širinu

                    Tabela_Dimenzije_Elemenata[0,brojač].Value = širina.ToString();

                    Tabela_Dimenzije_Elemenata[1,brojač].Value = dužina.ToString();

                    brojač++;

                }

            }

            #endregion

            //

            // Sortiraj dimenzije na osnovu vrednosti dužine i širine elementata

            //

            Prilagodi_Format_Podataka_U_Tabeli_Za_Sortiranje();

            Tabela_Dimenzije_Elemenata.Sort(Column1, ListSortDirection.Descending);

            Prilagodi_Format_Vrednostima_U_Tabeli_Za_Potrebe_Pregleda();

            //

            // Snimi dimenzije u fajl 'Dimenzije elemenata.txt'

            //

            #region - Metoda -

            dužina = 0;

            širina = 0;

            brojač = 0;

            while (brojač<Tabela_Dimenzije_Elemenata.RowCount)

            {

                dužina = int.Parse(Tabela_Dimenzije_Elemenata[0,brojač].Value.ToString());

                širina = int.Parse(Tabela_Dimenzije_Elemenata[1,brojač].Value.ToString());

                linija = dužina.ToString() + "," + širina.ToString();

                snimi.WriteLine(linija);

                brojač++;

            }

            snimi.Close();

            snimi.Dispose();

            #endregion

        }

        void Generiši_Dimenzije_Click(object sender, EventArgs e)

        {

            Tabela_Dimenzije_Elemenata.Enabled = true;

            Generiši_Dimenzije();

        }

        void Generiši_Dimenzije()

        {

            Cursor = Cursors.WaitCursor;

            if(Ne_Dozvoljene_Kopije_Elemenata_Izbor.Checked && Ne_Dozvoljene_Kopije_Elemenata_Izbor.Enabled)

            {

                Generiši_Dimenzije_Bez_Kopija();

            }

            else if(Oscilacija_Dužine_Izbor.Checked || Oscilacija_Širine_Izbor.Checked)

            {

                Generiši_Dimenzije_Sa_Dozvoljenom_Oscilacijom_Dimenzija();

            }

            else

            {

                Generiši_Dimenzije_Bez_Ograničenja();

            }

            Cursor = Cursors.Default;

        }

        #endregion

        #region -   Metode za ispitivanje i sortiranje   -

        void Da_Li_Može_Bez_Kopija_Elemenata()

        {

            #region - Deklaracija i inicijalizacija promenljivih -

            int željeni_broj_elemenata = (int)Željeni_Broj_Elemenata_Polje.Value;

            int mogući_broj_dimenzija = 0;

            int najmanja_dužina = (int)Najmanja_Dužina_Polje.Value;

            int najmanja_širina = (int)Najmanja_Širina_Polje.Value;

            int najveća_dužina = (int)Najveća_Dužina_Polje.Value;

            int najveća_širina = (int)Najveća_Širina_Polje.Value;

            int opseg_dužine = 0;

            int opseg_širine = 0;

            int i = 0;

            int j = 0;

            int k = 0;

            #endregion

            //

            // Izračunaj mogući broj jedinstvenih dimenzija elemenata,

            // pri zadatim vrednostima opsega

            // za najveću i najmanju vrednost dužine i širine elementa

            // u zavisnosti od dozvoljene ili ne dozoljene rotacije elemenata

            //

            #region - Metoda -

            opseg_dužine = (najveća_dužina - najmanja_dužina)/10 + 1;

            opseg_širine = (najveća_širina - najmanja_širina)/10 + 1;

            for(i=najmanja_dužina;i<=najveća_dužina;i+=10)

            {

                for(j=najmanja_širina;j<=najveća_širina;j+=10)

                {

                    if(i==j)

                    {

                        k++; // broj istih vrednosti dva opsega

                    }

                }

            }

            i = opseg_dužine - k; // broj različitih vrednosti za opseg dužine

            j = opseg_širine - k; // broj različitih vrednosti za opseg širine

            //

            // Mogući broj jedinstvenih dimenzija elemenata

            //

            // Ako je rotacija elemenata dozvoljena

            if(Dozvoljena_Rotacija_Elementa_Izbor.Checked)

            {

                mogući_broj_dimenzija = (k*k) + (k*i*2) + (k*j*2) + (i*j*2);

            }

            // Ako rotacija elemenata nije dozvoljena

            else

            {

                mogući_broj_dimenzija = (k*k) + (k*i) + (k*j) + (i*j);

            }

            // Ako je izabrana opcija bez kopija

            if(Ne_Dozvoljene_Kopije_Elemenata_Izbor.Checked)

            {

                // Ako je mogući broj jedinstvenih dimenzija elemenata

                // veći od dozvoljenog maksimuma

                if(mogući_broj_dimenzija>10000)

                {

                    mogući_broj_dimenzija = 10000;

                }

                // Prikaži mogući broj dimenzija

                Maksimalni_Broj_Elemenata_Polje.Text = mogući_broj_dimenzija.ToString();

                Željeni_Broj_Elemenata_Polje.Maximum = mogući_broj_dimenzija;

            }

            // Ako je dozvoljeno generisati kopije

            else if(Dozvoljene_Kopije_Elemenata_Izbor.Checked)

            {

                // Prikaži dozvoljeni maksimum broja elemenata

                Maksimalni_Broj_Elemenata_Polje.Text = "10000";

                Željeni_Broj_Elemenata_Polje.Maximum = 10000;

            }

            #endregion

        }

        void Tabela_Dimenzije_Elemenata_Column_Header_Click(object sender, DataGridViewCellMouseEventArgs e)

        {

            //

            // Sortiraj dimenzije elemenata u tabeli

            // suprotnim redosledom sortiranja od predhodnog

            //

            Prilagodi_Format_Podataka_U_Tabeli_Za_Sortiranje();

            if(Tabela_Dimenzije_Elemenata.SortOrder == SortOrder.Descending)

            {

                Tabela_Dimenzije_Elemenata.Sort(Tabela_Dimenzije_Elemenata.Columns[e.ColumnIndex], ListSortDirection.Ascending);

            }

            else

            {

                Tabela_Dimenzije_Elemenata.Sort(Tabela_Dimenzije_Elemenata.Columns[e.ColumnIndex], ListSortDirection.Descending);

            }

            Prilagodi_Format_Vrednostima_U_Tabeli_Za_Potrebe_Pregleda();

        }

        void Prilagodi_Format_Podataka_U_Tabeli_Za_Sortiranje()

        {

            int dužina = 0;

            int širina = 0;

            int brojač = 0;

            //Prilagodi format vrednostima u tabeli za potrebe sortiranja

            while(brojač<Tabela_Dimenzije_Elemenata.RowCount)

            {

                dužina = int.Parse(Tabela_Dimenzije_Elemenata[0,brojač].Value.ToString());

                širina = int.Parse(Tabela_Dimenzije_Elemenata[1,brojač].Value.ToString());

                Tabela_Dimenzije_Elemenata[0,brojač].Value = dužina.ToString("00000");

                Tabela_Dimenzije_Elemenata[1,brojač].Value = širina.ToString("00000");

                brojač++;

            }

        }

        void Prilagodi_Format_Vrednostima_U_Tabeli_Za_Potrebe_Pregleda()

        {

            int dužina = 0;

            int širina = 0;

            int brojač = 0;

            //Prilagodi format vrednostima u tabeli za potrebe pregleda

            brojač = 0;

            while(brojač<Tabela_Dimenzije_Elemenata.RowCount)

            {

                dužina = int.Parse(Tabela_Dimenzije_Elemenata[0,brojač].Value.ToString());

                širina = int.Parse(Tabela_Dimenzije_Elemenata[1,brojač].Value.ToString());

                Tabela_Dimenzije_Elemenata[0,brojač].Value = dužina.ToString();

                Tabela_Dimenzije_Elemenata[1,brojač].Value = širina.ToString();

                brojač++;

            }

        }

        void Sortiraj_Dimenzije_Elemenata(object sender, DataGridViewSortCompareEventArgs e)

        {

            // Obrada događaja SortCompare,

            // koji se pokreće svaki put

            // kada se upoređuju vrednosti ćelija zbog sortiranja tabele.

            // Sortira podatke u tabeli na osnovu odabranog redosleda,

            // rastućeg ili opadajućeg, prvo upoređujući vrednosti ćelija u prvoj,

            // odabranoj koloni, a zatim, ukoliko su vrednosti iste, 

            // upoređujući pripadajuće vrednosti dimenzija elemenata u ćelijama u drugoj koloni.

            int odabrana_kolona  = 0;

            int druga_kolona = 0;

            // Određuje koja kolona se prvo sortira

            odabrana_kolona = e.Column.Index;

            // Određuje koja kolona se alternativno sortira

            if(odabrana_kolona == 0)

                druga_kolona = 1;

            else

                druga_kolona = 0;

            // Upoređuje i sortira vrednosti ćelija u prvoj, odabranoj, koloni

            e.SortResult = System.String.Compare(

                Tabela_Dimenzije_Elemenata.Rows[e.RowIndex1].Cells[odabrana_kolona].Value.ToString(),

                Tabela_Dimenzije_Elemenata.Rows[e.RowIndex2].Cells[odabrana_kolona].Value.ToString());

            // Ako su upoređene vrednosti u prvoj koloni iste

            // uporedi vrednosti u drugoj koloni

            if (e.SortResult == 0)

            {

                e.SortResult = System.String.Compare(

                    Tabela_Dimenzije_Elemenata.Rows[e.RowIndex1].Cells[druga_kolona].Value.ToString(),

                    Tabela_Dimenzije_Elemenata.Rows[e.RowIndex2].Cells[druga_kolona].Value.ToString());

            }

            e.Handled = true;

        }

        #endregion

        #region -   Obrada događaja 'Promena izbora opcija'   -

        void Oscilacija_Dužine_Izbor_Promenjen(object sender, EventArgs e)

        {

            if(Oscilacija_Dužine_Izbor.Checked)

            {

                Oscilacija_Dužine_Polje.Enabled = true;

                Ne_Dozvoljene_Kopije_Elemenata_Izbor.Enabled = false;

                Dozvoljene_Kopije_Elemenata_Izbor.Checked = true;

            }

            else

            {

                Oscilacija_Dužine_Polje.Enabled = false;

                if(!Oscilacija_Širine_Izbor.Checked)

                {

                    Ne_Dozvoljene_Kopije_Elemenata_Izbor.Enabled = true;

                    Da_Li_Može_Bez_Kopija_Elemenata();

                }

            }

        }

        void Oscilacija_Širine_Izbor_Promenjen(object sender, EventArgs e)

        {

            if(Oscilacija_Širine_Izbor.Checked)

            {

                Oscilacija_Širine_Polje.Enabled = true;

                Ne_Dozvoljene_Kopije_Elemenata_Izbor.Enabled = false;

                Dozvoljene_Kopije_Elemenata_Izbor.Checked = true;

            }

            else

            {

                Oscilacija_Širine_Polje.Enabled = false;

                if(!Oscilacija_Dužine_Izbor.Checked)

                {

                    Ne_Dozvoljene_Kopije_Elemenata_Izbor.Enabled = true;

                    Da_Li_Može_Bez_Kopija_Elemenata();

                }

            }

        }

        void Dozvoljene_Kopije_Elemenata_Izbor_Promenjen(object sender, EventArgs e)

        {

            if(Dozvoljene_Kopije_Elemenata_Izbor.Checked)

            {

                Da_Li_Može_Bez_Kopija_Elemenata();

            }

        }

        void Ne_Dozvoljene_Kopije_Elemenata_Izbor_Promenjen(object sender, EventArgs e)

        {

            if(Ne_Dozvoljene_Kopije_Elemenata_Izbor.Checked)

            {

                Da_Li_Može_Bez_Kopija_Elemenata();

            }

        }

        void Dozvoljena_Rotacija_Elementa_Izbor_Promenjen(object sender, EventArgs e)

        {

            if(Dozvoljena_Rotacija_Elementa_Izbor.Checked &&

               !Oscilacija_Dužine_Izbor.Checked &&

               !Oscilacija_Širine_Izbor.Checked)

            {

                Da_Li_Može_Bez_Kopija_Elemenata();

            }

        }

        void Ne_Dozvoljena_Rotacija_Elemenata_Izbor_Promenjen(object sender, EventArgs e)

        {

            if(Ne_Dozvoljena_Rotacija_Elemenata_Izbor.Checked &&

               !Oscilacija_Dužine_Izbor.Checked &&

               !Oscilacija_Širine_Izbor.Checked)

            {

                Da_Li_Može_Bez_Kopija_Elemenata();

            }

        }

        #endregion

        #region -   Obrada događaja 'Promena ulaznih vrednosti'   -

        void Željeni_Broj_Elemenata_Polje_Promena(object sender, EventArgs e)

        {

            if(!Oscilacija_Dužine_Izbor.Checked && !Oscilacija_Širine_Izbor.Checked)

            {

                Da_Li_Može_Bez_Kopija_Elemenata();

            }

        }

        void Najmanja_Dužina_Polje_Promena(object sender, EventArgs e)

        {

            if(Najmanja_Dužina_Polje.Value%10!=0)

            {

                MessageBox.Show(" Poslednja cifra unetog broja mora biti nula.   \n" +

                                " npr. 10 , 50 , 100 , 110 , 250 , 600 , ...   ",

                                "  Greška pri unosu podataka !",

                                MessageBoxButtons.OK,

                                MessageBoxIcon.Error);

                Najmanja_Dužina_Polje.Value = Najmanja_Dužina_Polje.Minimum;

            }

            else

            {

                Najveća_Dužina_Polje.Minimum = Najmanja_Dužina_Polje.Value + 10;

                Oscilacija_Dužine_Polje.Maximum = Najveća_Dužina_Polje.Value - Najmanja_Dužina_Polje.Value;

            }

            if(!Oscilacija_Dužine_Izbor.Checked && !Oscilacija_Širine_Izbor.Checked)

            {

                Da_Li_Može_Bez_Kopija_Elemenata();

            }

        }

        void Najveća_Dužina_Polje_Promena(object sender, EventArgs e)

        {

            if(Najveća_Dužina_Polje.Value%10!=0)

            {

                MessageBox.Show(" Poslednja cifra unetog broja mora biti nula.   \n" +

                                " npr. 10 , 50 , 100 , 110 , 250 , 600 , ...   ",

                                "  Greška pri unosu podataka !",

                                MessageBoxButtons.OK,

                                MessageBoxIcon.Error);

                Najveća_Dužina_Polje.Value = Najveća_Dužina_Polje.Maximum;

            }

            else

            {

                Najmanja_Dužina_Polje.Maximum = Najveća_Dužina_Polje.Value - 10;

                Oscilacija_Dužine_Polje.Maximum = Najveća_Dužina_Polje.Value - Najmanja_Dužina_Polje.Value;

            }

            if(!Oscilacija_Dužine_Izbor.Checked && !Oscilacija_Širine_Izbor.Checked)

            {

                Da_Li_Može_Bez_Kopija_Elemenata();

            }

        }

        void Najmanja_Širina_Polje_Promena(object sender, EventArgs e)

        {

            if(Najmanja_Širina_Polje.Value%10!=0)

            {

                MessageBox.Show(" Poslednja cifra unetog broja mora biti nula.   \n" +

                                " npr. 10 , 50 , 100 , 110 , 250 , 600 , ...   ",

                                "  Greška pri unosu podataka !",

                                MessageBoxButtons.OK,

                                MessageBoxIcon.Error);

                Najmanja_Širina_Polje.Value = Najmanja_Širina_Polje.Minimum;

            }

            else

            {

                Najveća_Širina_Polje.Minimum = Najmanja_Širina_Polje.Value + 10;

                Oscilacija_Širine_Polje.Maximum = Najveća_Širina_Polje.Value - Najmanja_Širina_Polje.Value;

            }

            if(!Oscilacija_Dužine_Izbor.Checked && !Oscilacija_Širine_Izbor.Checked)

            {

                Da_Li_Može_Bez_Kopija_Elemenata();

            }

        }

        void Najveća_Širina_Polje_Promena(object sender, EventArgs e)

        {

            if(Najveća_Širina_Polje.Value%10!=0)

            {

                MessageBox.Show(" Poslednja cifra unetog broja mora biti nula.   \n" +

                                " npr. 10 , 50 , 100 , 110 , 250 , 600 , ...   ",

                                "  Greška pri unosu podataka !",

                                MessageBoxButtons.OK,

                                MessageBoxIcon.Error);

                Najveća_Širina_Polje.Value = Najveća_Širina_Polje.Maximum;

            }

            else

            {

                Najmanja_Širina_Polje.Maximum = Najveća_Širina_Polje.Value - 10;

                Oscilacija_Širine_Polje.Maximum = Najveća_Širina_Polje.Value - Najmanja_Širina_Polje.Value;

            }

            if(!Oscilacija_Dužine_Izbor.Checked && !Oscilacija_Širine_Izbor.Checked)

            {

                Da_Li_Može_Bez_Kopija_Elemenata();

            }

        }

        void Oscilacija_Dužine_Polje_Promena(object sender, EventArgs e)

        {

            if(Oscilacija_Dužine_Polje.Value%10!=0)

            {

                MessageBox.Show(" Poslednja cifra unetog broja mora biti nula.   \n" +

                                " npr. 10 , 50 , 100 , 110 , 250 , 600 , ...   ",

                                "  Greška pri unosu podataka !",

                                MessageBoxButtons.OK,

                                MessageBoxIcon.Error);

                Oscilacija_Dužine_Polje.Value = Oscilacija_Dužine_Polje.Minimum;

            }

        }

        void Oscilacija_Širine_Polje_Promena(object sender, EventArgs e)

        {

            if(Oscilacija_Širine_Polje.Value%10!=0)

            {

                MessageBox.Show(" Poslednja cifra unetog broja mora biti nula.   \n" +

                                " npr. 10 , 50 , 100 , 110 , 250 , 600 , ...   ",

                                "  Greška pri unosu podataka !",

                                MessageBoxButtons.OK,

                                MessageBoxIcon.Error);

                Oscilacija_Širine_Polje.Value = Oscilacija_Širine_Polje.Minimum;

            }

        }

        #endregion

        #region -   Obrada događaja 'Zahtev za pomoć'   -

        void Isključi_Pomoć(object sender, EventArgs e)

        {

            toolTip1.Active = false;

        }

        void Željeni_Broj_Elemenata_Polje_Pomoć(object sender, HelpEventArgs hlpevent)

        {

            toolTip1.Active = true;

            toolTip1.ToolTipTitle = " Broj elemenata";

            toolTip1.ToolTipIcon = ToolTipIcon.Info;

            toolTip1.Show("Polje 'Broj elemenata' je namenjeno,\n" +

                          "za izbor željenog broja elemenata,\n" +

                          "za koje treba generisati dimenzije.\n",

                          Željeni_Broj_Elemenata_Polje,0,0);

        }

        void Maksimalni_Broj_Elemenata_Polje_Pomoć(object sender, HelpEventArgs hlpevent)

        {

            toolTip1.Active = true;

            toolTip1.ToolTipTitle = " Maksimalan broj elemenata";

            toolTip1.ToolTipIcon = ToolTipIcon.Info;

            toolTip1.Show("Polje 'Maksimalan broj elemenata' je namenjeno,\n" +

                          "za prikaz maksimalnog broja elemenata,\n" +

                          "za koje generator može da generiše dimenzije.\n",

                          Maksimalni_Broj_Elemenata_Polje,0,0);

        }

        void Najmanja_Dužina_Polje_Pomoć(object sender, HelpEventArgs hlpevent)

        {

            toolTip1.Active = true;

            toolTip1.ToolTipTitle = " Najmanja dužina";

            toolTip1.ToolTipIcon = ToolTipIcon.Info;

            toolTip1.Show("Polje 'Najmanja dužina' je namenjeno,\n" +

                          "za izbor najmanje dužine elementa,\n" +

                          "koju generator sme da generiše.\n",

                          Najmanja_Dužina_Polje,0,0);

        }

        void Najmanja_Širina_Polje_Pomoć(object sender, HelpEventArgs hlpevent)

        {

            toolTip1.Active = true;

            toolTip1.ToolTipTitle = " Najmanja širina";

            toolTip1.ToolTipIcon = ToolTipIcon.Info;

            toolTip1.Show("Polje 'Najmanja širina' je namenjeno,\n" +

                          "za izbor najmanje širine elementa,\n" +

                          "koju generator sme da generiše.\n",

                          Najmanja_Širina_Polje,0,0);

        }

        void Najveća_Dužina_Polje_Pomoć(object sender, HelpEventArgs hlpevent)

        {

            toolTip1.Active = true;

            toolTip1.ToolTipTitle = " Najveća dužina";

            toolTip1.ToolTipIcon = ToolTipIcon.Info;

            toolTip1.Show("Polje 'Najveća dužina' je namenjeno,\n" +

                          "za izbor najveće dužine elementa,\n" +

                          "koju generator sme da generiše.\n",

                          Najveća_Dužina_Polje,0,0);

        }

        void Najveća_Širina_Polje_Pomoć(object sender, HelpEventArgs hlpevent)

        {

            toolTip1.Active = true;

            toolTip1.ToolTipTitle = " Najveća širina";

            toolTip1.ToolTipIcon = ToolTipIcon.Info;

            toolTip1.Show("Polje 'Najveća širina' je namenjeno,\n" +

                          "za izbor najveće širine elementa,\n" +

                          "koju generator sme da generiše.\n",

                          Najveća_Širina_Polje,0,0);

        }

        void Dozvoljena_Rotacija_Elementa_Izbor_Pomoć(object sender, HelpEventArgs hlpevent)

        {

            toolTip1.Active = true;

            toolTip1.ToolTipTitle = " Rotacija elemenata";

            toolTip1.ToolTipIcon = ToolTipIcon.Info;

            toolTip1.Show("Opcija 'Rotacija elemenata' omogućava da se već generisane vrednosti za ,\n" +

                          "dužinu i širinu elementa međusobno zamene i na taj način dobije novi ,\n" +

                          "par vrednosti koji bi bio upamćen kao dimenzije novog elementa.\n",

                          Dozvoljena_Rotacija_Elementa_Izbor,0,0);

        }

        void Dozvoljene_Kopije_Elemenata_Izbor_Pomoć(object sender, HelpEventArgs hlpevent)

        {

            toolTip1.Active = true;

            toolTip1.ToolTipTitle = " Kopije elemenata";

            toolTip1.ToolTipIcon = ToolTipIcon.Info;

            toolTip1.Show("Opcija 'Kopije elemenata' kontroliše generisanje\n" +

                          "istih vrednosti za dužinu i širinu elemenata,\n" +

                          "odnosno pojavu kopija elemenata.\n",

                          Dozvoljene_Kopije_Elemenata_Izbor,0,0);

        }

        void Oscilacija_Dužine_Polje_Pomoć(object sender, HelpEventArgs hlpevent)

        {

            toolTip1.Active = true;

            toolTip1.ToolTipTitle = " Dozvoljena oscilacija dimenzija";

            toolTip1.ToolTipIcon = ToolTipIcon.Info;

            toolTip1.Show("Opcija 'Dozvoljena oscilacija dimenzija'\n" +

                          "kontroliše razliku u dimenzijama između elemenata tako što\n" +

                          "određuje maksimalnu razliku u dimenzijama, između elementa koji je već\n" +

                          "generisan i elementa koji tek treba da se generiše. Na ovaj način se\n" +

                          "dobijaju ujednačene dimenzije elemenata, i mnogo veći broj istih dimenzija\n",

                          Oscilacija_Dužine_Polje,0,0);

        }

        void Generiši_Dimenzije_Dugme_Help(object sender, HelpEventArgs hlpevent)

        {

            toolTip1.Active = true;

            toolTip1.ToolTipTitle = " Generiši";

            toolTip1.ToolTipIcon = ToolTipIcon.Info;

            toolTip1.Show("Klikni da bi pokrenuo generator.\n",

                          Generiši_Dimenzije_Dugme,70,-70);

        }

        #endregion

    }

}

/************************************************************************

 * Program Licence :                                                    *

 *                                                                      *

 * Copyright 2013 , Perić Željko                                        *

 * (periczeljkosmederevo@yahoo.com)                                     *

 *                                                                      *

 * According to it's main purpose , this program is licensed            *

 * under the therms of 'Free Software' licence agreement.               *

 *                                                                      *

 * If You do not know what those therms applies to                      *

 * please read explanation at the following link :                      *

 * (http://www.gnu.org/philosophy/free-sw.html.en)                      *

 *                                                                      *

 * Since it is Free Software this program has no warranty of any kind.  *

 ************************************************************************

 * Ethical Notice :                                                     *

 *                                                                      *

 * It is not ethical to change program code signed by it's author       *

 * and then to redistribute it under the same author name ,             *

 * especially if it is incorrect.                                       *

 *                                                                      *

 * It is recommended that if You make improvement in program code ,     *

 * to make remarks of it and then to sign it with Your own name ,       *

 * for further redistribution as new major version of program.          *

 *                                                                      *

 * Author name and references of old program code version should be     *

 * kept , for tracking history of program development.                  *

 *                                                                      *

 * For any further information please contact code author at his email. *

 ************************************************************************/

/************************************

 * List Of Revisions                *

 ************************************

 * Major revision of version 2.0    *

 * Perić Željko 20.02.2014          *

 * new comments                     *

 * new options                      *

 * help function                    *

 * sort function changed            *

 * spelling checked                 *

 * New version number 3.0           *

 ************************************/

/************************************

 * List Of Revisions                *

 ************************************

 * Minor revision of version 3.0    *

 * Perić Željko 09.12.2015          *

 * new comments                     *

 * sort methods changed             *

 * spelling checked                 *

 * New version number 3.1           *

 ************************************/