Newsgroup: it.comp.programmare.win32
Titolo: [C++ Builder] Array di TShape distribuiti in tutta l'altezza

Salve,
stavo provando un codice che dovrebbe visualizzare un array  di TShape per 
tutte l'altezza dello schermo, al variare della risoluzione, solo che per 
certe risoluzioni lascia degli spazi bianchi in fondo. Eppure la divisione 
dei valori mi sembra corretta.
TShape* Porzioni[256];
void __fastcall TForm1::FormCreate(TObject *Sender)
{
        Form1->Left = 0;
        Form1->Top = 0;
        Form1->Height = Screen->Height;
        Form1->Width = Screen->Width;
        int tot = 0; // la uso come contatore ed effettivamente alla fine 
vale quanto l'altezza dello schermo.
      // div sarà l'ltezza di ogni TShape
     // resto mi serve per sapere quanti TShape dovranno essere un pixel più 
alti in modo da riempire lo schermo.
            int div = Screen->Height / 256,
            resto = Screen->Height % 256;
        for (int i = 0; i < 256; i++) {
            Porzioni[i] = new TShape(Form1);
            Porzioni[i]->Parent = Form1;
            Porzioni[i]->Height = div;
            if (resto > 0)
                Porzioni[i]->Height++;
            Porzioni[i]->Width = Screen->Width;
            Porzioni[i]->Left = 0;
            Porzioni[i]->Top = div * i;
            if (resto > 0)
                Porzioni[i]->Top++;
            tot += div;
            if (resto > 0)
                tot++;
            resto--;
            Porzioni[i]->Pen->Color = clBlack;
            Porzioni[i]->Brush->Color = clBlack;
        };
        for (int i = 0; i < 256; i++) {
            if (i % 2 == 0) {
                Porzioni[i]->Brush->Color = clYellow;
                Porzioni[i]->Pen->Color = clYellow;
            }
            else {
                Porzioni[i]->Brush->Color = clGreen;
                Porzioni[i]->Pen->Color = clGreen;
            };
        };
}
Grazie 

            Porzioni[i]->Top = div * i;
prova con:
    Porzioni[i]->Top = tot;
Poi se il form ha bordi o barre devi usare altezza e larghezza dell'area 
client, non dello schermo.
Penso tu possa evitare il secondo ciclo per la colorazione.
Infine, usa il costruttore, non OnCreate.
HTH,
-- 
Stefano Frosio
www.esse-effe.com
 

 Infine, usa il costruttore, non OnCreate.
Ok 

 L'i-esimo TShape sarà alla posizione div ripetuto i volte, no?
Mi sono accorto che in effetti c'è differenza a causa del fatto che nel caso 
che avevo scritto, il top veniva settato a div * i con un +1 per i primi 
r-TShape (con r = resto) ma in tal modo, quel +1 non si andava a sommare ad 
ogni ciclo in modo da incrementarsi e diventare +2, +3, etc...
Con il contatore questo avviene. Un modo però per farne a meno può essere:
div * i + (resto > 0 ? i : r)
dove r ha lo stesso valore di resto (quello originale e non subisce 
decrementi).
Saluti 

Nel programma, c'� una parte di codice in cui ogni TShape riceve il colore 
del TShape precedente, producendo cos� uno scorrimento graduale dal basso 
verso l'alto. Qualche mese fa, avendo gi� provato questo stesso programma, 
mi sono accorto che a volte quando ad un TShape dell'array viene assegnato 
un colore, il TShape produce uno sfarfallio e a quanto mi hanno detto il 
problema � legato al fatto che il TShape viene prima invalidato e reso 
bianco e poi colorato. C'� un modo per evitare ci�?
Magari ridefinendo qualche medoto?
Grazie 

 producendo cos� uno scorrimento graduale dal basso verso l'alto.
Volevo dire dall'alto verso il basso. 

 un colore, il TShape produce uno sfarfallio
Ma questi TShape ti servono solo per colorare lo sfondo? Se ï¿½ cosï¿½, ti 
conviene disegnare direttamente sul form, riducendo lo sfarfallio ed 
impiegando molte meno risorse.


 impiegando molte meno risorse.
In pratica, c'ï¿½ un TTimer che genera 10 volte al secondo un colore (una 
terna RGB). Ogni TShape riceve il colore dal precedente e il colore 
precedentemente generato viene assegnato al primo TShape.
Incollo il codice:
void __fastcall TColorSSForm::TempoTimer(TObject *Sender)
{
        if (genera) {
            srand(seed());
            a2 = rand() % 256;
            b2 = rand() % 256;
            c2 = rand() % 256;
            genera = false;
        }
        else {
            a1 > a2 ? a1-- : a1 < a2 ? a1++ : a1;
            b1 > b2 ? b1-- : b1 < b2 ? b1++ : b1;
            c1 > c2 ? c1-- : c1 < c2 ? c1++ : c1;
            for (int i = 255; i > 0; i--) {
                Porzioni[i]->Brush->Color = Porzioni[i - 1]->Brush->Color;
                Porzioni[i]->Pen->Color = Porzioni[i - 1]->Pen->Color;
            };
            Porzioni[0]->Brush->Color = (TColor)RGB(a1, b1, c1);
            Porzioni[0]->Pen->Color = Porzioni[0]->Brush->Color;
            if (a1 == a2 && b1 == b2 && c1 == c2)
                genera = true;
        };
}
Saluti 

Per risolvere il problema dello sfarfallio mi è stato detto di settare a 
true la proprietà DoubleBuffered del componente Parent dei TShape (nel mio 
caso TForm).
Infatti con questa istruzione:
Form1->DoubleBuffered = true;
Non ci sono più sfarfallii nemmeno se il TTimer lo imposto a 1000 esecuzioni 
al secondo.