[quelles classes créer][a partir d'un prgramme sans classes]

Version imprimable

Bonjours, je vous expose mon pb :

j'ai commencé un developpement en WxWidgets, etant totalement newbee en C, C++, et Wxwidgets, j'avait des bgs de partout...
maintenant il est "presque" fonctionnel, mais je ne sait plus du tout par ou commencer pour le refactoriser en OO...

donc, je vait me lancer dnas ce travail, mais, si une ^bonne âme voulait bien me diriger, ne setrait-ce q'un peu...

donc, voici une liste (surement incomplete) des traitements de mon programme :

creation d'une socket d'ecoute
creation d'une oscket client
creation d'une socket serveur
traitements coté serveur :
- "capture" de l'image affichée a l'ecran
- envoie de cette image par le reseau
- attente d'une trame confirmant la reception
- re-envoi d'une nouvelle image
traitement client
- reception de l'image
- affichage a l'ecran
- envoie d'une trame demandant une nouvelle image
traitement que je voudrait implementer
- utilisation de criptage simple par clé publique clef privée
- utilisation du protocole reseau simplounet pour d'autre traitement (TQ un tetris?)

bien entendu, tout ceci est codé comme l'aurait fait, ma grand mere (comme qqun qui s'y connait pas...)

ce que voudrait savoir, c'est surtout quelles classes créer...
je suis en seconde année de BTS info, et j'ai pas eu un seul cours sur la POO... et je doit, pour mon examen rendre un programme OO...

voici mon code, c'est pas vraiment la peine de le regarder...

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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
//---------------------------------------------------------------------------
//
// Name:        vncPeuThreadeFrm.cpp
// Author:      bruno DA SILVA
// Created:     09/01/2006 09:55:45
//
//---------------------------------------------------------------------------
 
#include "vncPeuThreadeFrm.h"
#include "thread2base.h"
#include <windows.h>
#include <wx/image.h>
#include <wx/dcscreen.h>
#include <wx/dc.h>
#include <wx/dcbuffer.h>
#include <wx/scrolwin.h>
//Do not add custom headers.
//wx-dvcpp designer will remove them
////Header Include Start
////Header Include End
 
//----------------------------------------------------------------------------
// vncPeuThreadeFrm
//----------------------------------------------------------------------------
   //Add Custom Events only in the appropriate Block.
   // Code added in  other places will be removed by wx-dvcpp 
  ////Event Table Start
BEGIN_EVENT_TABLE(vncPeuThreadeFrm,wxFrame)
 ////Manual Code Start
 EVT_SOCKET(SERVER_IMG_ID,  vncPeuThreadeFrm::OnServerEventImg)
 EVT_SOCKET(SOCKET_IMG_ID,  vncPeuThreadeFrm::OnSocketEventImg)
 EVT_SOCKET(CLIENT_IMG_ID,  vncPeuThreadeFrm::OnClientEventImg)
 EVT_SOCKET(SERVER_KBD_ID,  vncPeuThreadeFrm::OnServerEventKbd)
 EVT_SOCKET(SOCKET_KBD_ID,  vncPeuThreadeFrm::OnSocketEventKbd)
 EVT_SOCKET(CLIENT_KBD_ID,  vncPeuThreadeFrm::OnClientEventKbd)
 
 //pour la zone affichant la bmp
 EVT_PAINT(                 vncPeuThreadeFrm::OnAfficheBmp) //kan la bmp d'affiche
 EVT_SCROLLBAR(SCROLL_ID,   vncPeuThreadeFrm::OnScroll) 
 
 ////Manual Code End
 
 EVT_CLOSE(                 vncPeuThreadeFrm::vncPeuThreadeFrmClose)
 EVT_BUTTON(ID_WXBUTTON2,   vncPeuThreadeFrm::WxButton2Click)
 EVT_BUTTON(ID_WXBUTTON1,   vncPeuThreadeFrm::WxButton1Click)
 
END_EVENT_TABLE()
  ////Event Table End
 
 
//constructeur du gui
vncPeuThreadeFrm::vncPeuThreadeFrm( wxWindow *parent, wxWindowID id, const wxString &title, const wxPoint &position, const wxSize& size, long style )
    : wxFrame( parent, id, title, position, size, style)
{
    CreateGUIControls();
}
vncPeuThreadeFrm::~vncPeuThreadeFrm() {} 
void vncPeuThreadeFrm::CreateGUIControls(void)
{
    //Do not add custom Code here
    //wx-devcpp designer will remove them.
    //Add the custom code before or after the Blocks
    ////GUI Items Creation Start
 this->SetSize(8,8,617,384);
 this->SetTitle(wxT("vncPeuThreade"));
 this->Center();
 this->SetIcon(wxNullIcon);
 
 memoLog = new wxTextCtrl(this, ID_MEMOLOG, wxT(""), wxPoint(4,289), wxSize(560,64), wxVSCROLL | wxTE_READONLY | wxTE_MULTILINE, wxDefaultValidator, wxT("memoLog"));
 memoLog->SetMaxLength(0);
 memoLog->AppendText(wxT("Log :\n"));
 WxButton2 = new wxButton(this, ID_WXBUTTON2, wxT("Client"), wxPoint(256,13), wxSize(75,25), 0, wxDefaultValidator, wxT("WxButton2"));
 WxButton1 = new wxButton(this, ID_WXBUTTON1, wxT("serveur"), wxPoint(83,11), wxSize(75,25), 0, wxDefaultValidator, wxT("WxButton1"));
    ////GUI Items Creation End
 
    WxScrolledWindow1 = new wxScrolledWindow(this, ID_WXSCROLLEDWINDOW1, wxPoint(4,39), wxSize(560,220), wxVSCROLL | wxHSCROLL | wxWS_EX_PROCESS_UI_UPDATES );
 
  //suivant les choix de l'user, les event handler seront géres en tant que serveur ou client...
  //ces choix se fferont au niveau des boutons, 
  //il seront gérés par les fonctions "vncPeuThreadeFrm::setServeur()" et consoeures...
  //pour l'instant, on informe le prog que il n'est ni en mode serveur, ni en mode client :
   estServeur = false;
   estClient = false;
   ConnectionImgValidee = false;
   ConnectionKbdValidee = false;
   BmpRecue = false;
}
void vncPeuThreadeFrm::vncPeuThreadeFrmClose(wxCloseEvent& event)
{
    // --> Don't use Close with a Frame,
    // use Destroy instead.
    Destroy();
}
 
