Ministerul Educației al Republicii Moldova

Universitatea de Stat din Moldova

Facultatea de Matematică și Informatică

Lucrare de laborator nr.2

La disciplina Grafica Rastru
Tema:"Programarea mouse – lui. "

Efectuat de studentul
grupei IA21: Ghiderman Ion

Verificat de lectorul universitar:

Marin Ghenadie

Chişinău, 2015
1
 Condiția laboratorului:

Salvați imagnea desenată în editorul grafic Adobe Photoshop în formatul .bmp pe 4 bit.
Încărcați imaginea obținută în Microsoft Visual Studio și mutați – o cu ajutorul mouse – lui.

Programarea mouse – lui:

Programarea mouse-lui constă în tratarea evenimentelor generate de mouse. Orice acţiune cu

mouse-ul provoacă pe Windows să genereze unul sau mai multe mesaje de evenimente

respective. De exemplu, utilizatorul a executat un click stânga, sau a deplasat cursorul, sau a

executat un diblu click stânga, etc.

Mersul laboratorului:

1. Salvăm imaginea din formatul .psd în formatul .bmp pe 4 biți.

2. Cu ajutorul programului în C++, care citește un fișier .bmp și îl rescrie în hexazecimal în
format .txt salvăm imaginea dată.
3. Creăm un proiect în Microsoft Visual Studio incluzînd toate funcțiile de citire a fișierului
.bmp și .txt .
4. Adăugăm o funcție de tratare a mesajelor care să intercepteze mesajul generat la apăsarea
de către utilizator a butonului stîng al mouse – ului. Funcția va fi numită
OnButtonDown(). Ea va fi apelată de fiecare dată cînd utilizatorul apasă butonul stîng al
mouse - ului. Indicatorii de stare a butoanelor și a tastelor de dirijare sunt descrise în
următorul tabel:

Indicator Descriere
MK_LBUTTON Arată că este apăsat butonul sting al mouse - lui
MK_RBUTTON Arată că este apăsat butonul drept al mouse - lui
MK_MBUTTON Arată că este apăsat butonul de mijloc al mouse – lui
MK_CONTROL Arată că este apăsată tasta Ctrl
MK_SHIFT Arată că este apăsată tasta Shift

5. După ce executăm programul ținem apăsat pe butonul stîng al mouse – lui și mutăm
imaginea.

Listingul programului ca transformă imaginea din .bmp în .txt:

