bool MCRegionCalculateMask(MCRegionRef self, int32_t w, int32_t h, MCBitmap*& r_mask)
{
// Create a pixmap
Pixmap t_image;
t_image = MCscreen -> createpixmap(w, h, 1, False);
// Draw into the pixmap's port
CGrafPtr t_old_port;
GDHandle t_old_device;
GetGWorld(&t_old_port, &t_old_device);
SetGWorld((CGrafPtr)t_image -> handle . pixmap, NULL);
BackColor(whiteColor);
ForeColor(blackColor);
Rect t_rect;
SetRect(&t_rect, 0, 0, w, h);
EraseRect(&t_rect);
PaintRgn((RgnHandle)self);
SetGWorld(t_old_port, t_old_device);
// Fetch the pixmap as a bitmap
MCBitmap *t_bitmap;
t_bitmap = MCscreen -> getimage(t_image, 0, 0, w, h, False);
// Discard the pixmap
MCscreen -> freepixmap(t_image);
r_mask = t_bitmap;
return true;
}
BOOL nulldrv_InvertRgn( PHYSDEV dev, HRGN rgn )
{
HBRUSH prev_brush = SelectObject( dev->hdc, GetStockObject(BLACK_BRUSH) );
INT prev_rop = SetROP2( dev->hdc, R2_NOT );
BOOL ret = PaintRgn( dev->hdc, rgn );
SelectObject( dev->hdc, prev_brush );
SetROP2( dev->hdc, prev_rop );
return ret;
}
static void hugsprim_PaintRgn_12(HugsStackPtr hugs_root)
{
HsPtr arg1;
HsPtr arg2;
HsBool res1;
arg1 = hugs->getPtr();
arg2 = hugs->getPtr();
res1 = PaintRgn(arg1, arg2);
hugs->putBool(res1);
hugs->returnIO(hugs_root,1);
}
BOOL nulldrv_FillRgn( PHYSDEV dev, HRGN rgn, HBRUSH brush )
{
BOOL ret = FALSE;
HBRUSH prev;
if ((prev = SelectObject( dev->hdc, brush )))
{
ret = PaintRgn( dev->hdc, rgn );
SelectObject( dev->hdc, prev );
}
return ret;
}
static void ROM_ShowMenuBar(_THIS)
{
#if !TARGET_API_MAC_CARBON /* This seems not to be available? -sts Aug 2000 */
RgnHandle drawRgn = nil;
RgnHandle menuRgn = nil;
RgnHandle tempRgn = nil;
RgnHandle grayRgn = nil;
WindowPtr window = nil;
GrafPtr wMgrPort;
GrafPtr savePort;
Rect menuRect;
long response;
short height;
EventRecord theEvent;
RGBColor saveRGB;
RGBColor blackRGB = { 0, 0, 0 };
height = GetMBarHeight();
if ((height <= 0) && (gSaveMenuBar > 0)) {
drawRgn = NewRgn();
menuRgn = NewRgn();
tempRgn = NewRgn();
if ( ! tempRgn || ! drawRgn || ! gSaveGrayRgn ) {
goto CLEANUP;
}
grayRgn = GetGrayRgn(); /* No need to check for this */
GetPort(&savePort);
GetWMgrPort(&wMgrPort);
/* Set the height properly */
LMSetMBarHeight(gSaveMenuBar);
/* Restore the old GrayRgn: rounded corners, etc, but not
the menubar -- subtract that out first! */
if (gSaveGrayRgn)
{
menuRect = (*GetMainDevice())->gdRect;
menuRect.bottom = menuRect.top + gSaveMenuBar;
RectRgn(menuRgn, &menuRect);
DiffRgn(grayRgn, gSaveGrayRgn, drawRgn); /* What do we inval? */
DiffRgn(drawRgn, menuRgn, drawRgn); /* Clip out the menu */
/* Now redraw the corners and other bits black */
SetPort(wMgrPort);
GetClip(tempRgn);
SetClip(drawRgn);
GetForeColor(&saveRGB);
RGBForeColor(&blackRGB);
PaintRgn(drawRgn);
RGBForeColor(&saveRGB);
SetClip(tempRgn);
SetPort(savePort);
UnionRgn(drawRgn, menuRgn, drawRgn); /* Put back the menu */
/* Now actually restore the GrayRgn */
CopyRgn(gSaveGrayRgn, grayRgn);
DisposeRgn(gSaveGrayRgn);
gSaveGrayRgn = nil;
}
/* Modify the vis regions of exposed windows and draw menubar */
window = (FrontWindow()) ? FrontWindow() : (WindowPtr) -1L;
PaintBehind(window, drawRgn);
CalcVisBehind(window, drawRgn);
DrawMenuBar();
SetPort(savePort);
gSaveMenuBar = 0;
/* Now show the control strip if it's present */
if (!Gestalt(gestaltControlStripAttr, &response) &&
(response & (1L << gestaltControlStripExists)))
{
if (gSaveCSVis && !SBIsControlStripVisible())
SBShowHideControlStrip(true);
gSaveCSVis = true;
}
/* Yield time so that floaters can catch up */
EventAvail(0, &theEvent);
EventAvail(0, &theEvent);
EventAvail(0, &theEvent);
EventAvail(0, &theEvent);
}
CLEANUP:
if (drawRgn) DisposeRgn(drawRgn);
if (menuRgn) DisposeRgn(menuRgn);
if (tempRgn) DisposeRgn(tempRgn);
#endif /* !TARGET_API_MAC_CARBON */
}
static void draw_graphics(HDC hdc, BITMAPINFO *bmi, BYTE *bits, const char ***sha1)
{
DWORD dib_size = get_dib_size(bmi);
HPEN solid_pen, dashed_pen, orig_pen;
HBRUSH solid_brush, dib_brush, hatch_brush, orig_brush;
INT i, y, hatch_style;
HRGN hrgn, hrgn2;
BYTE dib_brush_buf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD) + 16 * 16 * sizeof(DWORD)]; /* Enough for 16 x 16 at 32 bpp */
BITMAPINFO *brush_bi = (BITMAPINFO*)dib_brush_buf;
BYTE *brush_bits;
BOOL dib_is_1bpp = (bmi->bmiHeader.biBitCount == 1);
memset(bits, 0xcc, dib_size);
compare_hash(bmi, bits, sha1, "empty");
solid_pen = CreatePen(PS_SOLID, 1, RGB(0, 0, 0xff));
orig_pen = SelectObject(hdc, solid_pen);
SetBrushOrgEx(hdc, 0, 0, NULL);
/* horizontal and vertical lines */
for(i = 1; i <= 16; i++)
{
SetROP2(hdc, i);
MoveToEx(hdc, 10, i * 3, NULL);
LineTo(hdc, 100, i * 3); /* l -> r */
MoveToEx(hdc, 100, 50 + i * 3, NULL);
LineTo(hdc, 10, 50 + i * 3); /* r -> l */
MoveToEx(hdc, 120 + i * 3, 10, NULL);
LineTo(hdc, 120 + i * 3, 100); /* t -> b */
MoveToEx(hdc, 170 + i * 3, 100, NULL);
LineTo(hdc, 170 + i * 3, 10); /* b -> t */
}
compare_hash(bmi, bits, sha1, "h and v solid lines");
memset(bits, 0xcc, dib_size);
/* diagonal lines */
SetROP2(hdc, R2_COPYPEN);
for(i = 0; i < 16; i++)
{
double s = sin(M_PI * i / 8.0);
double c = cos(M_PI * i / 8.0);
MoveToEx(hdc, 200.5 + 10 * c, 200.5 + 10 * s, NULL);
LineTo(hdc, 200.5 + 100 * c, 200.5 + 100 * s);
}
compare_hash(bmi, bits, sha1, "diagonal solid lines");
memset(bits, 0xcc, dib_size);
for(i = 0; i < sizeof(bias_check) / sizeof(bias_check[0]); i++)
{
MoveToEx(hdc, bias_check[i].left, bias_check[i].top, NULL);
LineTo(hdc, bias_check[i].right, bias_check[i].bottom);
}
compare_hash(bmi, bits, sha1, "more diagonal solid lines");
memset(bits, 0xcc, dib_size);
/* solid brush PatBlt */
solid_brush = CreateSolidBrush(RGB(0x33, 0xaa, 0xff));
orig_brush = SelectObject(hdc, solid_brush);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
ret = PatBlt(hdc, 10, y, 100, 10, rop3[i]);
if(rop_uses_src(rop3[i]))
ok(ret == FALSE, "got TRUE for %x\n", rop3[i]);
else
{
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 20;
}
}
compare_hash(bmi, bits, sha1, "solid patblt");
memset(bits, 0xcc, dib_size);
/* clipped lines */
hrgn = CreateRectRgn(10, 10, 200, 20);
hrgn2 = CreateRectRgn(100, 100, 200, 200);
CombineRgn(hrgn, hrgn, hrgn2, RGN_OR);
SetRectRgn(hrgn2, 290, 100, 300, 200);
CombineRgn(hrgn, hrgn, hrgn2, RGN_OR);
ExtSelectClipRgn(hdc, hrgn, RGN_COPY);
DeleteObject(hrgn2);
for(i = 0; i < sizeof(hline_clips)/sizeof(hline_clips[0]); i++)
{
MoveToEx(hdc, hline_clips[i].left, hline_clips[i].top, NULL);
LineTo(hdc, hline_clips[i].right, hline_clips[i].bottom);
}
compare_hash(bmi, bits, sha1, "clipped solid hlines");
memset(bits, 0xcc, dib_size);
for(i = 0; i < sizeof(vline_clips)/sizeof(vline_clips[0]); i++)
{
MoveToEx(hdc, vline_clips[i].left, vline_clips[i].top, NULL);
LineTo(hdc, vline_clips[i].right, vline_clips[i].bottom);
}
compare_hash(bmi, bits, sha1, "clipped solid vlines");
memset(bits, 0xcc, dib_size);
for(i = 0; i < sizeof(line_clips)/sizeof(line_clips[0]); i++)
{
MoveToEx(hdc, line_clips[i].left, line_clips[i].top, NULL);
LineTo(hdc, line_clips[i].right, line_clips[i].bottom);
}
compare_hash(bmi, bits, sha1, "clipped solid diagonal lines");
memset(bits, 0xcc, dib_size);
/* clipped PatBlt */
for(i = 0; i < sizeof(patblt_clips) / sizeof(patblt_clips[0]); i++)
{
PatBlt(hdc, patblt_clips[i].left, patblt_clips[i].top,
patblt_clips[i].right - patblt_clips[i].left,
patblt_clips[i].bottom - patblt_clips[i].top, PATCOPY);
}
compare_hash(bmi, bits, sha1, "clipped patblt");
memset(bits, 0xcc, dib_size);
/* clipped dashed lines */
dashed_pen = CreatePen(PS_DASH, 1, RGB(0xff, 0, 0));
SelectObject(hdc, dashed_pen);
SetBkMode(hdc, TRANSPARENT);
SetBkColor(hdc, RGB(0, 0xff, 0));
for(i = 0; i < sizeof(hline_clips)/sizeof(hline_clips[0]); i++)
{
MoveToEx(hdc, hline_clips[i].left, hline_clips[i].top, NULL);
LineTo(hdc, hline_clips[i].right, hline_clips[i].bottom);
}
compare_hash(bmi, bits, sha1, "clipped dashed hlines");
memset(bits, 0xcc, dib_size);
for(i = 0; i < sizeof(hline_clips)/sizeof(hline_clips[0]); i++)
{
MoveToEx(hdc, hline_clips[i].right - 1, hline_clips[i].bottom, NULL);
LineTo(hdc, hline_clips[i].left - 1, hline_clips[i].top);
}
compare_hash(bmi, bits, sha1, "clipped dashed hlines r -> l");
memset(bits, 0xcc, dib_size);
for(i = 0; i < sizeof(vline_clips)/sizeof(vline_clips[0]); i++)
{
MoveToEx(hdc, vline_clips[i].left, vline_clips[i].top, NULL);
LineTo(hdc, vline_clips[i].right, vline_clips[i].bottom);
}
compare_hash(bmi, bits, sha1, "clipped dashed vlines");
memset(bits, 0xcc, dib_size);
for(i = 0; i < sizeof(vline_clips)/sizeof(vline_clips[0]); i++)
{
MoveToEx(hdc, vline_clips[i].right, vline_clips[i].bottom - 1, NULL);
LineTo(hdc, vline_clips[i].left, vline_clips[i].top - 1);
}
compare_hash(bmi, bits, sha1, "clipped dashed vlines b -> t");
memset(bits, 0xcc, dib_size);
for(i = 0; i < sizeof(line_clips)/sizeof(line_clips[0]); i++)
{
MoveToEx(hdc, line_clips[i].left, line_clips[i].top, NULL);
LineTo(hdc, line_clips[i].right, line_clips[i].bottom);
}
compare_hash(bmi, bits, sha1, "clipped dashed diagonal lines");
memset(bits, 0xcc, dib_size);
SetBkMode(hdc, OPAQUE);
for(i = 0; i < sizeof(line_clips)/sizeof(line_clips[0]); i++)
{
MoveToEx(hdc, line_clips[i].left, line_clips[i].top, NULL);
LineTo(hdc, line_clips[i].right, line_clips[i].bottom);
}
compare_hash(bmi, bits, sha1, "clipped opaque dashed diagonal lines");
memset(bits, 0xcc, dib_size);
ExtSelectClipRgn(hdc, NULL, RGN_COPY);
/* 8888 DIB pattern brush */
brush_bi->bmiHeader = dib_brush_header_8888;
brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER);
memset(brush_bits, 0, 16 * 16 * sizeof(DWORD));
brush_bits[2] = 0xff;
brush_bits[6] = 0xff;
brush_bits[14] = 0xff;
brush_bits[65] = 0xff;
brush_bits[69] = 0xff;
brush_bits[72] = 0xff;
dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
SelectObject(hdc, dib_brush);
SetBrushOrgEx(hdc, 1, 1, NULL);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "top-down 8888 dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
DeleteObject(dib_brush);
/* 8888 bottom-up DIB pattern brush */
brush_bi->bmiHeader.biHeight = -brush_bi->bmiHeader.biHeight;
dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
SelectObject(hdc, dib_brush);
/* This used to set the x origin to 100 as well, but
there's a Windows bug for 24 bpp where the brush's x offset
is incorrectly calculated for rops that involve both D and P */
SetBrushOrgEx(hdc, 4, 100, NULL);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "bottom-up 8888 dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
DeleteObject(dib_brush);
/* 24 bpp dib pattern brush */
brush_bi->bmiHeader = dib_brush_header_24;
brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER);
memset(brush_bits, 0, 16 * 16 * 3);
brush_bits[0] = brush_bits[3] = brush_bits[6] = brush_bits[8] = 0xff;
brush_bits[49] = brush_bits[52] = 0xff;
dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
SelectObject(hdc, dib_brush);
SetBrushOrgEx(hdc, 1, 1, NULL);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "top-down 24 bpp brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
DeleteObject(dib_brush);
/* 555 dib pattern brush */
brush_bi->bmiHeader = dib_brush_header_555;
brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER);
memset(brush_bits, 0, 16 * 16 * sizeof(WORD));
brush_bits[0] = brush_bits[1] = 0xff;
brush_bits[32] = brush_bits[34] = 0x7c;
dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
SelectObject(hdc, dib_brush);
SetBrushOrgEx(hdc, 1, 1, NULL);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "top-down 555 dib brush patblt", dib_is_1bpp ? 1 : 0, dib_is_1bpp);
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
DeleteObject(dib_brush);
SetBrushOrgEx(hdc, 0, 0, NULL);
/* 8 bpp dib pattern brush */
brush_bi->bmiHeader = dib_brush_header_8;
brush_bi->bmiHeader.biClrUsed = 3;
memset(brush_bi->bmiColors, 0, brush_bi->bmiHeader.biClrUsed * sizeof(RGBQUAD));
brush_bi->bmiColors[0].rgbRed = 0xff;
brush_bi->bmiColors[1].rgbRed = 0xff;
brush_bi->bmiColors[1].rgbGreen = 0xff;
brush_bi->bmiColors[1].rgbBlue = 0xff;
brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER) + brush_bi->bmiHeader.biClrUsed * sizeof(RGBQUAD);
memset(brush_bits, 0, 16 * 16 * sizeof(BYTE));
brush_bits[0] = brush_bits[1] = 1;
brush_bits[16] = brush_bits[17] = 2;
brush_bits[32] = brush_bits[33] = 6;
dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
SelectObject(hdc, dib_brush);
SetBrushOrgEx(hdc, 1, 1, NULL);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "top-down 8 bpp dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
DeleteObject(dib_brush);
/* 4 bpp dib pattern brush */
brush_bi->bmiHeader = dib_brush_header_4;
dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
SelectObject(hdc, dib_brush);
SetBrushOrgEx(hdc, 1, 1, NULL);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "top-down 4 bpp dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
DeleteObject(dib_brush);
/* 1 bpp dib pattern brush */
brush_bi->bmiHeader = dib_brush_header_1;
brush_bi->bmiHeader.biClrUsed = 2;
memset(brush_bits, 0, 16 * 4);
brush_bits[0] = 0xf0;
brush_bits[4] = 0xf0;
brush_bits[8] = 0xf0;
dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
SelectObject(hdc, dib_brush);
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "top-down 1 bpp dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
SetBrushOrgEx(hdc, 0, 0, NULL);
/* Rectangle */
SelectObject(hdc, solid_pen);
SelectObject(hdc, solid_brush);
for(i = 0; i < sizeof(rectangles)/sizeof(rectangles[0]); i++)
{
Rectangle(hdc, rectangles[i].left, rectangles[i].top, rectangles[i].right, rectangles[i].bottom);
}
SelectObject(hdc, dashed_pen);
for(i = 0; i < sizeof(rectangles)/sizeof(rectangles[0]); i++)
{
Rectangle(hdc, rectangles[i].left, rectangles[i].top + 150, rectangles[i].right, rectangles[i].bottom + 150);
}
compare_hash(bmi, bits, sha1, "rectangles");
memset(bits, 0xcc, dib_size);
SelectObject(hdc, solid_pen);
/* PaintRgn */
PaintRgn(hdc, hrgn);
compare_hash(bmi, bits, sha1, "PaintRgn");
memset(bits, 0xcc, dib_size);
/* RTL rectangles */
if( !pSetLayout )
{
win_skip("Don't have SetLayout\n");
(*sha1)++;
}
else
{
pSetLayout(hdc, LAYOUT_RTL);
PaintRgn(hdc, hrgn);
PatBlt(hdc, 10, 250, 10, 10, PATCOPY);
Rectangle(hdc, 100, 250, 110, 260);
compare_hash(bmi, bits, sha1, "rtl");
memset(bits, 0xcc, dib_size);
pSetLayout(hdc, LAYOUT_LTR);
}
for(i = 0, y = 10; i < 256; i++)
{
BOOL ret;
if(!rop_uses_src(rop3[i]))
{
for(hatch_style = HS_HORIZONTAL; hatch_style <= HS_DIAGCROSS; hatch_style++)
{
hatch_brush = CreateHatchBrush(hatch_style, RGB(0xff, 0, 0));
SelectObject(hdc, hatch_brush);
ret = PatBlt(hdc, 10 + i + 30 * hatch_style, y, 20, 20, rop3[i]);
ok(ret, "got FALSE for %x\n", rop3[i]);
SelectObject(hdc, orig_brush);
DeleteObject(hatch_brush);
}
y += 25;
}
}
compare_hash_broken_todo(bmi, bits, sha1, "hatch brushes", 1, FALSE); /* nt4 is different */
memset(bits, 0xcc, dib_size);
SelectObject(hdc, orig_brush);
SelectObject(hdc, orig_pen);
DeleteObject(hrgn);
DeleteObject(dib_brush);
DeleteObject(dashed_pen);
DeleteObject(solid_brush);
DeleteObject(solid_pen);
}
void apply_light_mask()
{
GrafPtr old_port;
Rect temp = {0,0,108,84},paint_rect,base_rect = {0,0,36,28};
Rect big_to = {13,13,337,265};
short i,j;
bool is_dark = false,same_mask = true;
if (PSD[SDF_NO_FRILLS] > 0)
return;
if (is_out())
return;
if (univ.town->lighting_type == 0)
return;
if (oval_region == NULL) {
temp_rect_rgn = NewRgn();
dark_mask_region = NewRgn();
oval_region = NewRgn();
OpenRgn();
FrameOval(&temp);
CloseRgn(oval_region);
}
// Process the light array
for (i = 2; i < 11; i++)
for (j = 2; j < 11; j++)
if (light_area[i][j] == 0) is_dark = true;
if (is_dark == false) {
for (i = 2; i < 11; i++)
for (j = 2; j < 11; j++)
last_light_mask[i][j] = 0;
return;
}
for (i = 1; i < 12; i++)
for (j = 1; j < 12; j++)
if ((light_area[i - 1][j - 1] >= 1) && (light_area[i + 1][j - 1] >= 1) &&
(light_area[i - 1][j] >= 1) && (light_area[i + 1][j] >= 1) &&
(light_area[i - 1][j + 1] >= 1) && (light_area[i + 1][j + 1] >= 1) &&
(light_area[i][j - 1] >= 1) && (light_area[i][j + 1] >= 1)) {
light_area[i][j] = 2;
}
for (i = 1; i < 12; i++)
for (j = 1; j < 12; j++)
if ((light_area[i - 1][j - 1] >= 2) && (light_area[i + 1][j - 1] >= 2) &&
(light_area[i - 1][j] >= 2) && (light_area[i + 1][j] >= 2) &&
(light_area[i - 1][j + 1] >= 2) && (light_area[i + 1][j + 1] >= 2) &&
(light_area[i][j - 1] >= 2) && (light_area[i][j + 1] >= 2)) {
light_area[i][j] = 3;
}
GetPort(&old_port);
SetPort(terrain_screen_gworld);
for (i = 2; i < 11; i++)
for (j = 2; j < 11; j++) {
if (light_area[i][j] == 1)
terrain_there[i - 2][j - 2] = -1;
}
for (i = 0; i < 13; i++)
for (j = 0; j < 13; j++)
if (last_light_mask[i][j] != light_area[i][j])
same_mask = false;
if (same_mask == true) {
PaintRgn(dark_mask_region);
SetPort(old_port);
return;
}
SetRectRgn(dark_mask_region,big_to.left,big_to.top,big_to.right,big_to.bottom);
for (i = 0; i < 13; i++)
for (j = 0; j < 13; j++)
last_light_mask[i][j] = light_area[i][j];
for (i = 1; i < 12; i++)
for (j = 1; j < 12; j++) {
if (light_area[i][j] == 2) {
OffsetRgn(oval_region,13 + 28 * (i - 3), 13 + 36 * (j - 3));
DiffRgn(dark_mask_region,oval_region,dark_mask_region);
OffsetRgn(oval_region,-13 + -1 * (28 * (i - 3)),-13 + -1 * (36 * (j - 3)));
//PaintRect(&paint_rect);
}
if (light_area[i][j] == 3) {
paint_rect = base_rect;
OffsetRect(&paint_rect,13 + 28 * (i - 2),13 + 36 * (j - 2));
SetRectRgn(temp_rect_rgn,paint_rect.left,paint_rect.top,
paint_rect.right + 28,paint_rect.bottom + 36);
DiffRgn(dark_mask_region,temp_rect_rgn,dark_mask_region);
if (light_area[i + 1][j] == 3) light_area[i + 1][j] = 0;
if (light_area[i + 1][j + 1] == 3) light_area[i + 1][j + 1] = 0;
if (light_area[i][j + 1] == 3) light_area[i][j + 1] = 0;
}
}
//rect_draw_some_item(light_mask_gworld,big_from,terrain_screen_gworld,big_to,0,0);
PaintRgn(dark_mask_region);
SetPort(old_port);
}
// funkcja okna zawieraj¹ca obs³ugê meldunków przesy³anych do okna
LRESULT CALLBACK WndProc (HWND Okno, UINT KodMeldunku, WPARAM wParam, LPARAM lParam)
{
// deklaracja zmiennych
static POINT Punkty[100]; // tablica klikniêæ
static POINT Punkty2[100]; // tablica klikniêæ
static int rozmiary[100], regiony[100];
static int lPunktow = 0;
static int lPunktow2 = 0;
static int i = 50;
static int ii=0;
static bool leftMouse;
static bool rightMouse;
static bool negatyw = false;
HMENU mGlowne, mPlik, mRozmiar, mKolor, mInfo;
// obs³uga meldunku w zale¿noœci od kodu meldunku
switch (KodMeldunku)
{ case WM_CREATE: // obs³uga utworzenia okna - stworzenie menu
mPlik = CreateMenu();
AppendMenu(mPlik, MF_STRING, 100, "&Gong...");
AppendMenu(mPlik, MF_SEPARATOR, 0, "");
AppendMenu(mPlik, MF_STRING, 101, "&Koniec");
mRozmiar = CreateMenu();
AppendMenu(mRozmiar, MF_STRING, 103, "&Du¿e");
AppendMenu(mRozmiar, MF_STRING, 104, "&Ma³e");
mKolor = CreateMenu();
AppendMenu(mKolor, MF_STRING, 105, "&Podstawowy");
AppendMenu(mKolor, MF_STRING, 106, "&Negatyw");
mInfo = CreateMenu();
AppendMenu(mInfo, MF_STRING, 102, "&Autor...");
mGlowne = CreateMenu();
AppendMenu(mGlowne, MF_POPUP, (UINT_PTR) mPlik, "&Plik");
AppendMenu(mGlowne, MF_POPUP, (UINT_PTR) mRozmiar, "&Rozmiar");
AppendMenu(mGlowne, MF_POPUP, (UINT_PTR) mKolor, "&Kolor");
AppendMenu(mGlowne, MF_POPUP, (UINT_PTR) mInfo, "&Info");
SetMenu(Okno, mGlowne);
DrawMenuBar(Okno);
Punkty[lPunktow].x=200; // wype³nienie pierwszej pozycji tablicy klikniêæ
Punkty[lPunktow].y=200;
lPunktow++;
InvalidateRect(Okno, NULL, TRUE); // wymuszenie meldunku WM_PAINT
return 0;
case WM_COMMAND: // obs³uga wyboru opcji z menu
switch (wParam)
{
case 100: if(MessageBox(Okno, "Czy wygenerowaæ gong?", "Gong", MB_YESNO) == IDYES)
MessageBeep(0);
break;
case 101: DestroyWindow(Okno); // wymuszenie meldunku WM_DESTROY
break;
case 102: MessageBox(Okno, "imiê i nazwisko: Katarzyna Wolszon\nnumer indeksu: s8133", "Student PJWSTK", MB_OK);
break;
case 103: ii = 50;
break;
case 104: ii = 0;
break;
case 105: negatyw = false; //kolor podstawowy
break;
case 106: negatyw = true; //negatyw
break;
}
return 0;
case WM_LBUTTONDOWN: // obs³uga wciœniêcia lewego przycisku myszki
leftMouse=true;
rightMouse=false;
if(lPunktow >= sizeof(Punkty)/sizeof(POINT)) lPunktow = 0; // przepe³nienie tablicy klikniêæ
Punkty[lPunktow].x = LOWORD(lParam); // zapisanie wspó³rzêdnych kursora w tablicy klikniêæ
Punkty[lPunktow].y = HIWORD(lParam);
rozmiary[lPunktow] = ii;
//if (negatyw) negatywT[lPunktow] = true;
//else negatywT[lPunktow] = false;
lPunktow++;
InvalidateRect(Okno, NULL, leftMouse); // wymuszenie meldunku WM_PAINT
return 0;
case WM_RBUTTONDOWN: // obs³uga wciœniêcia prawego przycisku myszki
leftMouse=false;
rightMouse=true;
if(lPunktow2 >= sizeof(Punkty2)/sizeof(POINT)) lPunktow2 = 0; // przepe³nienie tablicy klikniêæ
Punkty2[lPunktow2].x = LOWORD(lParam); // zapisanie wspó³rzêdnych kursora w tablicy klikniêæ
Punkty2[lPunktow2].y = HIWORD(lParam);
lPunktow2++;
InvalidateRect(Okno, NULL, rightMouse); // wymuszenie meldunku WM_PAINT
return 0;
case WM_PAINT: // obs³uga odœwie¿enia okna
{ PAINTSTRUCT Paint;
HDC Kontekst = BeginPaint(Okno, &Paint);
char Tekst[] = "Katarzyna Wolszon Katarzyna Wolszon Katarzyna Wolszon Katarzyna Wolszon Katarzyna Wolszon Katarzyna Wolszon Katarzyna Wolszon Katarzyna Wolszon Katarzyna Wolszon Katarzyna Wolszon Katarzyna Wolszon";
POINT Wielokat1[] = {{100, 100}, {120+i, 100}, {120+i, 150+i/2}, {170+i, 100},{190+i*2, 100}, {120+i, 170+i}, {190+i*2, 280+i}, {170+i, 280+i},{120+i, 200+i+i/2}, {120+i, 280+i}, {100, 280+i}};
POINT Wielokat2[] = {{200+i*2, 100}, {220+i*3, 100}, {220+i*3, 260}, {260+i*3, 240},{320+i*3, 260}, {320+i*3, 100}, {340+i*4, 100}, {340+i*4, 280+i},{320+i*3, 280+i}, {260+i*3, 260+i}, {220+i*3, 280+i}, {200+i*2, 280+i}};
POINT Wielokat1m[] = {{100, 100}, {120, 100}, {120, 150}, {170, 100},{190, 100}, {120, 170}, {190, 280}, {170, 280},{120, 200}, {120, 280}, {100, 280}};
POINT Wielokat2m[] = {{200, 100}, {220, 100}, {220, 260}, {260, 240},{320, 260}, {320, 100}, {340, 100}, {340, 280},{320, 280}, {260, 260}, {220, 280}, {200, 280}};
HBRUSH Pedzel = CreateSolidBrush(RGB(255,0,0)); // czerwony pêdzel
HBRUSH Pedzel1 = CreateSolidBrush(RGB(0,0,255));
HBRUSH Pedzel2 = CreateSolidBrush(RGB(0,255,255));
HBRUSH Pedzel3 = CreateSolidBrush(RGB(255,255,0));
HPEN Pioro2 = CreatePen(PS_SOLID, 2, RGB(0,255,255));
HPEN Pioro3 = CreatePen(PS_SOLID, 2, RGB(255,255,0));
SelectObject(Kontekst, GetStockObject(NULL_PEN));
SetBkMode(Kontekst, TRANSPARENT);
HRGN Region0 = CreatePolygonRgn(Wielokat1, 11, WINDING);
HRGN Region1 = CreatePolygonRgn(Wielokat2, 12, WINDING);
HRGN Region2 = CreateRectRgn(0, 0, 0, 0); // pusty region
//HRGN Region3 = CreatePolygonRgn(Wielokat1m, 11, WINDING);
//HRGN Region4 = CreatePolygonRgn(Wielokat2m, 12, WINDING);
//HRGN RegionT = CreateRectRgn(0, 0, 0, 0); // pusty region
for(int n=0; n<lPunktow; n++)
{
OffsetRgn(Region0, Punkty[n].x-200, Punkty[n].y-200);
OffsetRgn(Region1, Punkty[n].x-200, Punkty[n].y-200);
CombineRgn(Region2, Region1, Region0, RGN_OR);
//SelectClipRgn(Kontekst, Region2);
//SelectObject(Kontekst, GetStockObject(WHITE_BRUSH)); // standardowy bia³y pêdzel
//PaintRgn(Kontekst, Region2);
//FrameRgn(Kontekst, Region2, Pedzel, 15, 15);
SelectClipRgn(Kontekst, Region0);
SelectObject(Kontekst, Pedzel);
PaintRgn(Kontekst, Region0);
SelectClipRgn(Kontekst, Region1);
SelectObject(Kontekst, Pedzel1);
PaintRgn(Kontekst, Region1);
//CombineRgn(RegionT, RegionT, Region2, RGN_OR);
SelectClipRgn(Kontekst, Region2);
WORD Odstep = HIWORD(GetDialogBaseUnits());
for(int y = 0; y < 850; y = y+Odstep) TextOut(Kontekst, 0, y, Tekst, strlen(Tekst));
OffsetRgn(Region0, -Punkty[n].x+200, -Punkty[n].y+200);
OffsetRgn(Region1, -Punkty[n].x+200, -Punkty[n].y+200);
}
for(int j=0; j<lPunktow2; j++){
SetViewportOrgEx(Kontekst,Punkty2[j].x-500,Punkty2[j].y-400,NULL);
SelectObject(Kontekst, Pioro2);
Polygon(Kontekst, Wielokat1m, 11);
SelectObject(Kontekst, Pioro3);
Polygon(Kontekst, Wielokat2m, 12);
}
DeleteObject(Pedzel);
DeleteObject(Pedzel1);
DeleteObject(Pedzel2);
DeleteObject(Pedzel3);
DeleteObject(Pioro2);
DeleteObject(Pioro3);
EndPaint(Okno, &Paint);
}
return 0;
case WM_DESTROY: // obs³uga zamkniêcia okna - wygenerowanie meldunku WM_QUIT
PostQuitMessage (0) ;
return 0;
default: // standardowa obs³uga wszystkich pozosta³ych meldunków
return DefWindowProc(Okno, KodMeldunku, wParam, lParam);
}
}