// initialise les sockets en tant que serveur...
void vncPeuThreadeFrm::setServeur()
{
   if (! estServeur) {
 
        //on va instancier les sockets, meme si elles ne seront pas utilisées forcement...
        // on crée l'@ par defaut sur le port local
       addrKbd.Service(8002);
       addrImg.Service(8001);
 
       // On crée deux sockets
       socketKbdSrv = new wxSocketServer(addrKbd);
       socketImgSrv = new wxSocketServer(addrImg);
       // On utilise la fontion Ok(), afin de verifier si l'initialisation s'est bien passée...
       if (! socketKbdSrv->Ok() && socketImgSrv->Ok() )
       {
           //alors les sockets sont pas pretes, on quite le prog...
        memoLog->AppendText(_("les sockets ont pas put s'initialiser...\n"));
        return;
           }      
     // On choisit l'event handler, et on choisit les notification a recevoir...
        socketKbdSrv->SetEventHandler(*this, SERVER_KBD_ID);
        socketImgSrv->SetEventHandler(*this, SERVER_IMG_ID);
        socketKbdSrv->SetNotify(wxSOCKET_CONNECTION_FLAG | wxSOCKET_INPUT | wxSOCKET_OUTPUT);
        socketImgSrv->SetNotify(wxSOCKET_CONNECTION_FLAG | wxSOCKET_OUTPUT | wxSOCKET_INPUT);    
        socketKbdSrv->Notify(true);
        socketImgSrv->Notify(true);
      estServeur = true;
      estClient = false;
 
      creeThread(SERVER_KBD_ID);
      creeThread(SERVER_IMG_ID);
      memoLog->AppendText(_("\nMode serveur initialisé!\n"));
 
      //a suppreimer, present a des fin de test :
     //creeThread(TEST_THREAD_ID);
     }
 
}
// initialise les sockets en tant que client...
void vncPeuThreadeFrm::setClient()
{
   if (! estClient ) {
        //on va instancier les sockets, meme si elles ne seront pas utilisées forcement...
        // on crée l'@ par defaut sur le port local
     addrKbd.Hostname(_("127.0.0.1"));
       addrKbd.Service(8002);
       addrImg.Hostname(_("127.0.0.1"));
       addrImg.Service(8001);
 
       // On crée deux sockets
       socketKbdCli = new wxSocketClient();
       socketImgCli = new wxSocketClient();
 
 
     // On choisit l'event handler, et on choisit les notification a recevoir...
      socketKbdCli->SetEventHandler(*this, CLIENT_KBD_ID);
      socketImgCli->SetEventHandler(*this, CLIENT_IMG_ID);
 
      socketKbdCli->SetNotify(wxSOCKET_CONNECTION_FLAG | wxSOCKET_OUTPUT | wxSOCKET_INPUT);
      socketImgCli->SetNotify(wxSOCKET_CONNECTION_FLAG | wxSOCKET_INPUT | wxSOCKET_OUTPUT );    
 
      socketKbdCli->Notify(true);
      socketImgCli->Notify(true);
 
      estServeur = false;
    estClient = true;
 
    SetImgCliEnCours(false);//on a pas encore recu les en tete de headr : initialisation de la var ici
 
      socketImgCli->Connect(addrImg, false);
     socketImgCli->WaitOnConnect(10);
 
   //on connecte les sockets
     if (socketImgCli->IsConnected()) {
         memoLog->AppendText(_("connection etablie! pour le client Image\n"));
      }
      else
     {
        socketImgCli->Close();
       memoLog->AppendText(_("Echec de connexion du client image\n"));
       wxMessageBox(_("Echec de connexion"), _("Attention !"));
      }
 
       socketKbdCli->Connect(addrKbd, false);
     socketKbdCli->WaitOnConnect(10);
 
     if (socketKbdCli->IsConnected()) {
          memoLog->AppendText(_("connection etablie! pour le client KBD\n"));
          }
     else
     {
        socketKbdCli->Close();
       memoLog->AppendText(_("Echec de connexion du client KBD\n"));
       wxMessageBox(_("Echec de connexion"), _("Attention !"));
     }
      //socket connectées
    creeThread(CLIENT_KBD_ID);
    creeThread(CLIENT_IMG_ID);
 
      memoLog->AppendText(_("\nMode client initialisé!\n"));
  }
}
// OnServerEventImg
void vncPeuThreadeFrm::OnServerEventImg(wxSocketEvent& event)
{
 /* TODO (#1#): Implement vncPeuThreadeFrm::OnServerEventImg() */
 //le socket base créé enverra les images
 wxString s = _("Evenement serveur: ");
  sockBaseImg = event.GetSocket();
 
 switch(event.GetSocketEvent())
 {
      case wxSOCKET_CONNECTION : s.Append(_("wxSOCKET_CONNECTION : ")); break;
  default                  : s.Append(_("evenement inatendu!\n")); break;
 }
 
 memoLog->AppendText(s);
 
 // Accepte une nouvelle connection si il y en a une dans la file d'attente
 // sinon, on sort. on utilise accept(false) pour effectuer une acceptation 
 //non blocante pour le GUI (au cas ou finalement il n'y ait rien dasn la 
 //file d'attente)
 
 
 sockBaseImg = socketImgSrv->Accept(false);
 
 if (sockBaseImg)
 {
     memoLog->AppendText(_("connection acceptée\n"));
 }
 else
 {
     memoLog->AppendText(_("erreure, connection refusée!\n"));
  return;
 }
 
 sockBaseImg->SetEventHandler(*this, SOCKET_IMG_ID);
 sockBaseImg->SetFlags(wxSOCKET_WAITALL);//on ne recevra d'evenements de output que quand tout aura ete transmis (entre temps, ca ne sert a rien de créer une nouvelle image)
 sockBaseImg->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG ); //on gere pas encore les output
 sockBaseImg->Notify(true); //pour recevoir les evenements :)
 
 
}
/*
 * OnSocketEventImg
 */
