Griser une fenêtre en arrière plan

Version imprimable

31/07/2006, 14h28
kurkaine

Griser une fenêtre en arrière plan

Bonjour,

Quelqu'un à déjà essayer de griser les fenêtres en arrière plan ? J'aimerai assombrir les fenêtres qui sont en arrière plan afin de ne pas surcharger mon application avec des fenêtres superposé.

Merchiche :roll:
31/07/2006, 15h25
ero-sennin

Salut,

Bonne question, je ne sais pas y répondre lol.
Ce que je fais, pour éviter d'avoir trop de fenêtre à l'écran, soit je détruis la fiche si j'en ai plus besoin, ou soit je mets false à la propriété visible de la Form.
Après tu peux afficher une fenêtre via un ShowModal, ce qui a pour conséquence d'empêcher à l'utilisateur aux autres fiches. Seul la fiche qui vient d'être appelée via le ShowModal est "utilisable".

Enfin bref, je ne crois pas que je réponds à ta question donc j'arrête la discussion ici :mrgreen:

@ +
01/08/2006, 08h01
kurkaine

Ca reste une solution

Effectivement, j'utiliserai ta technique si vraiment je ne trouve pas comment faire pour griser les fenêtres. Mais je suis sûr que c'est possible, vu que sous certains environnements (windev par ex) cette fonction de grisage est activé par défaut.

Si quelqu'un à une idée...

PS: je ne peux pas détruire les fenetres, puisque c'est une appli mdi, qui appel une fenetre d'insertion, puis confirmation... En fait, j'ai au plus trois ou quatre étage" .
01/08/2006, 08h43
kurkaine

A la limite, si quelqu'un sait comment appliquer un masque à une fenêtre afin de griser cette fenêtre (par l'utilisation d'une image...) je pourrais programmer une fonction de grisage.

Salut !

Peut-être en essayant de surcharger la méthode TCustomForm::PaintWindow qui se présente comme ceci :

Code:

virtual void __fastcall PaintWindow(HDC DC);

Il suffit donc de déclarer la nouvelle méthode dans la classe dérivée (la MDIForm) :

Code:

void __fastcall PaintWindow(HDC DC);

A ce stade, on aura donc deux méthodes qui vont coexister :
- la première relève de la classe TCustomForm
- le deuxième relève de la classe dérivée de TCustomForm : la MDIForm

Si c'est possible (donc aussi simple que ça...), la surcharge devient :
Code:

1 2 3 4 5 6 7 8 9 10 11 void __fastcall TForm...::PaintWindow(HDC DC) { if(Form1->ActiveMDIChild == this) { TCustomForm::PaintWindow(DC); // fait le travail normal de dessin } else { //... a faire mais j'en sais pas plus pour l'instant... } }
C'est juste une idée parce que je n'ai pas le temps pour l'instant de tester et donc d'aller plus loin... !

A plus !

Salut !

J'ai testé ce que je pensais être une astuce... hélas, à première vue.... !

Voici ce que tu peux faire :

- Ajouter une propriété dans la class des MDIChild

Code:

TColor ActiveColor;

- Affecter le code suivant à l'événement OnPaint de chaque MDIChild, ici pour ma TForm2 et j'ai fait pareil pour ma TForm3, chacune étant doté de composants divers...
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 void __fastcall TForm2::FormPaint(TObject *Sender) { if(Form1->ActiveMDIChild == this) { if(Color != ActiveColor) { Color = ActiveColor; for(int j = 0; j < ControlCount; j++) { Controls[j]->Visible = true; } for(int j = 0; j < Form1->MDIChildCount; j++) { if(Form1->ActiveMDIChild != Form1->MDIChildren[j]) { Form1->MDIChildren[j]->Repaint(); } } } } else { if(Color != clGray) { Color = clGray; for(int j = 0; j < ControlCount; j++) { Controls[j]->Visible = false; } } } }
- Dans le constructeur de chaque MDIChild rajouter l'initialisation de la propriété ActiveColor :

Code:

ActiveColor = Color;

J'ai pris comme couleur le clGray (gris foncé) pour les MDIChild inactives.

Ne pas oublier d'inclure le header de la fiche MDIForm dans l'unité des fiches enfants (MDIChild)

En attendant et à défaut d'avoir plus simple... (c'est un simple premier jet)

A plus !

01/08/2006, 21h27
kurkaine

C'est étrange, lorsque j'ai placé ton code dans une fiche fille, c'est ma fiche fille qui est "grisé", je n'ai pas réussi à appliquer le grisage sur la fiche qui demande l'ouverture d'une autre fiche.

Mais ton idée n'est pas mal du tout, merci. Si jamais tu penses à qq chose d'autre n'hésite pas.

Delphi VS Builder

Ne trouvant aucune réponse, j'ai posté ma question dans le forum Delphi. Plusieurs personnes ont travaillé la question et m'ont répondu. Hélas, le code est en Delphi, n'ayant jamais fait de Delphi j'ai essayé d'adapter le code en c++ mais j'ai une erreurs à l'exécution.

http://www.developpez.net/forums/showthread.php?p=1231586&posted=1

Vous pouvez trouvez ici le code écrit en Delphi. La transcription que j'ai réalisé compile bien mais entre autre, mal écrit cette ligne

Code:

RowOriginal := pRGBArray(BitmapForm.Scanline[iHeight]);

.

Quoi qu'il en soit, voici mon code correspondant en C++ qui ne marche pas encore. Peut-être un spécialiste pourra comprendre d'ou vient l'erreur

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
 
 
#include <windows.h>
#include <Math.hpp>
#include "Fille.h"
//---------------------------------------------------------------------------
 
#define   PIXELCOUNTMAX 32768;
//------------------------------------------------------------------------------
//  Fonction pour fusioner la form et l'image grisé
//
//  @param    FusionForm       Form a fusioner
//  @param    BmpGrise         Bitmap de l'image grisé
//-------------------------------------------------------------------------------}
void TForm1::FusionerImage(TForm *FusionForm,  Graphics::TBitmap *BmpGrise)
{
        PSIZE Size;
 
        TPoint TopLeft, BmpTopLeft;
        TBlendFunction Blend;
 
        SetWindowLong(Handle, GWL_EXSTYLE, GetWindowLong(Handle, GWL_EXSTYLE) | WS_EX_LAYERED) ;
 
        Size->cx = Width;
        Size->cy = Height;
 
        TopLeft.x = FusionForm->BoundsRect.Left;
        TopLeft.y = FusionForm->BoundsRect.Top;
 
        BmpTopLeft = Point(0, 0);
 
        Blend.BlendOp = 0;
        Blend.BlendFlags = 0;
        Blend.SourceConstantAlpha = 255;
        Blend.AlphaFormat = 0;
 
        BmpGrise->PixelFormat = pf32bit;
 
        UpdateLayeredWindow(Handle, GetDC(0), &TopLeft, Size, BmpGrise->Canvas->Handle, &BmpTopLeft, 0, &Blend, 2);
}
 
//----------------------------------------------------------------------------
//  Fonction pour afficher une fenêtre en showmodal et griser celle qui est
//  active pendant l'appel du showmodal
//
//  @param    Fenetre        Form a afficher en Showmodal
//-----------------------------------------------------------------------------}
int TForm1::CustomShowModal(TForm *Fenetre)
{
//  RowOriginal  = ^ARRAY[0..PIXELCOUNTMAX-1] OF TRGBTriple;;
//    RowOriginal  := pRGBArray(BitmapForm.Scanline[iHeight]);
//  pRGBArray  = ^TRGBArray;
//  TRGBArray   = ARRAY[0..PIXELCOUNTMAX-1] OF TRGBTriple;
//  RowOriginal     : pRGBArray;
 
 
//        TRGBTriple TRGBArray[32769];
//        TRGBTriple *RowOriginal = TRGBArray;
 
        THandle *WindowHandle;
        HDC deviceContext;
        Graphics::TBitmap *BitmapForm;
        int icolor;
        byte r,g,b;
        int iheight,iwidth  ;
        TForm *FormGrise;
        int PosLeft,PosTop,delta;
 
        WindowHandle  = (THandle*) Application->MainForm->Handle;
        deviceContext = GetWindowDC(WindowHandle);
 
        try
        {
            BitmapForm              = new Graphics::TBitmap();
            BitmapForm->PixelFormat = pf24bit;
            BitmapForm->Width       = Application->MainForm->Width;
            BitmapForm->Height      = Application->MainForm->Height;
 
            BitBlt(BitmapForm->Canvas->Handle, 0, 0, BitmapForm->Width, BitmapForm->Height,deviceContext, 0, 0, SRCCOPY);
 
        }
        catch (...)
        {
            ReleaseDC(WindowHandle, deviceContext);
        }
                for (iheight =0; iheight < BitmapForm->Height ;iheight++)
                {
                        //RowOriginal  = (TRGBTriple *)  BitmapForm->ScanLine[iheight]);    //-- PB ICI
                        RGBTRIPLE* line_curr =  static_cast<RGBTRIPLE*>(BitmapForm->ScanLine[iheight]);
 
                        for (iwidth =0; iwidth < BitmapForm->Width ; iwidth++)
                        {
 
                                r = line_curr[iwidth].rgbtRed;
                                g = line_curr[iwidth].rgbtGreen;
                                b = lline_curr[iwidth].rgbtBlue;
 
                                icolor  =(r+g+b) / 3;
                                line_curr[iwidth].rgbtRed   = icolor;
                                line_curr[iwidth].rgbtGreen = icolor;
                                line_curr[iwidth].rgbtBlue  = icolor;
                        }
                }
 
                FormGrise                = new TForm(Screen->ActiveForm);
                FormGrise->Name           = "GrayscaleForm";
                FormGrise->Caption        = Application->MainForm->Caption;
 
                 // gérer le cas ou la fenetre active est une MDIChild elle n'a pas le meme parent --//
                if (Application->MainForm->FormStyle == fsMDIChild )
                {
                        PosTop  = Application->MainForm->ClientOrigin.y-(Application->MainForm->Height - Application->MainForm->ClientHeight);
                        PosLeft = Application->MainForm->ClientOrigin.x-(Application->MainForm->Width - Application->MainForm->ClientWidth);
                        delta    = RoundTo((Application->MainForm->Width - Application->MainForm->ClientWidth)/2,0);
 
                        if ( (Application->MainForm->BorderStyle == bsSingle) ||
                             (Application->MainForm->BorderStyle == bsToolWindow))
                        {
                              delta--;
                        }
 
                        FormGrise->Top          = PosTop+delta;
                        FormGrise->Left         = PosLeft+delta;
                }
                else
                {
                        FormGrise->Top            = Application->MainForm->Top;
                        FormGrise->Left           = Application->MainForm->Left;
                }
 
                FormGrise->Width          = Application->MainForm->Width;
                FormGrise->Height         = Application->MainForm->Height;
                FormGrise->DoubleBuffered = true;
                FormGrise->BorderIcons    = Application->MainForm->BorderIcons;
                FormGrise->BorderStyle    = Application->MainForm->BorderStyle;
                FormGrise->Show();
 
                FusionerImage(FormGrise,BitmapForm);
                FormGrise->BringToFront();
 
                BitmapForm->Free();
 
                Fenetre->ShowModal();
 
                if (FormGrise!= NULL)
                        FormGrise->Release();
 
        return 0;
}
void __fastcall TForm1::Button1Click(TObject *Sender)
{
        CustomShowModal(maFille);
}
//---------------------------------------------------------------------------

Voilà, j'espère qu'on trouvera une solution. J'ai une exception sur FusionerImage(FormGrise,BitmapForm);

04/08/2006, 14h28
kurkaine

Je me parle tout seul mais ce n'est pas grave.

Voilà j'ai converti le code, je devais écrire

Code:

PSIZE Size = new SIZE();

dans la fonction FusionnerImage. Cela dit, j'ai des erreurs, mais bon, j'essaie de débugger... 8O

Si j'écris le showModal non dans la fct CustomShowModal mais juste après avoir appelé cette fonction, j'ai bien grisé mon application. Petit problème; lorsque je ferme la fenetre, mon application reste grisé avec des comportement bizarre.