2
#include"conio.h"
#include"stdlib.h"
#include"stdio.h"
#include"string.h"
unsignedchar hex[16]={'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
char bmp[5]=".bmp";
char txt[5]=".txt";
main()
{

FILE *pif, *pof;

char iname[20], oname[20];
unsigned char uc;
unsigned long k;
printf("Input file name? ");
scanf("%s", iname);
strcpy(oname, iname);
strcat(iname, bmp);
strcat(oname, txt);
printf("Input file name: %s\n", iname);
printf("Output file name: %s\n", oname);
pif = fopen(iname, "rb");
if(!pif)
{
printf("File %s not found!\n", iname);
printf("Press any key... ");
getch();
exit(1);
}
pof = fopen(oname, "wt");
k=0;
while(!feof(pif))
if(fread(&uc, 1, 1, pif))
{
if(k%16==0)
{
if(k>0)
fprintf(pof,"\n");
fprintf(pof,"%04X%04X: ", *((unsigned short*)&k+1),*((unsigned
short*)&k));
}
else
if(k%8==0)
fprintf(pof,"|");
else
fprintf(pof," ");
fprintf(pof,"%c%c", hex[uc>>4], hex[uc&0X0F]);
k++;
}
fclose(pif);
fclose(pof);
printf("Press any key... ");
getch();
}

Rezultatul:
3
Listingul GraphLab2View.h:
4
class CGraphLab2View : public CView
{
protected: // create from serialization only
CGraphLab2View();
DECLARE_DYNCREATE(CGraphLab2View)

// Attributes
public:
CGraphLab2Doc* GetDocument() const;

// Operations
public:

// Overrides
public:
virtual void OnDraw(CDC* pDC); // overridden to draw this view
virtual BOOL PreCreateWindow(CREATESTRUCT& cs);
protected:
virtual BOOL OnPreparePrinting(CPrintInfo* pInfo);
virtual void OnBeginPrinting(CDC* pDC, CPrintInfo* pInfo);
virtual void OnEndPrinting(CDC* pDC, CPrintInfo* pInfo);

// Implementation
public:
virtual ~CGraphLab2View();
public:
CPoint m_ptMouse;
public:
CPoint st;
public:
afx_msg void OnLButtonDown(UINT nFlags, CPoint point);
public:
afx_msg void OnMouseMove(UINT nFlags, CPoint point);
public:
int da;
public:
int des;

struct BITMAPFILEHEADER
{
char bfType[2];
unsigned int bfSize;
short int bfReserved1;
short int bfReserved2;
unsigned int bfOffBits;
};
struct BITMAPINFOHEADER
{
unsigned int biSize;
unsigned int biWidth;
unsigned int biHeight;
short int biPlanes;
short int biBitCount;
unsigned int biCompression;
unsigned int biSizeImage;
unsigned int biXPelsPerMeter;
unsigned int biYPelsPerMeter;
unsigned int biClrUsed;
unsigned int biClrImportant;
};
struct PALETA
{
unsigned char B;

5
 unsigned char G;
unsigned char R;
unsigned char Z;
};
BITMAPFILEHEADER antet_fis;
BITMAPINFOHEADER antet_img;
unsigned char *p;
unsigned char cul;
unsigned char *pim;
int noct;
PALETA *pal;

#ifdef _DEBUG
virtual void AssertValid() const;
virtual void Dump(CDumpContext& dc) const;
#endif

protected:

// Generated message map functions

protected:
DECLARE_MESSAGE_MAP()
};

#ifndef _DEBUG // debug version in GraphLab2View.cpp

inline CGraphLab2Doc* CGraphLab2View::GetDocument() const
{ return reinterpret_cast<CGraphLab2Doc*>(m_pDocument); }
#endif

Listingul GraphLab2View.cpp:
void CGraphLab2View::OnDraw(CDC* pDC)
{
CGraphLab2Doc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
if (!pDoc)
return;

if(des<1){
FILE* f;
FILE* f1;

int NBPP;

f=fopen("G:\\Grafica\\grafika2\\l2_4bit.bmp","rb");
f1=fopen("G:\\Grafica\\grafika2\\l2_4bit.txt","wt");

fread (&antet_fis.bfType[0],sizeof (char),1,f);

fprintf (f1,"%c",antet_fis.bfType[0]);

fread (&antet_fis.bfType[1],sizeof (char),1,f);

fprintf (f1,"%c",antet_fis.bfType[1]);

if ((antet_fis.bfType[0]!='B') || (antet_fis.bfType[1]!='M'))
{
CString mesl(CString("Format not available!"));
AfxMessageBox(mesl);
return;
6
 }
fread (&antet_fis.bfSize, sizeof(int),1,f);
fprintf (f1,"\n%d\n",antet_fis.bfSize);

fread( &antet_fis.bfReserved1,sizeof (short int),1,f);

fprintf (f1,"%d\n",antet_fis.bfReserved1);
fread( &antet_fis.bfReserved2,sizeof (short int),1,f);
fprintf (f1,"%d\n",antet_fis.bfReserved2);
fread( &antet_fis.bfOffBits,sizeof (int),1,f);
fprintf (f1,"offset %d\n",antet_fis.bfOffBits);
fread( &antet_img.biSize,sizeof (int),1,f);
fprintf (f1,"header image size %d\n",antet_img.biSize);

fread( &antet_img.biWidth,sizeof ( int),1,f);

fprintf (f1,"image width %d\n",antet_img.biWidth);
fread( &antet_img.biHeight,sizeof ( int),1,f);
fprintf (f1,"image height %d\n",antet_img.biHeight);
fread( &antet_img.biPlanes,sizeof (short int),1,f);
fread( &antet_img.biBitCount,sizeof (short int),1,f);
fprintf (f1,"image biBitCount %d\n",antet_img.biBitCount);
fread( &antet_img.biCompression,sizeof ( int),1,f);
fread( &antet_img.biSizeImage,sizeof ( int),1,f);
fread( &antet_img.biXPelsPerMeter,sizeof ( int),1,f);
fread( &antet_img.biYPelsPerMeter,sizeof ( int),1,f);
fread( &antet_img.biClrUsed,sizeof ( int),1,f);
fprintf(f1,"culori utilizate %d \n",antet_img.biClrUsed);
fread( &antet_img.biClrImportant,sizeof ( int),1,f);

NBPP=antet_img.biBitCount;
if (NBPP!=4)
{
CString mesl(CString("Imaginea nu este pe 4 b/p"));
AfxMessageBox(mesl);
return;
}

//Numarul de culori in paleta

int nculori=antet_img.biClrUsed;
if (nculori==0)
nculori=16;

//citim paleta
pal=new PALETA [nculori];
for (int i=0; i<nculori; i++)
{
fread (&(pal[i].B),1,1,f);
fread (&(pal[i].G),1,1,f);
fread (&(pal[i].R),1,1,f);
fread (&(pal[i].Z),1,1,f);

fprintf (f1, "%02X %02X %02X\n" , pal[i].R, pal[i].G, pal[i].B);

}
//Num de octeti pentru a codifica o linie 4 b/p
noct=(antet_img.biWidth+1)/2+((antet_img.biWidth+1)/2)%4;

//spatiul pru imagine

pim=new unsigned char [antet_img.biHeight*noct];

//citim imaginea
fread(pim,noct,antet_img.biHeight,f);

fclose(f);
7
//desenam imaginea

//pru 4 b/p
p=pim+noct*(antet_img.biHeight-1);
fprintf (f1,"culorile: \n");

for (unsigned i=0; i< antet_img.biHeight; i++)

{
for (unsigned j=0; j<antet_img.biWidth;j++)
{
unsigned char c12=p[j/2];
cul= (j%2) ? (c12&0x0F) : (c12>>4);

pDC->
SetPixel(j+m_ptMouse.x,i+m_ptMouse.y,RGB(pal[cul].R,pal[cul].G, pal[cul].B));

fprintf (f1,"%02X",cul);
}
fprintf (f1,"\n");
p-=noct;
}
fprintf (f1,"\n des=%d", des);
fclose (f1);
des++;

}
else
{
p=pim+noct*(antet_img.biHeight-1);

for (unsigned i=0; i< antet_img.biHeight; i++)

{
for (unsigned j=0; j<antet_img.biWidth;j++) {
unsigned char c12=p[j/2];
cul= (j%2) ? (c12&0x0F) : (c12>>4);
pDC->
SetPixel(j+m_ptMouse.x,i+m_ptMouse.y,RGB(pal[cul].R,
pal[cul].G,
pal[cul].B));
}
p-=noct;
}

}
ReleaseDC(pDC);

void CGraphLab2View::OnLButtonDown(UINT nFlags, CPoint point)

{
//TODO: Add your message handler code here and/or call default

8
if((point.x>=m_ptMouse.x)&&(point.x<=m_ptMouse.x+antet_img.biWidth)&&(point.y
>=m_ptMouse.y)
&&(point.y<=m_ptMouse.y+antet_img.biHeight))
{st=point-m_ptMouse;
da=1;
}
else
da=2;
CView::OnLButtonDown( nFlags, point);
}

void CGraphLab2View::OnMouseMove(UINT nFlags, CPoint point)

{
// TODO: Add your message handler code here and/or call default
if(((nFlags & MK_LBUTTON) == MK_LBUTTON)&&(da==1))
{
CDC *pDC=GetDC();
CString m;
m_ptMouse=point-st;
ReleaseDC(pDC);
Invalidate();
}
CView::OnMouseMove( nFlags, point);
}

Rezultatul final:
Poziția inițială:

9
 Poziția după mutare:

Concluzie:
În lucrea dată am folosit o aplicație de tip Dialog Based creată în Microsoft Visual
Studio. În funcția OnDraw am făcut citirea din fișier și înscrierea înapoi a informației despre
imagine: înălțimea, lățimea , numarul de biți, culorile utilizate ș.a.. Apoi am scris funcția care
mută imaginea pe suprafața de lucru cu butoanele necesare.

10