void vncPeuThreadeFrm::OnSocketEventImg(wxSocketEvent& event)
{
 /* TODO (#1#): Implement vncPeuThreadeFrm::OnSocketEventImg() */
 //c'est la socket crée par la connection avec le client
 //wxSocketBase *sock = event.GetSocket(); => inutil car il retourne le socket concerné, et on sait deja lequell c'est...
 
 switch(event.GetSocketEvent())
 {
 case wxSOCKET_INPUT:
 {
   memoLog->AppendText(_("wxSOCKET_INPUT (socketImg) : "));  
   // On desactive les wxINPUT, afin de ne pas etre rappelé pendant le traitement
   // wxSocketEvent again.
   sockBaseImg->SetNotify(wxSOCKET_LOST_FLAG );
 
   //la connection a t elle deja ete validée?
   if (ConnectionImgValidee) 
   {       
             //je ne sait pas a quoi ca peut encore servir, peut etre a couper la transmission...
 
      } else {
        //il faut faire montrer patte blanche
   unsigned char c;
   sockBaseImg->Read(&c, 1);      
   if (c == 0xBE) 
   {         
       ConnectionImgValidee = true;
       memoLog->AppendText(_("Connection du client validée par le verificateur de securitée, envoie d'une trame de validation\n"));
   } else {
         memoLog->AppendText(_("Connection du client refuséeée par le verificateur de securitée\n"));
            }
   sockBaseImg->Write(&c, 1);//on lui renvoie pour lui notifier que c'est ok ou non
   }
 
 
   // on active les input events de nouveau
   sockBaseImg->SetNotify(wxSOCKET_LOST_FLAG | wxSOCKET_OUTPUT_FLAG | wxSOCKET_INPUT_FLAG);
 
   //et on envoie la premiere image :
      sendImg();
   break;
 }
 case wxSOCKET_LOST:
 {
   memoLog->AppendText(_("socket perdue!\n\n"));
   ConnectionImgValidee = false;
   sockBaseImg->Destroy();
   break;
 }
 case wxSOCKET_OUTPUT:
    {
    //on entre ici quant toutes les data ont ete envoyées...
    //on en envoie donc de nouvelles
    sendImg();   
    }
 default: ;
 }
}
/*
 * OnClientEventImg
 */
void vncPeuThreadeFrm::OnClientEventImg(wxSocketEvent& event)
{
 /* TODO (#1#): Implement vncPeuThreadeFrm::OnClientEventImg() */
 //on recoit les images
 unsigned char c;
   switch(event.GetSocketEvent())
  {
    case wxSOCKET_INPUT      : 
    memoLog->AppendText(_("wxSOCKET_INPUT (ClientImg): ")); 
    if (! ConnectionImgValidee) {
     //si la connection est pas encore validée, on lit la reponse du serveur
    socketImgCli->Read(&c, 1);      
    if (c == 0xBE) 
    {
          ConnectionImgValidee = true;
          memoLog->AppendText(_("Connection validée par le serveur\n"));
       } else {
          memoLog->AppendText(_("Connection refusée par le serveur\n"));                 
       }
          } else {
    //la connection est validée, on recoit les images ou le header
    if (GetImgCliEnCours() == false) 
    {
       //on recoit le header
       memoLog->AppendText(_("Recuperation de la taille du ficier\n"));
       socketImgCli->Read(&tailleImg, 4);//on recupere la taille du fic
      tailleImgRestante = tailleImg;//tous deux sont des wxUint32       
       SetImgCliEnCours(true);
           wxString temp;            
         temp<<tailleImg; 
         memoLog->AppendText( temp);
       //on instancie bufimage, buffer de char destiné a contenir 
        //l'image en entier...
          buffImage = new unsigned char[tailleImg];
       } else {
        //on recoit l'image dans temp readed : bufffer contenant
        // la partie recu par le reseau, a integrer dans buffimage
        wxUint32 tempReaded;
        unsigned char newBuffer[886432];
        socketImgCli->Read(newBuffer, tempReaded);        
        tempReaded = socketImgCli->LastCount();        
        wxString temp; 
         temp<<tempReaded; 
         /*
      memoLog->AppendText(_("taille du dernier troncon recu :"));
         memoLog->AppendText( temp);
         memoLog->AppendText(_("\n"));
         */
        for (wxUint32 i = 0; i < tempReaded ; i++) 
         {//on transvase newbuffer dans buffimage
            buffImage[i + ( tailleImg - tailleImgRestante ) ] = 
                                                        newBuffer[i];
         }
         tailleImgRestante -= tempReaded;
         /*
         memoLog->AppendText(_("Lecture \n"));
      */
        if ( tailleImgRestante == 0)

(suite)

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
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
      {
        wxString fichier = _("./image/BMPRecue.bmp");  
              wxFile *myfile ;
            myfile= new wxFile(fichier, wxFile::write);
         myfile->Write(buffImage, tailleImg);
         myfile->Close();
         SetImgCliEnCours(false);
         //on a ecrit le fichier recu, on va le relire          
                     if (! Bmp.LoadFile(fichier, wxBITMAP_TYPE_BMP ) )
                           memoLog->AppendText(_("Image mal rechargée\n"));
                        if ( Bmp.Ok())
                              memoLog->AppendText(_("BMP OK!\n"));
                        WxScrolledWindow1->SetScrollbars(8, 8, 128, 96, false);//8*128 = 1024, 8*96 = 768
                        WxScrolledWindow1->EnableScrolling(true,true);
         BmpRecue = true;      
         }
 
           memoLog->AppendText(_("Fin ")); 
             }
       }
    break;
 
    case wxSOCKET_LOST       : 
       memoLog->AppendText(_("wxSOCKET_LOST : socket KBD perdue!\n")); 
    break;
 
    case wxSOCKET_CONNECTION : 
    memoLog->AppendText(_("wxSOCKET_CONNECTION : on montre patte blanche\n")); 
     //on va montrer patte blanche
     //a securiser plus tard
        c = 0xBE;
       socketImgCli->Write(&c, 1);
     break;
 
    default                  : 
    memoLog->AppendText(_("Unexpected event !\n")); 
    break;
  }
}
/*
 * OnServerEventKbd
 */
