void KTraceEMF::CompareDC(HDC hDC)
{
Compare(m_value[0], GetMapMode(hDC), "MapMode : %d\r\n");
Compare(m_value[1], GetGraphicsMode(hDC), "GraphicsMode : %d\r\n");
XFORM xm;
GetWorldTransform(hDC, & xm);
Compare(m_float[0], xm.eM11, "WT.eM11 : %8.5f\r\n");
Compare(m_float[1], xm.eM12, "WT.eM12 : %8.5f\r\n");
Compare(m_float[2], xm.eM21, "WT.eM21 : %8.5f\r\n");
Compare(m_float[3], xm.eM22, "WT.eM22 : %8.5f\r\n");
Compare(m_float[4], xm.eDx, "WT.eDx : %8.5f\r\n");
Compare(m_float[5], xm.eDy, "WT.eDy : %8.5f\r\n");
Compare(m_value[2], GetBkMode(hDC), "BkMode : %d\r\n");
Compare(m_value[3], GetROP2(hDC), "ROP2 : %d\r\n");
Compare(m_value[4], ((int)GetTextAlign(hDC)), "TextAlign : 0x%x\r\n");
Compare(m_object[0], GetCurrentObject(hDC, OBJ_PEN), "Pen : 0x%08x\r\n");
Compare(m_object[1], GetCurrentObject(hDC, OBJ_BRUSH), "Brush : 0x%08x\r\n");
Compare(m_object[2], GetCurrentObject(hDC, OBJ_FONT), "Font : 0x%08x\r\n");
Compare(m_object[3], GetCurrentObject(hDC, OBJ_PAL), "Palette : 0x%08x\r\n");
Compare(m_object[4], GetCurrentObject(hDC, OBJ_COLORSPACE), "ColorSpace : 0x%08x\r\n");
Compare(m_object[5], GetCurrentObject(hDC, OBJ_BITMAP), "Bitmap : 0x%08x\r\n");
}
static void mswin_crosshair(int id, int x, int y)
{
HPEN mswin_cursorpen;
HPEN oldpen;
HDC hdc;
int oldmode;
G_PALETTEENTRY g_palette;
if (WI[id].hdc_cross) {
g_bell();
return;
}
INTERNAL_get_palette_color(&g_palette, G_WHITE);
WI[id].hdc_cross = GetDC(WI[id].child[C_DRAWAREA].hwnd);
mswin_cursorpen = CreatePen(PS_SOLID,
1,
RGB(g_palette.r,
g_palette.g,
g_palette.b));
oldmode = GetROP2(WI[id].hdc_cross);
SetROP2(WI[id].hdc_cross, R2_XORPEN);
oldpen = SelectObject(WI[id].hdc_cross, mswin_cursorpen);
mswin_draw_cursor_func[id] (id, x, y);
SelectObject(WI[id].hdc_cross, oldpen);
DeleteObject(mswin_cursorpen);
SetROP2(WI[id].hdc_cross, oldmode);
ReleaseDC(WI[id].child[C_DRAWAREA].hwnd, WI[id].hdc_cross);
WI[id].hdc_cross = NULL;
}
/***********************************************************************
* PSDRV_Rectangle
*/
BOOL PSDRV_Rectangle( PHYSDEV dev, INT left, INT top, INT right, INT bottom )
{
PSDRV_PDEVICE *physDev = get_psdrv_dev( dev );
RECT rect;
TRACE("%d %d - %d %d\n", left, top, right, bottom);
rect.left = left;
rect.top = top;
rect.right = right;
rect.bottom = bottom;
LPtoDP( dev->hdc, (POINT *)&rect, 2 );
/* Windows does something truly hacky here. If we're in passthrough mode
and our rop is R2_NOP, then we output the string below. This is used in
Office 2k when inserting eps files */
if(physDev->job.in_passthrough && !physDev->job.had_passthrough_rect && GetROP2(dev->hdc) == R2_NOP) {
char buf[256];
sprintf(buf, "N %d %d %d %d B\n", rect.right - rect.left, rect.bottom - rect.top, rect.left, rect.top);
write_spool(dev, buf, strlen(buf));
physDev->job.had_passthrough_rect = TRUE;
return TRUE;
}
PSDRV_SetPen(dev);
PSDRV_SetClip(dev);
PSDRV_WriteRectangle(dev, rect.left, rect.top, rect.right - rect.left,
rect.bottom - rect.top );
PSDRV_Brush(dev,0);
PSDRV_DrawLine(dev);
PSDRV_ResetClip(dev);
return TRUE;
}
/***********************************************************************
* dibdrv_SelectBrush
*/
HBRUSH CDECL dibdrv_SelectBrush( PHYSDEV dev, HBRUSH hbrush )
{
PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSelectBrush );
dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
LOGBRUSH logbrush;
TRACE("(%p, %p)\n", dev, hbrush);
if (!GetObjectW( hbrush, sizeof(logbrush), &logbrush )) return 0;
if (hbrush == GetStockObject( DC_BRUSH ))
logbrush.lbColor = GetDCBrushColor( dev->hdc );
pdev->brush_style = logbrush.lbStyle;
pdev->defer |= DEFER_BRUSH;
free_pattern_brush( pdev );
switch(logbrush.lbStyle)
{
case BS_SOLID:
pdev->brush_color = pdev->dib.funcs->colorref_to_pixel(&pdev->dib, logbrush.lbColor);
calc_and_xor_masks(GetROP2(dev->hdc), pdev->brush_color, &pdev->brush_and, &pdev->brush_xor);
pdev->brush_rects = solid_brush;
pdev->defer &= ~DEFER_BRUSH;
break;
case BS_NULL:
pdev->brush_rects = null_brush;
pdev->defer &= ~DEFER_BRUSH;
break;
case BS_DIBPATTERN:
{
BITMAPINFOHEADER *bi = GlobalLock((HGLOBAL)logbrush.lbHatch);
dib_info orig_dib;
if(!bi) return NULL;
if(init_dib_info_from_packed(&orig_dib, bi, LOWORD(logbrush.lbColor)))
{
copy_dib_color_info(&pdev->brush_dib, &pdev->dib);
if(convert_dib(&pdev->brush_dib, &orig_dib))
{
pdev->brush_rects = pattern_brush;
pdev->defer &= ~DEFER_BRUSH;
}
free_dib_info(&orig_dib, FALSE);
}
GlobalUnlock((HGLOBAL)logbrush.lbHatch);
break;
}
default:
break;
}
return next->funcs->pSelectBrush( next, hbrush );
}
void SystemDraw::DrawPolyPolyPolygonOp(const Point *vertices, int vertex_count,
const int *subpolygon_counts, int subpolygon_count_count,
const int *disjunct_polygon_counts, int disjunct_polygon_count_count,
Color color, int width, Color outline, uint64 pattern, Color doxor)
{
GuiLock __;
if(vertex_count == 0)
return;
bool is_xor = !IsNull(doxor);
HDC hdc = GetHandle();
if(pattern) {
int old_rop = GetROP2(hdc);
HGDIOBJ old_brush = GetCurrentObject(hdc, OBJ_BRUSH);
word wpat[8] = {
(byte)(pattern >> 56), (byte)(pattern >> 48), (byte)(pattern >> 40), (byte)(pattern >> 32),
(byte)(pattern >> 24), (byte)(pattern >> 16), (byte)(pattern >> 8), (byte)(pattern >> 0),
};
HBITMAP bitmap = CreateBitmap(8, 8, 1, 1, wpat);
HBRUSH brush = ::CreatePatternBrush(bitmap);
COLORREF old_bk = GetBkColor(hdc);
COLORREF old_fg = GetTextColor(hdc);
if(!is_xor) {
SetROP2(hdc, R2_MASKPEN);
SelectObject(hdc, brush);
SetTextColor(hdc, Black());
SetBkColor(hdc, White());
SetDrawPen(PEN_NULL, Black);
DrawPolyPolyPolygonRaw(*this, vertices, vertex_count,
subpolygon_counts, subpolygon_count_count,
disjunct_polygon_counts, disjunct_polygon_count_count);
SetROP2(hdc, R2_MERGEPEN);
SetTextColor(hdc, color);
SetBkColor(hdc, Black());
}
else {
SetROP2(hdc, R2_XORPEN);
SetTextColor(hdc, COLORREF(color) ^ COLORREF(doxor));
SelectObject(hdc, brush);
}
DrawPolyPolyPolygonRaw(*this, vertices, vertex_count,
subpolygon_counts, subpolygon_count_count,
disjunct_polygon_counts, disjunct_polygon_count_count);
SelectObject(hdc, old_brush);
SetTextColor(hdc, old_fg);
SetBkColor(hdc, old_bk);
SetROP2(hdc, old_rop);
DeleteObject(brush);
DeleteObject(bitmap);
if(!IsNull(outline)) {
SetColor(Null);
SetDrawPen(width, outline);
ASSERT(sizeof(POINT) == sizeof(Point));
DrawPolyPolyPolygonRaw(*this, vertices, vertex_count,
subpolygon_counts, subpolygon_count_count,
disjunct_polygon_counts, disjunct_polygon_count_count);
}
}
else { // simple fill
void tTVPDrawer_DrawDibNoBuffering::NotifyBitmapCompleted(tjs_int x, tjs_int y, const void * bits, const BITMAPINFO * bitmapinfo,
const tTVPRect &cliprect)
{
// DrawDibDraw にて TargetDC に描画を行う
if(DrawDibHandle && TargetDC)
DrawDibDraw(DrawDibHandle,
TargetDC,
x + DestLeft,
y + DestTop,
cliprect.get_width(),
cliprect.get_height(),
const_cast<BITMAPINFOHEADER*>(reinterpret_cast<const BITMAPINFOHEADER*>(bitmapinfo)),
const_cast<void*>(bits),
cliprect.left,
cliprect.top,
cliprect.get_width(),
cliprect.get_height(),
0);
// 更新矩形の表示
if(DrawUpdateRectangle)
{
if(!BluePen) BluePen = CreatePen(PS_SOLID, 1, RGB(0, 0, 255));
if(!YellowPen) YellowPen = CreatePen(PS_SOLID, 1, RGB(255, 255, 0));
HPEN oldpen;
int ROP_save = GetROP2(TargetDC);
tjs_int rleft = x + DestLeft;
tjs_int rtop = y + DestTop;
tjs_int rright = rleft + cliprect.get_width();
tjs_int rbottom = rtop + cliprect.get_height();
POINT points[5];
points[0].x = rleft;
points[0].y = rtop;
points[1].x = rright -1;
points[1].y = rtop;
points[2].x = rright -1;
points[2].y = rbottom -1;
points[3].x = rleft;
points[3].y = rbottom -1;
points[4] = points[0];
oldpen = SelectObject(TargetDC, BluePen);
SetROP2(TargetDC, R2_NOTMASKPEN);
Polyline(TargetDC, points, 4);
SelectObject(TargetDC, YellowPen);
SetROP2(TargetDC, R2_MERGEPEN);
Polyline(TargetDC, points, 5);
SelectObject(TargetDC, oldpen);
}
}
/***********************************************************************
* dibdrv_SetDCPenColor
*/
COLORREF CDECL dibdrv_SetDCPenColor( PHYSDEV dev, COLORREF color )
{
PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSetDCPenColor );
dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
if (GetCurrentObject(dev->hdc, OBJ_PEN) == GetStockObject( DC_PEN ))
{
pdev->pen_color = pdev->dib.funcs->colorref_to_pixel(&pdev->dib, color);
calc_and_xor_masks(GetROP2(dev->hdc), pdev->pen_color, &pdev->pen_and, &pdev->pen_xor);
}
return next->funcs->pSetDCPenColor( next, color );
}
/***********************************************************************
* dibdrv_SetDCBrushColor
*/
COLORREF CDECL dibdrv_SetDCBrushColor( PHYSDEV dev, COLORREF color )
{
PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSetDCBrushColor );
dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
if (GetCurrentObject(dev->hdc, OBJ_BRUSH) == GetStockObject( DC_BRUSH ))
{
pdev->brush_colorref = color;
pdev->brush_color = get_fg_color( pdev, pdev->brush_colorref );
calc_and_xor_masks(GetROP2(dev->hdc), pdev->brush_color, &pdev->brush_and, &pdev->brush_xor);
}
return next->funcs->pSetDCBrushColor( next, color );
}
/***************************************************************************
* get_pen_bkgnd_masks
*
* Returns the pre-calculated bkgnd color masks unless the dib is 1 bpp.
* In this case since there are several fg sources (pen, brush, text)
* this makes pdev->bkgnd_color unusable. So here we take the inverse
* of the relevant fg color (which is always set up correctly).
*/
static inline void get_pen_bkgnd_masks(const dibdrv_physdev *pdev, DWORD *and, DWORD *xor)
{
if(pdev->dib.bit_count != 1 || GetBkMode(pdev->dev.hdc) == TRANSPARENT)
{
*and = pdev->bkgnd_and;
*xor = pdev->bkgnd_xor;
}
else
{
DWORD color = ~pdev->pen_color;
if(pdev->pen_colorref == GetBkColor(pdev->dev.hdc)) color = pdev->pen_color;
calc_and_xor_masks( GetROP2(pdev->dev.hdc), color, and, xor );
}
}
/***********************************************************************
* dibdrv_SetBkMode
*/
static INT dibdrv_SetBkMode( PHYSDEV dev, INT mode )
{
PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSetBkMode );
dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
if( mode == OPAQUE )
calc_and_xor_masks( GetROP2(dev->hdc), pdev->bkgnd_color, &pdev->bkgnd_and, &pdev->bkgnd_xor );
else
{
pdev->bkgnd_and = ~0u;
pdev->bkgnd_xor = 0;
}
return next->funcs->pSetBkMode( next, mode );
}
/***********************************************************************
* dibdrv_SetDIBColorTable
*/
static UINT dibdrv_SetDIBColorTable( PHYSDEV dev, UINT pos, UINT count, const RGBQUAD *colors )
{
PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSetDIBColorTable );
dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
TRACE("(%p, %d, %d, %p)\n", dev, pos, count, colors);
if( pdev->dib.color_table && pos < pdev->dib.color_table_size )
{
if( pos + count > pdev->dib.color_table_size ) count = pdev->dib.color_table_size - pos;
memcpy( pdev->dib.color_table + pos, colors, count * sizeof(RGBQUAD) );
pdev->bkgnd_color = get_pixel_color( pdev, GetBkColor( dev->hdc ), FALSE );
update_fg_colors( pdev );
update_masks( pdev, GetROP2( dev->hdc ) );
}
return next->funcs->pSetDIBColorTable( next, pos, count, colors );
}
/***********************************************************************
* dibdrv_SetBkColor
*/
static COLORREF dibdrv_SetBkColor( PHYSDEV dev, COLORREF color )
{
PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSetBkColor );
dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
pdev->bkgnd_color = get_pixel_color( pdev, color, FALSE );
if( GetBkMode(dev->hdc) == OPAQUE )
calc_and_xor_masks( GetROP2(dev->hdc), pdev->bkgnd_color, &pdev->bkgnd_and, &pdev->bkgnd_xor );
else
{
pdev->bkgnd_and = ~0u;
pdev->bkgnd_xor = 0;
}
update_fg_colors( pdev ); /* Only needed in the 1 bpp case */
return next->funcs->pSetBkColor( next, color );
}
void
_gdk_win32_print_dc (HDC hdc)
{
HGDIOBJ obj;
LOGBRUSH logbrush;
EXTLOGPEN extlogpen;
HRGN hrgn;
RECT rect;
int flag;
g_print ("%p:\n", hdc);
obj = GetCurrentObject (hdc, OBJ_BRUSH);
GetObject (obj, sizeof (LOGBRUSH), &logbrush);
g_print ("brush: %s color=%06lx hatch=%p\n",
_gdk_win32_lbstyle_to_string (logbrush.lbStyle),
logbrush.lbColor, (gpointer) logbrush.lbHatch);
obj = GetCurrentObject (hdc, OBJ_PEN);
GetObject (obj, sizeof (EXTLOGPEN), &extlogpen);
g_print ("pen: %s %s %s %s w=%d %s\n",
_gdk_win32_pstype_to_string (extlogpen.elpPenStyle),
_gdk_win32_psstyle_to_string (extlogpen.elpPenStyle),
_gdk_win32_psendcap_to_string (extlogpen.elpPenStyle),
_gdk_win32_psjoin_to_string (extlogpen.elpPenStyle),
extlogpen.elpWidth,
_gdk_win32_lbstyle_to_string (extlogpen.elpBrushStyle));
g_print ("rop2: %s textcolor=%06lx\n",
_gdk_win32_rop2_to_string (GetROP2 (hdc)),
GetTextColor (hdc));
hrgn = CreateRectRgn (0, 0, 0, 0);
if ((flag = GetClipRgn (hdc, hrgn)) == -1)
WIN32_API_FAILED ("GetClipRgn");
else if (flag == 0)
g_print ("no clip region\n");
else if (flag == 1)
{
GetRgnBox (hrgn, &rect);
g_print ("clip region: %p bbox: %s\n",
hrgn, _gdk_win32_rect_to_string (&rect));
}
DeleteObject (hrgn);
}
void CPreviewDC::MirrorAttributes()
{
ASSERT(m_hAttribDC != NULL);
if (m_hDC != NULL)
{
// extract and re-set Pen and Brush
HGDIOBJ hTemp = ::SelectObject(m_hAttribDC, ::GetStockObject(BLACK_PEN));
::SelectObject(m_hAttribDC, hTemp);
::SelectObject(m_hDC, hTemp);
hTemp = ::SelectObject(m_hAttribDC, ::GetStockObject(BLACK_BRUSH));
::SelectObject(m_hAttribDC, hTemp);
::SelectObject(m_hDC, hTemp);
SetROP2(GetROP2());
SetBkMode(GetBkMode());
SetTextAlign(GetTextAlign());
SetPolyFillMode(GetPolyFillMode());
SetStretchBltMode(GetStretchBltMode());
SetTextColor(GetNearestColor(GetTextColor()));
SetBkColor(GetNearestColor(GetBkColor()));
}
}
/***********************************************************************
* dibdrv_SelectBrush
*/
HBRUSH dibdrv_SelectBrush( PHYSDEV dev, HBRUSH hbrush )
{
PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSelectBrush );
dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
LOGBRUSH logbrush;
TRACE("(%p, %p)\n", dev, hbrush);
if (!GetObjectW( hbrush, sizeof(logbrush), &logbrush )) return 0;
if (hbrush == GetStockObject( DC_BRUSH ))
logbrush.lbColor = GetDCBrushColor( dev->hdc );
pdev->brush_style = logbrush.lbStyle;
pdev->defer |= DEFER_BRUSH;
free_pattern_brush( pdev );
switch(logbrush.lbStyle)
{
case BS_SOLID:
pdev->brush_colorref = logbrush.lbColor;
pdev->brush_color = get_fg_color( pdev, pdev->brush_colorref );
calc_and_xor_masks(GetROP2(dev->hdc), pdev->brush_color, &pdev->brush_and, &pdev->brush_xor);
pdev->brush_rects = solid_brush;
pdev->defer &= ~DEFER_BRUSH;
break;
case BS_NULL:
pdev->brush_rects = null_brush;
pdev->defer &= ~DEFER_BRUSH;
break;
case BS_DIBPATTERN:
{
BITMAPINFOHEADER *bi = GlobalLock((HGLOBAL)logbrush.lbHatch);
dib_info orig_dib;
WORD usage = LOWORD(logbrush.lbColor);
HPALETTE pal = (usage == DIB_PAL_COLORS) ? GetCurrentObject(dev->hdc, OBJ_PAL) : NULL;
if(!bi) return NULL;
if(init_dib_info_from_packed(&orig_dib, bi, usage, pal))
{
copy_dib_color_info(&pdev->brush_dib, &pdev->dib);
if(convert_dib(&pdev->brush_dib, &orig_dib))
{
pdev->brush_rects = pattern_brush;
pdev->defer &= ~DEFER_BRUSH;
}
free_dib_info(&orig_dib);
}
GlobalUnlock((HGLOBAL)logbrush.lbHatch);
break;
}
case BS_HATCHED:
{
if(logbrush.lbHatch > HS_DIAGCROSS) return 0;
pdev->brush_hatch = logbrush.lbHatch;
pdev->brush_colorref = logbrush.lbColor;
pdev->brush_color = get_fg_color( pdev, pdev->brush_colorref );
calc_and_xor_masks(GetROP2(dev->hdc), pdev->brush_color, &pdev->brush_and, &pdev->brush_xor);
pdev->brush_rects = pattern_brush;
pdev->defer &= ~DEFER_BRUSH;
break;
}
default:
break;
}
return next->funcs->pSelectBrush( next, hbrush );
}
void TDC::xor_pen()
//-----------------
{ SetROP2(m_hdc, GetROP2(m_hdc)==R2_XORPEN ? R2_COPYPEN : R2_XORPEN); }
int LineTo_16bpp(HDC hdc, int nXEnd, int nYEnd)
{
int x, y;
int x1, y1;
int x2, y2;
int e, e2;
int dx, dy;
int sx, sy;
HBITMAP bmp;
int bx1, by1;
int bx2, by2;
int irop2;
uint16 pen;
uint16 *pixel;
x1 = hdc->pen->posX;
y1 = hdc->pen->posY;
x2 = nXEnd;
y2 = nYEnd;
dx = (x1 > x2) ? x1 - x2 : x2 - x1;
dy = (y1 > y2) ? y1 - y2 : y2 - y1;
sx = (x1 < x2) ? 1 : -1;
sy = (y1 < y2) ? 1 : -1;
e = dx - dy;
x = x1;
y = y1;
irop2 = GetROP2(hdc) - 1;
bmp = (HBITMAP) hdc->selectedObject;
if (hdc->clip->null)
{
bx1 = (x1 < x2) ? x1 : x2;
by1 = (y1 < y2) ? y1 : y2;
bx2 = (x1 > x2) ? x1 : x2;
by2 = (y1 > y2) ? y1 : y2;
}
else
{
bx1 = hdc->clip->x;
by1 = hdc->clip->y;
bx2 = bx1 + hdc->clip->w - 1;
by2 = by1 + hdc->clip->h - 1;
}
pen = GetPenColor_16bpp(hdc->pen);
while (1)
{
if (!(x == x2 && y == y2))
{
if ((x >= bx1 && x <= bx2) && (y >= by1 && y <= by2))
{
pixel = GetPointer_16bpp(bmp, x, y);
SetPixel16_ROP2_[irop2](pixel, &pen);
}
}
else
{
break;
}
e2 = 2 * e;
if (e2 > -dy)
{
e -= dy;
x += sx;
}
if (e2 < dx)
{
e += dx;
y += sy;
}
}
return 1;
}
void KDCAttributes::DumpDC(HDC hDC)
{
POINT pnt;
SIZE size;
m_List.DeleteAll();
Add(_T("Technology"), _T("%d"), GetDeviceCaps(hDC, TECHNOLOGY));
Add(_T("width"), _T("%d"), GetDeviceCaps(hDC, HORZRES));
Add(_T("height"), _T("%d"), GetDeviceCaps(hDC, VERTRES));
GetDCOrgEx(hDC, & pnt);
Add(_T("DC Origin"), _T("{ %d, %d }"), pnt.x, pnt.y);
TCHAR szTitle[MAX_PATH];
szTitle[0] = 0;
GetWindowText(WindowFromDC(hDC), szTitle, MAX_PATH);
Add(_T("Window"), _T("0x%X \"%s\""), WindowFromDC(hDC), szTitle);
Add(_T("Bitmap"), _T("0x%X"), GetCurrentObject(hDC, OBJ_BITMAP));
Add(_T("Graphics Mode"), _T("%d"), GetGraphicsMode(hDC));
Add(_T("Mapping Mode"), _T("%d"), GetMapMode(hDC));
GetViewportExtEx(hDC, & size);
Add(_T("Viewport Extent"), _T("{ %d, %d }"), size.cx, size.cy);
GetViewportOrgEx(hDC, & pnt);
Add(_T("Viewport Origin"), _T("{ %d, %d }"), pnt.x, pnt.y);
GetWindowExtEx(hDC, & size);
Add(_T("Window Extent"), _T("{ %d, %d }"), size.cx, size.cy);
GetWindowOrgEx(hDC, & pnt);
Add(_T("Window Origin"), _T("{ %d, %d }"), pnt.x, pnt.y);
XFORM xform;
GetWorldTransform(hDC, & xform);
Add(_T("World transformation"), _T("{ %f, %f, %f, %f, %f, %f }"),
xform.eM11, xform.eM12, xform.eM21, xform.eM22, xform.eDx, xform.eDy);
// transformation
Add(_T("Background Color"), _T("0x%X"), GetBkColor(hDC));
Add(_T("Text Color"), _T("0x%X"), GetTextColor(hDC));
Add(_T("Palette"), _T("0x%X"), GetCurrentObject(hDC, OBJ_PAL));
{
COLORADJUSTMENT ca;
GetColorAdjustment(hDC, & ca);
Add(_T("Color Adjustment"), _T("{ %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d, %d }"),
ca.caSize, ca.caFlags, ca.caIlluminantIndex,
ca.caRedGamma, ca.caGreenGamma, ca.caBlueGamma,
ca.caReferenceBlack, ca.caReferenceWhite,
ca.caContrast, ca.caBrightness, ca.caColorfulness, ca.caRedGreenTint);
}
Add(_T("Color Space"), _T("0x%X"), GetColorSpace(hDC));
Add(_T("ICM Mode"), _T("%d"), SetICMMode(hDC, ICM_QUERY));
{
TCHAR szProfile[MAX_PATH];
DWORD dwSize = MAX_PATH;
szProfile[0] = 0;
GetICMProfile(hDC, & dwSize, szProfile);
Add(_T("ICM Profile"), _T("%s"), szProfile);
}
GetCurrentPositionEx(hDC, & pnt);
Add(_T("Current Position"), _T("{ %d, %d }"), pnt.x, pnt.y);
Add(_T("ROP2"), _T("%d"), GetROP2(hDC));
Add(_T("Background Mode"), _T("%d"), GetBkMode(hDC));
Add(_T("Logical Pen"), _T("0x%X"), GetCurrentObject(hDC, OBJ_PEN));
Add(_T("DC Pen Color"), _T("0x%X"), GetDCPenColor(hDC));
Add(_T("Arc Direction"), _T("%d"), GetArcDirection(hDC));
FLOAT miter;
GetMiterLimit(hDC, & miter);
Add(_T("Miter Limit"), _T("%f"), miter);
Add(_T("Logical Brush"), _T("0x%X"), GetCurrentObject(hDC, OBJ_BRUSH));
Add(_T("DC Brush Color"), _T("0x%X"), GetDCBrushColor(hDC));
GetBrushOrgEx(hDC, & pnt);
Add(_T("Brush Origin"), _T("{ %d, %d }"), pnt.x, pnt.y);
Add(_T("Polygon Filling Mode"), _T("%d"), GetPolyFillMode(hDC));
Add(_T("Bitmap Stretching Mode"), _T("%d"), GetStretchBltMode(hDC));
Add(_T("Logical Font"), _T("0x%X"), GetCurrentObject(hDC, OBJ_FONT));
Add(_T("Inter-character spacing"), _T("%d"), GetTextCharacterExtra(hDC));
DWORD flag = SetMapperFlags(hDC, 0);
SetMapperFlags(hDC, flag);
Add(_T("Font Mapper Flags"), _T("0x%X"), flag);
Add(_T("Text Alignment"), _T("0x%X"), GetTextAlign(hDC));
Add(_T("Text Justification"), _T("write only"), 0);
Add(_T("Layout"), _T("%d"), GetLayout(hDC));
Add(_T("Path"), _T("%d bytes"), GetPath(hDC, NULL, NULL, 0));
RECT rect;
int typ = GetClipBox(hDC, & rect);
HRGN hRgn = CreateRectRgn(0, 0, 1, 1);
GetClipRgn(hDC, hRgn);
Add(_T("Clipping"), _T("type %d clip box { %d, %d, %d, %d } size %d bytes"),
typ, rect.left, rect.top, rect.right, rect.bottom,
GetRegionData(hRgn, 0, NULL)
);
GetMetaRgn(hDC, hRgn);
GetRgnBox(hRgn, & rect);
Add(_T("Meta Region"), _T("size %d bytes, rgn box { %d, %d, %d, %d }"),
GetRegionData(hRgn, 0, NULL), rect.left, rect.top, rect.right, rect.bottom);
for (int i=1; i<=5; i++)
{
int rslt = GetRandomRgn(hDC, hRgn, i);
if ( rslt==1 )
{
GetRgnBox(hRgn, & rect);
Add(_T("Random Region"), _T("size %d bytes, rgn box { %d, %d, %d, %d }"),
GetRegionData(hRgn, 0, NULL), rect.left, rect.top, rect.right, rect.bottom);
}
else if ( rslt==0 )
Add(_T("Random Region"), _T("NULL"), 0);
else
Add(_T("Random Region"), _T("FAIL"), 0);
}
DeleteObject(hRgn);
GetBoundsRect(hDC, & rect, 0);
Add(_T("Bounds Rectangle"), _T("{ %d, %d, %d, %d }"),
rect.left, rect.top, rect.right, rect.bottom);
}
bool _HYSequencePane::_ProcessOSEvent (Ptr vEvent)
{
static bool amScrolling = false,
vertical;
static POINT localPt;
static long originalStart,
originalSpan,
lastClick,
firstClick;
if (_HYPlatformComponent::_ProcessOSEvent (vEvent)) {
return true;
}
if (!active) {
return false;
}
short lastH, lastV;
POINT globalPt;
_HYWindowsUIMessage* theEvent = (_HYWindowsUIMessage*)vEvent;
switch (theEvent->iMsg) {
case WM_RBUTTONDOWN:
case WM_LBUTTONDOWN:
case WM_LBUTTONDBLCLK:
{
lastH = (short)LOWORD (theEvent->lParam),
lastV = (short)HIWORD (theEvent->lParam);
globalPt = (POINT) {
lastH, lastV
};
localPt = (POINT) {
lastH - rel.left , lastV - rel.top
};
vertical = (localPt.x<headerWidth)&&(localPt.y>=(GetSlotHeight()+1));
if ((theEvent->iMsg == WM_LBUTTONDOWN)||(theEvent->iMsg == WM_LBUTTONDBLCLK)) {
forceUpdateForScrolling = true;
if (vertical)
ProcessVSelectionChange (localPt.x,localPt.y,GetAsyncKeyState (VK_SHIFT) & 0x8000,
GetAsyncKeyState (VK_CONTROL) & 0x8000, false, theEvent->iMsg == WM_LBUTTONDBLCLK);
else
ProcessSelectionChange (localPt.x,localPt.y,GetAsyncKeyState (VK_SHIFT) & 0x8000,
GetAsyncKeyState (VK_CONTROL) & 0x8000);
forceUpdateForScrolling = false;
ClientToScreen (parentWindow, &globalPt);
if (DragDetect (parentWindow, globalPt)) {
if (messageRecipient) {
SetCapture (parentWindow);
((_HYTWindow*)messageRecipient)->trackMouseComponent = this;
}
amScrolling = true;
if (vertical) {
originalStart = startRow,
originalSpan = endRow-startRow;
lastClick = -2;
firstClick = (localPt.y-(GetSlotHeight()+1))/GetSlotHeight();
}
}
return true;
}
if ((theEvent->iMsg == WM_RBUTTONDOWN)&&(vertical&&vselection.lLength)||((!vertical)&&selection.lLength)) {
ClientToScreen (parentWindow, &globalPt);
ProcessContextualPopUp (globalPt.x, globalPt.y);
return true;
}
}
break;
case WM_LBUTTONUP:
if (amScrolling) {
amScrolling = false;
if (messageRecipient) {
ReleaseCapture ();
((_HYTWindow*)messageRecipient)->trackMouseComponent = nil;
}
if (vertical) {
RECT invalRect = {rel.left,rel.top+(GetSlotHeight()+1)+1,rel.left+headerWidth,rel.bottom-HY_SCROLLER_WIDTH};
InvalidateRect (parentWindow,&invalRect,false);
if ((localPt.x<headerWidth)&&(localPt.x>0)&&(lastClick>-2)) {
MoveSpecies (firstClick+originalStart,lastClick+startRow);
}
}
}
return true;
break;
case WM_MOUSEMOVE:
if ((theEvent->wParam & MK_LBUTTON)&&(amScrolling)) {
POINT mousePt = {((short)LOWORD (theEvent->lParam))-rel.left,
((short)HIWORD (theEvent->lParam))-rel.top
};
if (vertical) {
long wHeight = rel.bottom-rel.top-HY_SCROLLER_WIDTH,
slotHeight = GetSlotHeight();
forceUpdateForScrolling = true;
if ((mousePt.y<(GetSlotHeight()+1))||(localPt.y!=mousePt.y)||(mousePt.y>wHeight)) {
localPt = mousePt;
if (mousePt.y>wHeight) {
// scroll down
if ((endRow<=speciesIndex.lLength)&&(vselection.lData[0]!=speciesIndex.lLength-1)) {
if (endRow-startRow<originalSpan) {
break;
}
startRow++;
endRow++;
_SetVScrollerPos(((double)MAX_CONTROL_VALUE*startRow)/
(speciesIndex.lLength-endRow+startRow+1));
BuildPane();
_MarkForUpdate();
lastClick = -2;
}
break;
} else {
mousePt.y-=(GetSlotHeight()+1);
if (mousePt.y<=slotHeight) {
if (mousePt.y>=0) {
if (mousePt.y<slotHeight/2) {
mousePt.y = -1;
} else {
mousePt.y = 0;
}
} else {
// scroll up
if (startRow>0) {
startRow--;
endRow--;
_SetVScrollerPos(((double)MAX_CONTROL_VALUE*startRow)/(speciesIndex.lLength-endRow+startRow+1));
BuildPane();
_MarkForUpdate();
lastClick = -2;
}
break;
}
} else {
mousePt.y=(mousePt.y-(GetSlotHeight()+1))/slotHeight;
}
}
if ((mousePt.y<-1)||(mousePt.y>=(endRow-startRow))) {
break;
}
if (mousePt.y!=lastClick) {
HDC winDC = GetDC (parentWindow);
int saveROP2 = GetROP2 (winDC);
SetROP2 (winDC,R2_NOT);
if (lastClick>=-1) {
lastClick = (GetSlotHeight()+1)+slotHeight*(lastClick+1)+rel.top+1;
MoveToEx(winDC,rel.left+1,lastClick,nil);
LineTo (winDC,rel.left+headerWidth-1,lastClick);
}
lastClick = mousePt.y;
if (lastClick+startRow!=firstClick+originalStart) {
mousePt.y = (GetSlotHeight()+1)+slotHeight*(lastClick+1)+rel.top+1;
MoveToEx (winDC,rel.left+1,mousePt.y,nil);
LineTo (winDC,rel.left+headerWidth-1,mousePt.y);
}
SetROP2 (winDC,saveROP2);
ReleaseDC (parentWindow,winDC);
}
}
forceUpdateForScrolling = false;
return true;
} else {
if (((mousePt.x<headerWidth)&&(startColumn>0))||(localPt.x!=mousePt.x)||(mousePt.x>_HYCanvas::GetMaxW()-5)) {
forceUpdateForScrolling = true;
ProcessSelectionChange (mousePt.x,mousePt.y,true,true,true);
forceUpdateForScrolling = false;
localPt = mousePt;
}
return true;
}
}
break;
}
return false;
}
/***********************************************************************
* dibdrv_SelectPen
*/
HPEN CDECL dibdrv_SelectPen( PHYSDEV dev, HPEN hpen )
{
PHYSDEV next = GET_NEXT_PHYSDEV( dev, pSelectPen );
dibdrv_physdev *pdev = get_dibdrv_pdev(dev);
LOGPEN logpen;
DWORD style;
TRACE("(%p, %p)\n", dev, hpen);
if (!GetObjectW( hpen, sizeof(logpen), &logpen ))
{
/* must be an extended pen */
EXTLOGPEN *elp;
INT size = GetObjectW( hpen, 0, NULL );
if (!size) return 0;
elp = HeapAlloc( GetProcessHeap(), 0, size );
GetObjectW( hpen, size, elp );
/* FIXME: add support for user style pens */
logpen.lopnStyle = elp->elpPenStyle;
logpen.lopnWidth.x = elp->elpWidth;
logpen.lopnWidth.y = 0;
logpen.lopnColor = elp->elpColor;
HeapFree( GetProcessHeap(), 0, elp );
}
if (hpen == GetStockObject( DC_PEN ))
logpen.lopnColor = GetDCPenColor( dev->hdc );
pdev->pen_colorref = logpen.lopnColor;
pdev->pen_color = get_fg_color( pdev, pdev->pen_colorref );
calc_and_xor_masks(GetROP2(dev->hdc), pdev->pen_color, &pdev->pen_and, &pdev->pen_xor);
pdev->pen_pattern = dash_patterns[PS_SOLID];
pdev->defer |= DEFER_PEN;
style = logpen.lopnStyle & PS_STYLE_MASK;
switch(style)
{
case PS_SOLID:
if(logpen.lopnStyle & PS_GEOMETRIC) break;
if(logpen.lopnWidth.x > 1) break;
pdev->pen_line = solid_pen_line;
pdev->defer &= ~DEFER_PEN;
break;
case PS_DASH:
case PS_DOT:
case PS_DASHDOT:
case PS_DASHDOTDOT:
if(logpen.lopnStyle & PS_GEOMETRIC) break;
if(logpen.lopnWidth.x > 1) break;
pdev->pen_line = dashed_pen_line;
pdev->pen_pattern = dash_patterns[style];
pdev->defer &= ~DEFER_PEN;
break;
case PS_NULL:
pdev->pen_line = null_pen_line;
pdev->defer &= ~DEFER_PEN;
break;
default:
break;
}
return next->funcs->pSelectPen( next, hpen );
}
void DrawPolyPolyPolygon(Draw& draw, const Point *vertices, int vertex_count,
const int *subpolygon_counts, int subpolygon_count_count,
const int *disjunct_polygon_counts, int disjunct_polygon_count_count,
Color color, int width, Color outline, uint64 pattern, Color doxor)
{
if(vertex_count == 0)
return;
#ifdef PLATFORM_WIN32_ //!!TODO
if(PdfDraw *pdf = dynamic_cast<PdfDraw *>(&draw)) {
pdf->DrawPolyPolyPolygon(vertices, vertex_count, subpolygon_counts, subpolygon_count_count,
disjunct_polygon_counts, disjunct_polygon_count_count, color, width, outline, pattern, doxor);
return;
}
#endif
// LOG("DrawPolyPolyPolygon: drawing = " << (draw.IsDrawing() ? "yes" : "no")
// << ", backdraw = " << (draw.IsBack() ? "yes" : "no")
// << ", " << (draw.Dots() ? "dots" : "pixels")
// << ", printer = " << (draw.IsPrinter() ? "yes" : "no"));
// LOG("#vertices = " << vertex_count << ", #subpolygons = " << subpolygon_count_count
// << ", #disjunct polygons = " << disjunct_polygon_count_count);
// LOG("color = " << Dump(color) << ", width = " << width << ", outline = " << Dump(outline)
// << ", pattern = " << Dump(pattern) << ", doxor = " << doxor);
#ifdef _DEBUG
// for(int v = 0; v < vertex_count; v++)
// if(abs2(vertices[v] - vertices[(v ? v : vertex_count) - 1]) >= 500 * 500)
// NEVER();
#endif
if(!dynamic_cast<SystemDraw *>(&draw)) {
draw.DrawPolyPolyPolygon(vertices, vertex_count,
subpolygon_counts, subpolygon_count_count,
disjunct_polygon_counts, disjunct_polygon_count_count,
color, width, outline, pattern, doxor);
return;
}
// TIMING("DrawPolyPolygon/hdc");
bool is_xor = !IsNull(doxor);
#ifdef PLATFORM_X11
unsigned xor_pixel = (is_xor ? GetXPixel(doxor) : 0);
XGCValues gcv;
gcv.function = is_xor ? X11_ROP2_XOR : X11_ROP2_COPY;
GC fill_gc = NULL;
Image pattern_image;
if(!IsNull(color)) {
gcv.foreground = GetXPixel(color) ^ xor_pixel;
int fmask = GCForeground | GCFunction;
if(pattern) {
pattern_image = GetPatternImage(pattern);
gcv.stipple = pattern_image.GetMaskPixmap();
gcv.fill_style = FillStippled;
fmask |= GCStipple | GCFillStyle;
}
fill_gc = XCreateGC(Xdisplay, draw.GetDrawable(), fmask, &gcv);
}
GC line_gc = NULL;
if(!IsNull(outline)) {
gcv.foreground = GetXPixel(outline) ^ xor_pixel;
gcv.line_width = width;
line_gc = XCreateGC(Xdisplay, draw.GetDrawable(), GCForeground | GCFunction | GCLineWidth, &gcv);
Point offset = draw.GetOffset();
}
#endif
for(int i = 0; i < disjunct_polygon_count_count; i++, disjunct_polygon_counts++) {
int poly = *disjunct_polygon_counts;
int sub = 1;
if(*subpolygon_counts < poly)
if(disjunct_polygon_count_count > 1) {
const int *se = subpolygon_counts;
int total = 0;
while(total < poly)
total += *se++;
sub = se - subpolygon_counts;
}
else
sub = subpolygon_count_count;
if(sub > poly) {
vertices += poly;
subpolygon_counts += sub;
continue;
}
#if defined(PLATFORM_WIN32)
#ifdef SYSTEMDRAW
SystemDraw *w = dynamic_cast<SystemDraw *>(&draw);
if(w) { SystemDraw& draw = *w;
#endif
if(pattern) {
int old_rop = GetROP2(draw);
HGDIOBJ old_brush = GetCurrentObject(draw, OBJ_BRUSH);
word wpat[8] = {
(byte)(pattern >> 56), (byte)(pattern >> 48), (byte)(pattern >> 40), (byte)(pattern >> 32),
(byte)(pattern >> 24), (byte)(pattern >> 16), (byte)(pattern >> 8), (byte)(pattern >> 0),
};
HBITMAP bitmap = CreateBitmap(8, 8, 1, 1, wpat);
HBRUSH brush = ::CreatePatternBrush(bitmap);
COLORREF old_bk = GetBkColor(draw);
COLORREF old_fg = GetTextColor(draw);
if(!is_xor) {
SetROP2(draw, R2_MASKPEN);
SelectObject(draw, brush);
SetTextColor(draw, Black());
SetBkColor(draw, White());
DrawPolyPolygonRaw(draw, vertices, poly,
subpolygon_counts, sub, true, PEN_NULL, Null);
SetROP2(draw, R2_MERGEPEN);
SetTextColor(draw, color);
SetBkColor(draw, Black());
}
else { // xor fill with pattern data
SetROP2(draw, R2_XORPEN);
SelectObject(draw, brush);
}
DrawPolyPolygonRaw(draw, vertices, poly,
subpolygon_counts, sub, true, PEN_NULL, Null);
SelectObject(draw, old_brush);
SetTextColor(draw, old_fg);
SetBkColor(draw, old_bk);
SetROP2(draw, old_rop);
DeleteObject(brush);
DeleteObject(bitmap);
if(!IsNull(outline))
{
draw.SetColor(Null);
draw.SetDrawPen(width, outline);
ASSERT(sizeof(POINT) == sizeof(Point));
PolyPolygon(draw, (const POINT *)vertices, subpolygon_counts, sub);
}
}
else
{ // simple fill
// RTIMING("AreaTool::Fill(solid color)");
int out_wd = (IsNull(width) || IsNull(outline) ? PEN_NULL : width);
Color out_co = Nvl(outline, Black);
draw.SetDrawPen(out_wd, out_co);
if(is_xor)
{
color = Color(color.GetR() ^ doxor.GetR(), color.GetG() ^ doxor.GetG(), color.GetB() ^ doxor.GetB());
SetROP2(draw, R2_XORPEN);
}
HGDIOBJ old_brush = 0;
if(IsNull(color))
{
static HGDIOBJ null_brush = GetStockObject(NULL_BRUSH);
old_brush = SelectObject(draw, null_brush);
}
else
draw.SetColor(color);
DrawPolyPolygonRaw(draw, vertices, poly, subpolygon_counts, sub,
!IsNull(color), out_wd, out_co);
if(old_brush)
SelectObject(draw, old_brush);
if(is_xor)
SetROP2(draw, R2_COPYPEN);
}
#ifdef SYSTEMDRAW
}
#endif
#elif defined(PLATFORM_X11)
if(fill_gc)
FillPolyPolygonRaw(fill_gc, draw.GetDrawable(), draw.GetClip(), draw.GetOffset(),
vertices, poly, subpolygon_counts, sub);
if(line_gc)
DrawPolyPolygonRaw(line_gc, draw.GetDrawable(), draw.GetOffset(),
vertices, poly, subpolygon_counts, sub);
#else
#error
#endif
vertices += poly;
subpolygon_counts += sub;
}