void vncPeuThreadeFrm::OnServerEventKbd(wxSocketEvent& event)
{
 /* TODO (#1#): Implement vncPeuThreadeFrm::OnServerEventKbd() */
 //on recoit le KBD
 wxString s = _("Evenement serveur: ");
  sockBaseKbd = event.GetSocket();
 
 switch(event.GetSocketEvent())
 {
      case wxSOCKET_CONNECTION : s.Append(_("wxSOCKET_CONNECTION (KBD): ")); break;
  default                  : s.Append(_("evenement inatendu!\n")); break;
 }
 
 memoLog->AppendText(s);
 
 // Accepte une nouvelle connection si il y en a une dans la file d'attente
 // sinon, on sort. on utilise accept(false) pour effectuer une acceptation 
 //non blocante pour le GUI (au cas ou finalement il n'y ait rien dasn la 
 //file d'attente)
 
 
 sockBaseKbd = socketKbdSrv->Accept(false);
 
 if (sockBaseKbd)
 {
     memoLog->AppendText(_("connection acceptée\n"));
 }
 else
 {
     memoLog->AppendText(_("erreure, connection refusée de facon inatendu\n"));
  return;
 }
 
 sockBaseKbd->SetEventHandler(*this, SOCKET_KBD_ID);
 sockBaseKbd->SetNotify(wxSOCKET_INPUT_FLAG | wxSOCKET_LOST_FLAG | wxSOCKET_OUTPUT_FLAG);
 sockBaseKbd->Notify(true); //pour recevoir les evenements :)
 
 
}
/*
 * OnSocketEventKbd
 */
void vncPeuThreadeFrm::OnSocketEventKbd(wxSocketEvent& event)
{
 /* TODO (#1#): Implement vncPeuThreadeFrm::OnSocketEventKbd() */
 //c'est la socket crée par la connection avec le client
 //wxSocketBase *sock = event.GetSocket(); => inutil car il retourne le socket concerné, et on sait deja lequell c'est...
 
 switch(event.GetSocketEvent())
 {
 case wxSOCKET_INPUT:
 {
   memoLog->AppendText(_("wxSOCKET_INPUT (socketKbd) : "));  
   // On desactive les wxINPUT, afin de ne pas etre rappelé pendant le traitement
   // wxSocketEvent again.
   sockBaseKbd->SetNotify(wxSOCKET_LOST_FLAG | wxSOCKET_OUTPUT_FLAG);
 
   //la connection a t elle deja ete validée?
   if (ConnectionKbdValidee) 
   {       
             //on peut alors recevoir les input
 
      } else {
        //il faut faire montrer patte blanche
   unsigned char c;
   sockBaseKbd->Read(&c, 1);      
   if (c == 0xBE) 
   {         
       ConnectionKbdValidee = true;
       memoLog->AppendText(_("Connection du client validée par le verificateur de securitée, envoie d'une trame de validation\n"));
   } else {
         memoLog->AppendText(_("Connection du client refuséeée par le verificateur de securitée\n"));
            }
   sockBaseKbd->Write(&c, 1);//on lui renvoie pour lui notifier que c'est ok ou non
   }
 
 
   // on active les input events de nouveau
   sockBaseKbd->SetNotify(wxSOCKET_LOST_FLAG | wxSOCKET_OUTPUT_FLAG | wxSOCKET_INPUT_FLAG);
   break;
 }
 case wxSOCKET_LOST:
 {
 
   // Destroy() should be used instead of delete wherever possible,
   // due to the fact that wxSocket uses 'delayed events' (see the
   // documentation for wxPostEvent) and we don't want an event to
   // arrive to the event handler (the frame, here) after the socket
   // has been deleted. Also, we might be doing some other thing with
   // the socket at the same time; for example, we might be in the
   // middle of a test or something. Destroy() takes care of all
   // this for us.
 
   memoLog->AppendText(_("socket perdue!\n\n"));
   ConnectionKbdValidee = false;
   sockBaseKbd->Destroy();
   break;
 }
 default: ;
 }
}
/*
 * OnClientEventKbd
 */
void vncPeuThreadeFrm::OnClientEventKbd(wxSocketEvent& event)
{
 /* TODO (#1#): Implement vncPeuThreadeFrm::OnClientEventKbd() */
 //on envoie les KBD
 unsigned char c;
   switch(event.GetSocketEvent())
  {
    case wxSOCKET_INPUT      : 
    memoLog->AppendText(_("wxSOCKET_INPUT (ClientKbd): ")); 
    if (! ConnectionKbdValidee) {
     //si la connection est pas encore validée, on lit la reponse du serveur
    socketKbdCli->Read(&c, 1);      
    if (c == 0xBE) 
    {
          ConnectionKbdValidee = true;
          memoLog->AppendText(_("Connection validée par le serveur\n"));
       } else {
          memoLog->AppendText(_("Connection refusée par le serveur\n"));                 
       }
          } else {
    //la connection est validée, on recoit les toucjes        
       }
    break;
    case wxSOCKET_LOST       : memoLog->AppendText(_("wxSOCKET_LOST\n")); break;
    case wxSOCKET_CONNECTION : 
    memoLog->AppendText(_("wxSOCKET_CONNECTION : on montre patte blanche\n")); 
     //on va montrer patte blanche
     //a securiser plus tard
        c = 0xBE;
       socketKbdCli->Write(&c, 1);
     break;
    default                  : memoLog->AppendText(_("Unexpected event !\n")); break;
  } 
}
/*
 * WxButton1Click
 */
void vncPeuThreadeFrm::WxButton1Click(wxCommandEvent& event)
{
 // insert your code here
 setServeur();
}
/*
 * WxButton2Click
 */
void vncPeuThreadeFrm::WxButton2Click(wxCommandEvent& event)
{
 // insert your code here
 setClient();
}
/*
 * methode permettant la création d'un thread du type passé en parametre...
 */
void vncPeuThreadeFrm::creeThread(int type)
{
 /* TODO (#1#): Implement vncPeuThreadeFrm::creeThread() */
 switch ( type ) {
 
 case TEST_THREAD_ID :
   threadTest = new  thread2Base(this);
   if ( threadTest->Create() != wxTHREAD_NO_ERROR )
      {
           memoLog->AppendText(_("Erreure dans la creation du thread!"));
     } 
     threadTest->Run();
      break;
 
   case CLIENT_IMG_ID :
    break;
 
 
    case CLIENT_KBD_ID :
    break;   
 
    case SERVER_IMG_ID :
    break;
 
 
    case SERVER_KBD_ID :
    break;
 
   default : 
      memoLog->AppendText(_("on n'a pas reussit a trouver quel type de thread créer...\n"));  
 
    }
}
 
/*
 * sert a logger pour les autres objets
 */
void vncPeuThreadeFrm::doLog(wxString &texte)
{
 /* TODO (#1#): Implement vncPeuThreadeFrm::doLog() */
 memoLog->AppendText(texte);
 memoLog->AppendText(_("\n"));
}
 
// returns the value of addrKbd;
wxIPV4address  vncPeuThreadeFrm::GetaddrKbd()
{
 return addrKbd;
}
 
// returns the value of addrImg
wxIPV4address vncPeuThreadeFrm::GetaddrImg()
{
 return addrImg;
}
// envoie une image
void vncPeuThreadeFrm::sendImg()
{
 //on envoir une image
 HBITMAP Bmp;
 Bmp = snapshoot();
 PBITMAPINFO infoStruct;
 infoStruct = CreateBitmapInfoStruct(Bmp)  ;     
 HDC DCecran;
 DCecran = CreateDC("DISPLAY", NULL, NULL, NULL); 
 
    //on crée un bitmap sur le diqsue dur :
    CreateBMPFile( (LPTSTR)"./image/desktop.bmp", infoStruct, Bmp, DCecran);
    DeleteDC(DCecran);
    //on le reouvre, et on l'envoie :
 wxFile *myfile ;
 myfile= new wxFile("./image/desktop.bmp");
 off_t taille = myfile->Length(); //taille en octet :)
 char *buffer = new char[taille] ; // on crée un buffer de la taille du fichier
 myfile->Read(buffer, taille);
 myfile->Close();
 
 //envoi d'info a l'ecran
    wxString temp; 
    temp<<taille; 
    memoLog->AppendText(_("Envoie de la taille du fichier : "));
 memoLog->AppendText(temp);
    memoLog->AppendText(_("\n"));
 memoLog->AppendText(_("Envoie du fichier : "));
 
 //envoie des fic sur le reseau
 sockBaseImg->SetNotify(wxSOCKET_LOST_FLAG | wxSOCKET_INPUT_FLAG);
 sockBaseImg->Write(&taille, 4);
 sockBaseImg->Write(buffer , taille);
 
 if ( sockBaseImg->Error() ) 
         memoLog->AppendText(_("Erreure lors de l'nevoie de l'image\n"));
 memoLog->AppendText(_("FIN\n\n"));
 
 sockBaseImg->SetNotify(wxSOCKET_LOST_FLAG | wxSOCKET_OUTPUT_FLAG | wxSOCKET_INPUT_FLAG);
 
}
 
// returns the value of ImgCliEnCours
bool vncPeuThreadeFrm::GetImgCliEnCours()
{
 return ImgCliEnCours;
}
 
// sets the value of ImgCliEnCours
void vncPeuThreadeFrm::SetImgCliEnCours(bool x)
{
 ImgCliEnCours = x;
}
 
// returns the value of tailleImg
wxUint32 vncPeuThreadeFrm::GettailleImg()
{
 return tailleImg;
}
 
// sets the value of tailleImg
void vncPeuThreadeFrm::SettailleImg(wxUint32 x)
{
 tailleImg = x;
}
 
/*
 * capture l'image a l'ecran
 */
HBITMAP vncPeuThreadeFrm::snapshoot()
{
    int nScreenWidth = GetSystemMetrics(SM_CXSCREEN);
    int nScreenHeight = GetSystemMetrics(SM_CYSCREEN);
    HWND hDesktopWnd = GetDesktopWindow();
    HDC hDesktopDC = GetDC(hDesktopWnd);
    HDC hCaptureDC = CreateCompatibleDC(hDesktopDC);
    HBITMAP hCaptureBitmap =CreateCompatibleBitmap(hDesktopDC, 
        nScreenWidth, nScreenHeight);
    SelectObject(hCaptureDC,hCaptureBitmap); 
    BitBlt(hCaptureDC,0,0,nScreenWidth,nScreenHeight,hDesktopDC,0,0,SRCCOPY);     
    ReleaseDC(hDesktopWnd,hDesktopDC);
    DeleteDC(hCaptureDC);
    return hCaptureBitmap; 
}

(fin)

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
155
156
157
158
159
 
PBITMAPINFO vncPeuThreadeFrm::CreateBitmapInfoStruct(HBITMAP hBmp)    
{
//maintenant, on va créer une vrai bitmap.
    BITMAP bmp; 
    PBITMAPINFO pbmi; 
    WORD    cClrBits; 
    // Retrieve the bitmap color format, width, and height. 
    if (!GetObject(hBmp, sizeof(BITMAP), (LPSTR)&bmp)) 
         memoLog->AppendText(_("erreuer"));
    // Convert the color format to a count of bits. 
    cClrBits = (WORD)(bmp.bmPlanes * bmp.bmBitsPixel); 
    if (cClrBits == 1) 
        cClrBits = 1; 
    else if (cClrBits <= 4) 
        cClrBits = 4; 
    else if (cClrBits <= 8) 
        cClrBits = 8; 
    else if (cClrBits <= 16) 
        cClrBits = 16; 
    else if (cClrBits <= 24) 
        cClrBits = 24; 
    else cClrBits = 32; 
    // Allocate memory for the BITMAPINFO structure. (This structure 
    // contains a BITMAPINFOHEADER structure and an array of RGBQUAD 
    // data structures.) 
     if (cClrBits != 24) 
         pbmi = (PBITMAPINFO) LocalAlloc(LPTR, 
                    sizeof(BITMAPINFOHEADER) + 
                    sizeof(RGBQUAD) * (1<< cClrBits)); 
     // There is no RGBQUAD array for the 24-bit-per-pixel format. 
     else 
         pbmi = (PBITMAPINFO) LocalAlloc(LPTR, 
                    sizeof(BITMAPINFOHEADER)); 
    // Initialize the fields in the BITMAPINFO structure. 
    pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER); 
    pbmi->bmiHeader.biWidth = bmp.bmWidth; 
    pbmi->bmiHeader.biHeight = bmp.bmHeight; 
    pbmi->bmiHeader.biPlanes = bmp.bmPlanes; 
    pbmi->bmiHeader.biBitCount = bmp.bmBitsPixel; 
    if (cClrBits < 24) 
        pbmi->bmiHeader.biClrUsed = (1<<cClrBits); 
    // If the bitmap is not compressed, set the BI_RGB flag. 
    pbmi->bmiHeader.biCompression = BI_RGB; 
    // Compute the number of bytes in the array of color 
    // indices and store the result in biSizeImage. 
    // For Windows NT, the width must be DWORD aligned unless 
    // the bitmap is RLE compressed. This example shows this. 
    // For Windows 95/98/Me, the width must be WORD aligned unless the 
    // bitmap is RLE compressed.
    pbmi->bmiHeader.biSizeImage = ((pbmi->bmiHeader.biWidth * cClrBits +31) & ~31) /8
                                  * pbmi->bmiHeader.biHeight; 
    // Set biClrImportant to 0, indicating that all of the 
    // device colors are important. 
     pbmi->bmiHeader.biClrImportant = 0; 
     return pbmi; 
 } 
void vncPeuThreadeFrm::CreateBMPFile(LPTSTR pszFile, PBITMAPINFO pbi, 
                  HBITMAP hBMP, HDC hDC) 
 { 
     HANDLE hf;                 // file handle 
    BITMAPFILEHEADER hdr;       // bitmap file-header 
    PBITMAPINFOHEADER pbih;     // bitmap info-header 
    LPBYTE lpBits;              // memory pointer 
    DWORD dwTotal;              // total count of bytes 
    DWORD cb;                   // incremental count of bytes 
    BYTE *hp;                   // byte pointer 
    DWORD dwTmp; 
    pbih = (PBITMAPINFOHEADER) pbi; 
    lpBits = (LPBYTE) GlobalAlloc(GMEM_FIXED, pbih->biSizeImage);
    if (!lpBits) 
         memoLog->AppendText(_(" erreure : GlobalAlloc")); 
    // Retrieve the color table (RGBQUAD array) and the bits 
    // (array of palette indices) from the DIB. 
    if (!GetDIBits(hDC, hBMP, 0, (WORD) pbih->biHeight, lpBits, pbi, 
        DIB_RGB_COLORS)) 
    {
        memoLog->AppendText(_("erreure : GetDIBits")); 
    }
    // Create the .BMP file. 
    hf = CreateFile(pszFile, 
                   GENERIC_READ | GENERIC_WRITE, 
                   (DWORD) 0, 
                    NULL, 
                   CREATE_ALWAYS, 
                   FILE_ATTRIBUTE_NORMAL, 
                   (HANDLE) NULL); 
    if (hf == INVALID_HANDLE_VALUE) 
        memoLog->AppendText(_("CreateFile")); 
    hdr.bfType = 0x4d42;        // 0x42 = "B" 0x4d = "M" 
    // Compute the size of the entire file. 
    hdr.bfSize = (DWORD) (sizeof(BITMAPFILEHEADER) + 
                 pbih->biSize + pbih->biClrUsed 
                 * sizeof(RGBQUAD) + pbih->biSizeImage); 
    hdr.bfReserved1 = 0; 
    hdr.bfReserved2 = 0; 
    // Compute the offset to the array of color indices. 
    hdr.bfOffBits = (DWORD) sizeof(BITMAPFILEHEADER) + 
                    pbih->biSize + pbih->biClrUsed 
                    * sizeof (RGBQUAD); 
    // Copy the BITMAPFILEHEADER into the .BMP file. 
    if (!WriteFile(hf, (LPVOID) &hdr, sizeof(BITMAPFILEHEADER), 
        (LPDWORD) &dwTmp,  NULL)) 
    {
       memoLog->AppendText(_("erreure : WriteFile")); 
    }
    // Copy the BITMAPINFOHEADER and RGBQUAD array into the file. 
    if (!WriteFile(hf, (LPVOID) pbih, sizeof(BITMAPINFOHEADER) 
                  + pbih->biClrUsed * sizeof (RGBQUAD), 
                  (LPDWORD) &dwTmp, ( NULL)) 
        )
        memoLog->AppendText(_("WriteFile")); 
    // Copy the array of color indices into the .BMP file. 
    dwTotal = cb = pbih->biSizeImage; 
    hp = lpBits; 
    if (!WriteFile(hf, (LPSTR) hp, (int) cb, (LPDWORD) &dwTmp,NULL)) 
           memoLog->AppendText(_("WriteFile")); 
    // Close the .BMP file. 
     if (!CloseHandle(hf)) 
           memoLog->AppendText(_("CloseHandle")); 
    // Free memory. 
    GlobalFree((HGLOBAL)lpBits);
}
 
//}
/*
 * kan ca afficjhe la bmp dans le champ scrollable
 */
void vncPeuThreadeFrm::OnAfficheBmp(wxPaintEvent & event )
{
   wxPaintDC dc(this); //si on ne crée pas de wxPaintDC, la fenetre se bloque (cf la doc)
 
   if (BmpRecue)
   {        
        //wxBufferedPaintDC MyDC(WxScrolledWindow1); 
 
        //on affiche la bmp dnas un champ :                      
     wxBufferedPaintDC DC(WxScrolledWindow1, Bmp); 
     WxScrolledWindow1->PrepareDC(DC);
     DC.BeginDrawing();
     //DC.DrawBitmap(Bmp, wxCoord(0), wxCoord(0), false);
     DC.EndDrawing();
     //MyDC = DC;
   }
}
 
/*
 * kan on bouge la zone scrollable
 */
void vncPeuThreadeFrm::OnScroll(wxCommandEvent & event)
{
        //on affiche la bmp dnas un champ :                      
     wxBufferedPaintDC MyDC(WxScrolledWindow1); 
     WxScrolledWindow1->PrepareDC(MyDC);
     MyDC.BeginDrawing();
     MyDC.DrawBitmap(Bmp, wxCoord(0), wxCoord(0), false);
     MyDC.EndDrawing();
//     this.UpdateWindowUI();
}

20/04/2006, 11h01
Matthieu Brucher

J'ai pas trop de temps de regarder le code et de t'aider en détail, mais je te conseille :
- séparer tout ce qui est connexion de ton travail effectif - BMP, ... -
- même chose pour séparation de l'interface graphique s'il y a
Une fois que tu as vu quels sont les éléments à extraire de tes autres classes, regarde comment tu peux les assembler pour créer des classes explicites et logiques.
20/04/2006, 11h06
hansaplast
vi, pour le code, il est la... pour etre la...
je me doute que c'est pas regardable :)

merci de ta reponse, ca me rappele que j'ai oublié de dire ce que je pensait faire :
- objet reseau
- objet image
- objet affichage
mais, le truc c'est quec a ferait 3 objets tres lourds, donc je pensait peut etre faire :
- objet reseau, herite de :
  - objet client
  - objet serveur
  - tous deux heritent de
    objet clef pub/priv
- objet image, herite de :
  - objet créer image
  - objet lire image
- ...
mais, a ce compte là, vu que les traitements ne sont pas les meme coté servfeur et cleint, a quoi mes erviraient ces heritages?
a part les montrer pour mon examen...
est-ce le mieux a faire?
20/04/2006, 11h41
Matthieu Brucher

Tu peux donc faire mieux. Faire une classe image, c'est bien, maintenant, tu peux peut-être faire une classe comme Image, en fait héritant de son interface, qui implémente un "proxy" qui fera l'interface avec le réseau et tu utiliserais ton image comme tu veux. C'est juste une idée, pas un truc à faire vraiment si cela ne convient pas ;)
Le but n'est pas de faire des classes uniques avec le code client et serveur en même temps.
20/04/2006, 11h45
Stany

Salut, ton projet est tres intéressant.
j'ai vu que tu utilisait les sockets, quand je m'en sui servie j'ai utilisé les objet windows, effectivement c'est diffèrent quand on utilise WxWidgets. Un question a propos de ca, tu l'as avec quoi, y a t - il des tutot pour cela.
Si non pour tes class, les objets clients et serveur hérite de clef mais tu ne regoupe pas client et serveur mai il faut les concevoire ensemble pour que ca colle (histoire des protocols).
Je m'inscrit pour avoir l'application quand elle sera fini ( bien sur je te laisse le code ).
Stany
20/04/2006, 12h05
hansaplast

Citation:

Envoyé par Miles

Tu peux donc faire mieux. Faire une classe image, c'est bien, maintenant, tu peux peut-être faire une classe comme Image, en fait héritant de son interface, qui implémente un "proxy" qui fera l'interface avec le réseau et tu utiliserais ton image comme tu veux. C'est juste une idée, pas un truc à faire vraiment si cela ne convient pas ;)
Le but n'est pas de faire des classes uniques avec le code client et serveur en même temps.

j'ai pas vraiment compris...
c'est le terme proxy qui me bloque...
en fait, ce que tu veut dire, je suppose, c'est que je devrait créer une API pour l'image, en gros toput encapsuler le concept de capture de l'image, pour pouvoir re-utiliser cela?

Citation:

Envoyé par Stany

Salut, ton projet est tres intéressant.
j'ai vu que tu utilisait les sockets, quand je m'en sui servie j'ai utilisé les objet windows, effectivement c'est diffèrent quand on utilise WxWidgets. Un question a propos de ca, tu l'as avec quoi, y a t - il des tutot pour cela.
Si non pour tes class, les objets clients et serveur hérite de clef mais tu ne regoupe pas client et serveur mai il faut les concevoire ensemble pour que ca colle (histoire des protocols).
Je m'inscrit pour avoir l'application quand elle sera fini ( bien sur je te laisse le code ).
Stany

on a les objet avec wx/socket.h
pour les tuto, tu a des fichiers d'exemple avec la librairie Wxwidgets, masi ils sont assez sommaire, j'ai eu pas mal de mal a implementer le tout, et c'est loin d'etre parfait, croit moi...

pour les protocoles, tu a raison, merci de me le rappeler... cependant, j'ai implementé le mein (tout pourri) et je peut tres bien dissocier les deux classes, masi, c'est vrai que pour le cryptage, il faut que ces deux classes heritent d'une classe cryptage, merci encore :)

l'application, une fois finit, je la donne sans pb (le code, je te le laisse, lol, j'en ait honte) mais c'est loin d'etre fonctionnel, j'alloue mal la memoire,et au bout de 1 ou 2 minute, mon systeme sature (j'ai pas le temps d'apprendre commetn faire :'( )

merci de vos reponse, elle m'ont ete tres instrucitves :)
20/04/2006, 12h10
hansaplast

Citation:

Envoyé par Miles

Tu peux donc faire mieux. Faire une classe image, c'est bien, maintenant, tu peux peut-être faire une classe comme Image, en fait héritant de son interface, qui implémente un "proxy" qui fera l'interface avec le réseau et tu utiliserais ton image comme tu veux. C'est juste une idée, pas un truc à faire vraiment si cela ne convient pas ;)
Le but n'est pas de faire des classes uniques avec le code client et serveur en même temps.

j'ai pas vraiment compris...
c'est le terme proxy qui me bloque...
en fait, ce que tu veut dire, je suppose, c'est que je devrait créer une API pour l'image, en gros toput encapsuler le concept de capture de l'image, pour pouvoir re-utiliser cela?

Citation:

Envoyé par Stany

Salut, ton projet est tres intéressant.
j'ai vu que tu utilisait les sockets, quand je m'en sui servie j'ai utilisé les objet windows, effectivement c'est diffèrent quand on utilise WxWidgets. Un question a propos de ca, tu l'as avec quoi, y a t - il des tutot pour cela.
Si non pour tes class, les objets clients et serveur hérite de clef mais tu ne regoupe pas client et serveur mai il faut les concevoire ensemble pour que ca colle (histoire des protocols).
Je m'inscrit pour avoir l'application quand elle sera fini ( bien sur je te laisse le code ).
Stany

on a les objet avec wx/socket.h
pour les tuto, tu a des fichiers d'exemple avec la librairie Wxwidgets, masi ils sont assez sommaire, j'ai eu pas mal de mal a implementer le tout, et c'est loin d'etre parfait, croit moi...

pour les protocoles, tu a raison, merci de me le rappeler... cependant, j'ai implementé le mein (tout pourri) et je peut tres bien dissocier les deux classes, masi, c'est vrai que pour le cryptage, il faut que ces deux classes heritent d'une classe cryptage, merci encore :)

l'application, une fois finit, je la donne sans pb (le code, je te le laisse, lol, j'en ait honte) mais c'est loin d'etre fonctionnel, j'alloue mal la memoire,et au bout de 1 ou 2 minute, mon systeme sature (j'ai pas le temps d'apprendre commetn faire :'( )

merci de vos reponse, elle m'ont ete tres instrucitves :)

ps : je voulait joindre les sources pour stany, mais mon reseau d'entrprise rame tropa midi, j'essairait de la faire + tard :)
20/04/2006, 12h14
Stany

Moi aussi je rend contre des probléme de mémoire et je ne sais pas trop de quoi ce vient.
20/04/2006, 12h21
hansaplast

1 pièce(s) jointe(s)

voila, j'ai reussi l'upload :)
j'ai dut supprimmer quelques fichier du ZIP, j'espere que ca marchera...
20/04/2006, 13h50
Stany

Hum j'ai bien dl ton fichier mais je n'ai pas les bon truc donc si tu peu l'envoyer jsute le .exe par mail :D .
Merci
21/04/2006, 16h06
hansaplast

essaye a cette adresse.

comment ca marche?

il faut lancer deux fois le soft.

tout d'abourds, tu met un des deux en serveur (sinon ca plante)
et apres t'en met un en client

le client affiche l'image du serveur, mais elle ne se rafraichit pas toute seule, il faut afficher une autre fenetre devant pour que ca se rafraichisse.

tu n'a pas le choix de l'ip de destination, elle est hardcodée en localhost.

si tu clique sur l'image, ca envoie l'info au serveur qui est sensé imuler un click souri (marche po encore bien)

voila, bonne chance!

ps : j'avait prevenu, c po terrible