WD_HPATH
wdCreatePolygonPath(WD_HCANVAS hCanvas, const WD_POINT* pPoints, UINT uCount)
{
WD_HPATH p;
p = wdCreatePath(hCanvas);
if(p == NULL) {
WD_TRACE("wdCreatePolygonPath: wdCreatePath() failed.");
return NULL;
}
if(uCount > 0) {
WD_PATHSINK sink;
UINT i;
if(!wdOpenPathSink(&sink, p)) {
WD_TRACE("wdCreatePolygonPath: wdOpenPathSink() failed.");
wdDestroyPath(p);
return NULL;
}
wdBeginFigure(&sink, pPoints[0].x, pPoints[0].y);
for(i = 1; i < uCount; i++)
wdAddLine(&sink, pPoints[i].x, pPoints[i].y);
wdEndFigure(&sink, TRUE);
wdClosePathSink(&sink);
}
return p;
}
void
wdDestroyCanvas(WD_HCANVAS hCanvas)
{
if(d2d_enabled()) {
d2d_canvas_t* c = (d2d_canvas_t*) hCanvas;
/* Check for common logical errors. */
if(c->clip_layer != NULL || (c->flags & D2D_CANVASFLAG_RECTCLIP))
WD_TRACE("wdDestroyCanvas: Logical error: Canvas has dangling clip.");
if(c->gdi_interop != NULL)
WD_TRACE("wdDestroyCanvas: Logical error: Unpaired wdStartGdi()/wdEndGdi().");
dummy_ID2D1RenderTarget_Release(c->target);
free(c);
} else {
gdix_canvas_t* c = (gdix_canvas_t*) hCanvas;
gdix_vtable->fn_DeleteStringFormat(c->string_format);
gdix_vtable->fn_DeletePen(c->pen);
gdix_vtable->fn_DeleteGraphics(c->graphics);
if(c->real_dc != NULL) {
HBITMAP mem_bmp;
mem_bmp = SelectObject(c->dc, c->orig_bmp);
DeleteObject(mem_bmp);
DeleteObject(c->dc);
}
free(c);
}
}
WD_HPATH
wdCreatePath(WD_HCANVAS hCanvas)
{
if(d2d_enabled()) {
dummy_ID2D1PathGeometry* g;
HRESULT hr;
wd_lock();
hr = dummy_ID2D1Factory_CreatePathGeometry(d2d_factory, &g);
wd_unlock();
if(FAILED(hr)) {
WD_TRACE_HR("wdCreatePath: "
"ID2D1Factory::CreatePathGeometry() failed.");
return NULL;
}
return (WD_HPATH) g;
} else {
dummy_GpPath* p;
int status;
status = gdix_vtable->fn_CreatePath(dummy_FillModeAlternate, &p);
if(status != 0) {
WD_TRACE("wdCreatePath: GdipCreatePath() failed. [%d]", status);
return NULL;
}
return (WD_HPATH) p;
}
}
void wd17xx_dispatch(void)
{
if (fdc_query(FDC_RESET)) {
if (WD_RESET()) {
wd_rst();
}
if (wd.index != fdc_query(FDC_INDEX)) {
wd.index = !wd.index;
if (wd.index) {
wd.icnt += 1;
}
}
wd_proc();
} else {
STATE(reset);
}
// WD_TRACE(("wd: icnt=%u\n", wd.icnt));
if (!WD_BUSY()) {
if (wd.icnt >= 15 && fdc_query(FDC_HLD)) {
WD_TRACE(("wd: hld_off icnt=%u hld=%u ready=%u\n", wd.icnt, fdc_query(FDC_HLD), wd.ready != 0));
fdc_set(FDC_HLD, 0); // disengage motor
}
}
}
byte wd17xx_read(word addr)
{
byte data = 0xff;
if (!WD_RESET()) {
switch (addr & (WD17XX_A1 | WD17XX_A0)) {
case WDR_STAT:
WD_CLR_INT();
wd_update_stat();
data = wd.str;
wd_clr_stat();
if ((wd.cr_c & TYPEI_MASK) != TYPEI) {
WD_TRACE(("wd: read stat %s\n", wd_stat_decode(data, wd.cr_c)));
}
break;
case WDR_TRK:
data = wd.tr;
break;
case WDR_SEC:
data = wd.sr;
break;
case WDR_DATA:
WD_CLR_DRQ();
data = wd.dr;
WDH_TRACE(("wd: rd_data, clr_drq, dcnt=%u, data=0x%02x\n", wd.dcnt, wd.dr));
break;
}
}
return data;
}
static void wd_rst(void)
{
WD_TRACE(("wd: performing reset\n"));
wd.cr = 0;
#if RESTORE_ON_RESET
WD_TRACE(("wd: performing restore\n"));
wd_cmd_start();
#else
fdc_set(FDC_STEP, 0);
WD_CLR_DRQ();
WD_CLR_INT();
WD_TRACE(("wd: clr busy signal (#0)\n"));
WD_CLR_BUSY();
STATE(t0);
#endif
}
WD_HBRUSH
wdCreateSolidBrush(WD_HCANVAS hCanvas, WD_COLOR color)
{
if(d2d_enabled()) {
d2d_canvas_t* c = (d2d_canvas_t*) hCanvas;
ID2D1SolidColorBrush* b;
D2D_COLOR_F clr;
HRESULT hr;
d2d_init_color(&clr, color);
hr = ID2D1RenderTarget_CreateSolidColorBrush(
c->target, &clr, NULL, &b);
if(FAILED(hr)) {
WD_TRACE_HR("wdCreateSolidBrush: "
"ID2D1RenderTarget::CreateSolidColorBrush() failed.");
return NULL;
}
return (WD_HBRUSH) b;
} else {
dummy_GpSolidFill* b;
int status;
status = gdix_vtable->fn_CreateSolidFill(color, &b);
if(status != 0) {
WD_TRACE("wdCreateSolidBrush: "
"GdipCreateSolidFill() failed. [%d]", status);
return NULL;
}
return (WD_HBRUSH) b;
}
}
WD_HCACHEDIMAGE
wdCreateCachedImage(WD_HCANVAS hCanvas, WD_HIMAGE hImage)
{
if(d2d_enabled()) {
d2d_canvas_t* c = (d2d_canvas_t*) hCanvas;
ID2D1Bitmap* b;
HRESULT hr;
hr = ID2D1RenderTarget_CreateBitmapFromWicBitmap(c->target,
(IWICBitmapSource*) hImage, NULL, &b);
if(FAILED(hr)) {
WD_TRACE_HR("wdCreateCachedImage: "
"ID2D1RenderTarget::CreateBitmapFromWicBitmap() failed.");
return NULL;
}
return (WD_HCACHEDIMAGE) b;
} else {
gdix_canvas_t* c = (gdix_canvas_t*) hCanvas;
dummy_GpCachedBitmap* cb;
int status;
status = gdix_vtable->fn_CreateCachedBitmap((dummy_GpImage*) hImage,
c->graphics, &cb);
if(status != 0) {
WD_TRACE("wdCreateCachedImage: "
"GdipCreateCachedBitmap() failed. [%d]", status);
return NULL;
}
return (WD_HCACHEDIMAGE) cb;
}
}
HMODULE
wd_load_system_dll(const TCHAR* dll_name)
{
HMODULE dll_kernel32;
HMODULE dll;
/* Check whether flag LOAD_LIBRARY_SEARCH_SYSTEM32 is supported on this
* system. It has been added in Win Vista/7 with the security update
* KB2533623. The update also added new symbol AddDllDirectory() so we
* use that as a canary. */
dll_kernel32 = GetModuleHandle(_T("KERNEL32.DLL"));
if(dll_kernel32 != NULL &&
GetProcAddress(dll_kernel32, "AddDllDirectory") != NULL)
{
dll = LoadLibraryEx(dll_name, NULL, LOAD_LIBRARY_SEARCH_SYSTEM32);
if(dll == NULL) {
WD_TRACE("wd_load_system_library: "
"LoadLibraryEx(%s, LOAD_LIBRARY_SEARCH_SYSTEM32) [%lu]",
dll_name, GetLastError());
}
} else {
TCHAR path[MAX_PATH];
UINT dllname_len;
UINT sysdir_len;
dllname_len = _tcslen(dll_name);
sysdir_len = GetSystemDirectory(path, MAX_PATH);
if(sysdir_len + 1 + dllname_len >= MAX_PATH) {
WD_TRACE("wd_load_system_library: Buffer too small.");
SetLastError(ERROR_BUFFER_OVERFLOW);
return NULL;
}
path[sysdir_len] = _T('\\');
memcpy(path + sysdir_len + 1, dll_name, (dllname_len + 1) * sizeof(TCHAR));
dll = LoadLibraryEx(path, NULL, LOAD_WITH_ALTERED_SEARCH_PATH);
if(dll == NULL) {
WD_TRACE("wd_load_system_library: "
"LoadLibraryEx(%s, LOAD_WITH_ALTERED_SEARCH_PATH) [%lu]",
dll_name, GetLastError());
}
}
return dll;
}
WD_HPATH
wdCreateRoundedRectPath(WD_HCANVAS hCanvas, const WD_RECT* prc, float r)
{
WD_HPATH p;
WD_PATHSINK sink;
float w_2, h_2;
/* Adjust the radius according to the maximum size allowed */
w_2 = (prc->x1 - prc->x0) / 2.f + 0.5f;
h_2 = (prc->y1 - prc->y0) / 2.f + 0.5f;
if (r > w_2) r = w_2;
if (r > h_2) r = h_2;
/* Create the path */
p = wdCreatePath(hCanvas);
if(p == NULL) {
WD_TRACE("wdCreateRoundRectPath: wdCreatePath() failed.");
return NULL;
}
if(!wdOpenPathSink(&sink, p))
{
WD_TRACE("wdCreateRoundRectPath: wdOpenPathSink() failed.");
wdDestroyPath(p);
return NULL;
}
wdBeginFigure(&sink, prc->x0+r, prc->y0);
wdAddLine(&sink, prc->x1-r, prc->y0);
wdAddArc (&sink, prc->x1-r, prc->y0+r, 90.0f);
wdAddLine(&sink, prc->x1, prc->y1-r);
wdAddArc (&sink, prc->x1-r, prc->y1-r, 90.0f);
wdAddLine(&sink, prc->x0+r, prc->y1);
wdAddArc (&sink, prc->x0+r, prc->y1-r, 90.0f);
wdAddLine(&sink, prc->x0, prc->y0+r);
wdAddArc (&sink, prc->x0+r, prc->y0+r, 90.0f);
wdEndFigure(&sink, TRUE);
wdClosePathSink(&sink);
return p;
}
static void wd_cmd_start(void)
{
WD_CLR_DRQ();
WD_CLR_INT();
if ((wd.cr & TYPEIV_MASK) != TYPEIV) {
WD_TRACE(("wd: set busy signal\n"));
WD_SET_BUSY();
}
STATE(t0_cmd);
}
BOOL
wdResizeCanvas(WD_HCANVAS hCanvas, UINT uWidth, UINT uHeight)
{
if(d2d_enabled()) {
d2d_canvas_t* c = (d2d_canvas_t*) hCanvas;
if(c->type == D2D_CANVASTYPE_HWND) {
dummy_D2D1_SIZE_U size = { uWidth, uHeight };
HRESULT hr;
hr = dummy_ID2D1HwndRenderTarget_Resize(c->hwnd_target, &size);
if(FAILED(hr)) {
WD_TRACE_HR("wdResizeCanvas: "
"ID2D1HwndRenderTarget_Resize() failed.");
return FALSE;
}
/* In RTL mode, we have to update the transformation matrix
* accordingly. */
if(c->flags & D2D_CANVASFLAG_RTL) {
dummy_D2D1_MATRIX_3X2_F m;
dummy_ID2D1RenderTarget_GetTransform(c->target, &m);
m._31 = m._11 * (float)(uWidth - c->width);
m._32 = m._12 * (float)(uWidth - c->width);
dummy_ID2D1RenderTarget_SetTransform(c->target, &m);
c->width = uWidth;
}
return TRUE;
} else {
/* Operation not supported. */
WD_TRACE("wdResizeCanvas: Not supported (not ID2D1HwndRenderTarget).");
return FALSE;
}
} else {
/* Actually we should never be here as GDI+ back-end never allows
* caching of the canvas so there is no need to ever resize it. */
WD_TRACE("wdResizeCanvas: Not supported (GDI+ back-end).");
return FALSE;
}
}
static void wd_proc(void)
{
static byte am[6];
byte i_met;
word stat = 0;
static /*PROGMEM */void * entries[] = {
ADDR(t0),
ADDR(t0_cmd),
ADDR(t1), ADDR(t1_set), ADDR(t1_trkupd),
ADDR(t1_trk0), ADDR(t1_step), ADDR(t1_waits),
ADDR(t1_vrfy), ADDR(t1_waitd), ADDR(t1_hlt),
ADDR(t1_rdam),
ADDR(t2), ADDR(t2_waitd), ADDR(t2_hlt),
ADDR(t2_loop), ADDR(t2_amc), ADDR(t2_rd),
ADDR(t2_rdblk), ADDR(t2_mchk), ADDR(t2_wr),
ADDR(t3), ADDR(t3_wait), ADDR(t3_hlt), ADDR(t3_rdam),
ADDR(t4),
ADDR(reset),
ADDR(done)
};
goto *entries[wd.state];
/***************/ ENTRY(t0); /***************/
WAIT();
/***************/ ENTRY(t0_cmd); /***************/
WD_TRACE(("wd: t0_cmd: %s, cr=0x%02x\n", wd_command_decode(wd.cr), wd.cr));
if ((wd.cr & TYPEIV_MASK) == TYPEIV) {
BDI_ResetWrite();
BDI_ResetRead( 0 );
if ((wd.cr & INTR_MASK) != 0)
{
wd.ready = fdc_query(FDC_READY);
SET_TIMERU( 64 );
JUMP(t4);
}
if (!WD_BUSY())
{
wd.cr_c = 0;
}
WD_TRACE(("wd: clr busy signal (#1)\n"));
WD_CLR_BUSY();
JUMP(t0);
} else if ((wd.cr & TYPEI_MASK) == TYPEI) {
wd.cr_c = wd.cr;
wd.str &= ~(WD17XX_STAT_CRCERR|WD17XX_STAT_SEEKERR);
fdc_set(FDC_HLD, (wd.cr_c & TYPEI_BIT_H) != 0);
JUMP(t1);
} else {
wd.cr_c = wd.cr;
wd.str &= ~(WD17XX_STAT_RECTYPE|WD17XX_STAT_WRERR|WD17XX_STAT_CRCERR|WD17XX_STAT_LOST|WD17XX_STAT_WP|WD17XX_STAT_NOTFOUND);
if (!fdc_query(FDC_READY)) {
JUMP(done);
}
fdc_set(FDC_HLD, 1);
if ((wd.cr_c & TYPEII_MASK) == TYPEII) {
JUMP(t2);
} else {
if ((wd.cr_c & TYPEIII_AM_MASK) != TYPEIII_AM) {
wd.str |= WD17XX_STAT_WP;
JUMP(done);
}
JUMP(t3);
}
}
WAIT();
//=========================================================
// type 1
//=========================================================
/***************/ ENTRY(t1); /***************/
WD_TRACE(("wd: t1: dr=%x, hld=%u\n", wd.dr, fdc_query(FDC_HLD)));
if ((wd.cr_c & TYPEI_STEP_MASK) != 0) {
if ((wd.cr_c & TYPEI_STEPWD_MASK) == TYPEI_STEPWD) {
fdc_set(FDC_SDIR, (wd.cr_c & TYPEI_SDIR_MASK) == 0);
}
if ((wd.cr_c & TYPEI_BIT_U)) {
JUMP(t1_trkupd);
} else {
JUMP(t1_step);
}
} else {
if ((wd.cr_c & TYPEI_SEEK_MASK) != TYPEI_SEEK) {
// restore
wd.tr = 0xff;
wd.dr = 0;
}
}
/***************/ ENTRY(t1_set); /***************/
WD_TRACE(("wd: t1_set, time=%s\n", ticks_str(get_ticks())));
wd.dsr = wd.dr;
if (wd.dsr == wd.tr) {
JUMP(t1_vrfy);
}
fdc_set(FDC_SDIR, wd.dsr > wd.tr);
/***************/ ENTRY(t1_trkupd); /***************/
WD_TRACE(("wd: t1_trkupd, sdir=%u, tr=%u, time=%s\n", fdc_query(FDC_SDIR), wd.tr, ticks_str(get_ticks())));
if (fdc_query(FDC_SDIR)) {
wd.tr += 1;
} else {
wd.tr -= 1;
}
/***************/ ENTRY(t1_trk0); /***************/
WD_TRACE(("wd: t1_trk0, sdir=%u, time=%s\n", fdc_query(FDC_SDIR), ticks_str(get_ticks())));
if (!fdc_query(FDC_TRK0) && !fdc_query(FDC_SDIR)) {
WD_TRACE(("wd: t1_trk0: trk0\n"));
wd.tr = 0;
JUMP(t1_vrfy);
} else {
fdc_set(FDC_STEP, 1);
SET_TIMERU(WD_STEP_INTERVAL);
}
/***************/ ENTRY(t1_step); /***************/
WDH_TRACE(("wd: t1_step time=%s\n", ticks_str(get_ticks())));
WAIT_TIMER();
fdc_set(FDC_STEP, 0);
SET_TIMER(wd_step_rate(wd.cr_c & TYPEI_BIT_R));
/***************/ ENTRY(t1_waits); /***************/
WDH_TRACE(("wd: t1_waits time=%s\n", ticks_str(get_ticks())));
// delay according to r1,r0 field
WAIT_TIMER();
if ((wd.cr_c & 0xe0) == 0) {
JUMP(t1_set);
}
/***************/ ENTRY(t1_vrfy); /***************/
WD_TRACE(("wd: t1_vrfy time=%s\n", ticks_str(get_ticks())));
// is V = 1?
if ((wd.cr_c & TYPEI_BIT_V) == 0) {
JUMP(done);
}
// set hld
fdc_set(FDC_HLD, 1);
// setup delay
SET_TIMER(DATA_DELAY);
/***************/ ENTRY(t1_waitd); /***************/
WDH_TRACE(("wd: t1_waitd time=%s\n", ticks_str(get_ticks())));
// has 15 ms expired
WAIT_TIMER();
/***************/ ENTRY(t1_hlt); /***************/
WD_TRACE(("wd: t1_hlt time=%s\n", ticks_str(get_ticks())));
// is hlt = 1
if (!wd_is_hld()) {
WAIT();
}
wd.icnt = 0;
/***************/ ENTRY(t1_rdam); /***************/
WD_TRACE(("wd: t1_rdam, icnt=%u, time=%s\n", wd.icnt, ticks_str(get_ticks())));
if (wd.icnt >= 6) {
wd.str |= WD17XX_STAT_SEEKERR;
JUMP(done);
}
stat = floppy_stat();
if ((stat & FLP_STAT_AM) == 0) {
WAIT();
}
if (wd_rd_am(am)) {
if (wd.tr == am[0]) {
JUMP(done);
}
}
WAIT();
//=========================================================
// type 2
//=========================================================
/***************/ ENTRY(t2); /***************/
WD_TRACE(("wd: t2 tr=%u, sr=%u, side=%u, cr=%x, time=%s\n", wd.tr, wd.sr, wd.cr_c & TYPEII_BIT_S ? 1 : 0, wd.cr_c, ticks_str(get_ticks())));
floppy_set_sec_id(wd.sr);
if ((wd.cr_c & TYPEII_BIT_E) == 0) {
JUMP(t2_hlt);
}
SET_TIMER(DATA_DELAY);
/***************/ ENTRY(t2_waitd); /***************/
WDH_TRACE(("wd: t2_waitd time=%s\n", ticks_str(get_ticks())));
WAIT_TIMER();
/***************/ ENTRY(t2_hlt); /***************/
WD_TRACE(("wd: t2_hlt time=%s\n", ticks_str(get_ticks())));
if (!wd_is_hld()) {
WAIT();
}
// TG43
/***************/ ENTRY(t2_loop); /***************/
WD_TRACE(("wd: t2_loop time=%s\n", ticks_str(get_ticks())));
if ((wd.cr_c & TYPEII_WR_MASK) == TYPEII_WR) {
if (fdc_query(FDC_WP)) {
WD_TRACE(("wd: t2_loop disk is wp\n"));
wd.str |= WD17XX_STAT_WP;
JUMP(done);
}
}
wd.icnt = 0;
/***************/ ENTRY(t2_amc); /***************/
if (wd.icnt >= 6) {
wd.str |= WD17XX_STAT_NOTFOUND;
JUMP(done);
}
stat = floppy_stat();
if ((stat & FLP_STAT_AM) == 0) {
WAIT();
}
if (!wd_rd_am(am)) {
JUMP(done);
}
WD_TRACE(("wd: t2_amc, sz=%u (trk,side,sec) dsk(%u,%u,%u) wd(%u,%u,%u) time=%s\n", am[3], am[0], am[1], am[2], wd.tr, wd.cr_c & TYPEII_BIT_S ? 1 : 0, wd.sr, ticks_str(get_ticks())));
if (wd.tr != am[0]) {
if( floppy_fast_mode )
{
wd.str |= WD17XX_STAT_NOTFOUND;
JUMP(done);
}
else WAIT();
}
if (wd.sr != am[2]) {
WAIT();
}
// 1795 - other operation
if ( (wd.cr_c & TYPEII_BIT_C) != 0 )
{
byte side = ( wd.cr_c & TYPEII_BIT_S ) != 0 ? 0 : 1;
if ( side == am[1] )
{
WAIT();
}
}
wd.dcnt = wd_sect_size(am[3]);
BDI_ResetWrite();
SET_TIMER_DCNT( wd.dcnt );
if ((wd.cr_c & TYPEII_WR_MASK) == TYPEII_WR)
{
BDI_ResetRead( wd.dcnt - 1 );
WD_TRACE(("wd: t2_amc, SET_DRQ() time=%s\n", ticks_str(get_ticks())));
WD_SET_DRQ();
JUMP(t2_wr);
}
/***************/ ENTRY(t2_rd); /***************/
WD_TRACE(("wd: t2_rd time=%s\n", ticks_str(get_ticks())));
stat = floppy_stat();
if ((stat & FLP_STAT_AM) != 0) {
wd.str |= WD17XX_STAT_NOTFOUND;
JUMP(done);
}
// put record type in status reg bit 5
if ((stat & FLP_STAT_DEL) != 0) {
wd.str |= WD17XX_STAT_RECTYPE; // 1 = deleted record, 0 - normal record
} else {
wd.str &= ~WD17XX_STAT_RECTYPE; // 1 = deleted record, 0 - normal record
}
/***************/ ENTRY(t2_rdblk); /***************/
WDH_TRACE(("wd: t2_rdblk dcnt=%u, time=%s\n", wd.dcnt, ticks_str(get_ticks())));
while( wd.dcnt > 1 )
{
wd_floppy_read();
BDI_Write( wd.dsr );
wd.dcnt--;
}
// has first byte been assembled in dsr
if (!WD_DRQ())
{
t2_rd_common:
if (wd.dcnt == 0) {
stat = floppy_stat();
if( ( stat & FLP_STAT_ERR ) != 0 ) wd.str |= WD17XX_STAT_CRCERR;
if( ( wd.str & WD17XX_STAT_CRCERR ) != 0 ) JUMP(done);
JUMP(t2_mchk);
}
wd_floppy_read();
wd.dr = wd.dsr;
wd.dcnt -= 1;
WD_SET_DRQ();
} else {
if (TIMER_EXP()) {
WD_TRACE(("wd: t2_rdblk - set LOST, time=%s (byte time=%s, drq time=%s)\n", ticks_str(get_ticks()), ticks_str1(wd.delta_time), ticks_str2(wd.start_time)));
//__TRACE( "wd: t2_rdblk - set LOST\n" );
wd.str |= WD17XX_STAT_LOST;
wd.str |= WD17XX_STAT_CRCERR;
BDI_ResetWrite();
goto t2_rd_common;
}
}
WAIT();
/***************/ ENTRY(t2_mchk); /***************/
WD_TRACE(("wd: t2_mchk wdstat=%x, flp_stat=%x, time=%s\n", wd.str, stat, ticks_str(get_ticks())));
if ((wd.cr_c & TYPEII_BIT_M) != 0) {
wd.sr += 1;
JUMP(t2_loop);
}
WD_TRACE(("wd: end of read\n"));
JUMP(done);
/***************/ ENTRY(t2_wr); /***************/
WDH_TRACE(("wd: t2_wr dcnt=%u, time=%s\n", wd.dcnt, ticks_str(get_ticks())));
while( BDI_Read( &wd.dsr ) )
{
wd_floppy_write();
wd.dcnt--;
}
if (!WD_DRQ())
{
wd.dsr = wd.dr;
t2_wr_common:
wd_floppy_write();
wd.dcnt -= 1;
if (wd.dcnt == 0) {
stat = floppy_stat();
if( ( stat & FLP_STAT_ERR ) != 0 ) wd.str |= WD17XX_STAT_CRCERR;
if( ( wd.str & WD17XX_STAT_CRCERR ) != 0 ) JUMP(done);
JUMP(t2_mchk);
}
WD_SET_DRQ();
} else {
if (TIMER_EXP()) {
WD_TRACE(("wd: t2_wr - set LOST, time=%s (byte time=%s, drq time=%s)\n", ticks_str(get_ticks()), ticks_str1(wd.delta_time), ticks_str2(wd.start_time)));
//__TRACE( "wd: t2_wr - set LOST\n" );
BDI_ResetRead(0);
wd.str |= WD17XX_STAT_LOST;
wd.str |= WD17XX_STAT_CRCERR;
wd.dsr = 0;
goto t2_wr_common;
}
}
WAIT();
//=========================================================
// type 3
//=========================================================
/***************/ ENTRY(t3); /***************/
WD_TRACE(("wd: t3 time=%s\n", ticks_str(get_ticks())));
if ((wd.cr_c & TYPEIII_BIT_E) == 0) {
JUMP(t3_hlt);
}
SET_TIMER(DATA_DELAY);
/***************/ ENTRY(t3_wait); /***************/
WDH_TRACE(("wd: t3_wait time=%s\n", ticks_str(get_ticks())));
WAIT_TIMER();
/***************/ ENTRY(t3_hlt); /***************/
WD_TRACE(("wd: t3_hlt time=%s\n", ticks_str(get_ticks())));
if (!wd_is_hld()) {
WAIT();
}
wd.icnt = 0;
wd.dcnt = 6;
wd_crc_init();
BDI_ResetWrite();
/***************/ ENTRY(t3_rdam); /***************/
WDH_TRACE(("wd: t3_rdam time=%s\n", ticks_str(get_ticks())));
if (wd.icnt >= 6) {
wd.str |= WD17XX_STAT_NOTFOUND;
JUMP(done);
}
if (wd.dcnt == 6) {
stat = floppy_stat();
if ((stat & FLP_STAT_AM) == 0) {
WAIT();
}
}
while( wd.dcnt > 1 )
{
wd_floppy_read();
BDI_Write( wd.dsr );
wd.dcnt--;
}
if (!WD_DRQ()) {
if (wd.dcnt == 0) {
WD_TRACE(("wd: rd_am, crc=0x%04x\n", wd.crc));
WD_TRACE(("wd: rd_am (%u,%u,%u,%u), crc=0x%02x%02x\n", am[5], am[4], am[3], am[2], am[1], am[0]));
if (wd.crc != 0) {
wd.str |= WD17XX_STAT_CRCERR;
}
JUMP(done);
}
wd_floppy_read();
wd.dr = wd.dsr;
wd.dcnt -= 1;
#if defined(DEBUG) && DEBUG
am[wd.dcnt] = wd.dsr;
#endif
if (wd.dcnt == 5) {
wd.sr = wd.dsr;
}
WD_SET_DRQ();
}
WAIT();
//=========================================================
// type 4
//=========================================================
/***************/ ENTRY(t4); /***************/
WAIT_TIMER();
i_met = INTR_MASK_I3;
if (wd.ready != fdc_query(FDC_READY)) {
i_met |= wd.ready ? INTR_MASK_I1 : INTR_MASK_I0;
wd.ready = !wd.ready;
}
if (wd.index) {
i_met |= INTR_MASK_I2;
}
if ((i_met & wd.cr & INTR_MASK) == 0) {
WAIT();
}
JUMP(done);
/***************/ ENTRY(reset); /***************/
WAIT();
/***************/ ENTRY(done); /***************/
fdc_set(FDC_STEP, 0);
WD_TRACE(("wd: clr busy signal (#2)\n\n"));
WD_CLR_BUSY();
//WD_CLR_DRQ();
WD_SET_INT();
STATE(t0);
}
WD_HCANVAS
wdCreateCanvasWithHDC(HDC hDC, const RECT* pRect, DWORD dwFlags)
{
if(d2d_enabled()) {
dummy_D2D1_RENDER_TARGET_PROPERTIES props = {
dummy_D2D1_RENDER_TARGET_TYPE_DEFAULT,
{ dummy_DXGI_FORMAT_B8G8R8A8_UNORM, dummy_D2D1_ALPHA_MODE_PREMULTIPLIED },
0.0f, 0.0f,
((dwFlags & WD_CANVAS_NOGDICOMPAT) ?
0 : dummy_D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE),
dummy_D2D1_FEATURE_LEVEL_DEFAULT
};
d2d_canvas_t* c;
dummy_ID2D1DCRenderTarget* target;
HRESULT hr;
wd_lock();
hr = dummy_ID2D1Factory_CreateDCRenderTarget(d2d_factory, &props, &target);
wd_unlock();
if(FAILED(hr)) {
WD_TRACE_HR("wdCreateCanvasWithHDC: "
"ID2D1Factory::CreateDCRenderTarget() failed.");
goto err_CreateDCRenderTarget;
}
hr = dummy_ID2D1DCRenderTarget_BindDC(target, hDC, pRect);
if(FAILED(hr)) {
WD_TRACE_HR("wdCreateCanvasWithHDC: "
"ID2D1Factory::BindDC() failed.");
goto err_BindDC;
}
c = d2d_canvas_alloc((dummy_ID2D1RenderTarget*)target, D2D_CANVASTYPE_DC,
pRect->right - pRect->left, (dwFlags & WD_CANVAS_LAYOUTRTL));
if(c == NULL) {
WD_TRACE("wdCreateCanvasWithHDC: d2d_canvas_alloc() failed.");
goto err_d2d_canvas_alloc;
}
/* make sure text anti-aliasing is clear type */
dummy_ID2D1RenderTarget_SetTextAntialiasMode(c->target, dummy_D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE);
return (WD_HCANVAS) c;
err_d2d_canvas_alloc:
err_BindDC:
dummy_ID2D1RenderTarget_Release((dummy_ID2D1RenderTarget*)target);
err_CreateDCRenderTarget:
return NULL;
} else {
BOOL use_doublebuffer = (dwFlags & WD_CANVAS_DOUBLEBUFFER);
gdix_canvas_t* c;
c = gdix_canvas_alloc(hDC, (use_doublebuffer ? pRect : NULL),
pRect->right - pRect->left, (dwFlags & WD_CANVAS_LAYOUTRTL));
if(c == NULL) {
WD_TRACE("wdCreateCanvasWithHDC: gdix_canvas_alloc() failed.");
return NULL;
}
return (WD_HCANVAS) c;
}
}
WD_HCANVAS
wdCreateCanvasWithPaintStruct(HWND hWnd, PAINTSTRUCT* pPS, DWORD dwFlags)
{
RECT rect;
GetClientRect(hWnd, &rect);
if(d2d_enabled()) {
dummy_D2D1_RENDER_TARGET_PROPERTIES props = {
dummy_D2D1_RENDER_TARGET_TYPE_DEFAULT,
{ dummy_DXGI_FORMAT_B8G8R8A8_UNORM, dummy_D2D1_ALPHA_MODE_PREMULTIPLIED },
0.0f, 0.0f,
((dwFlags & WD_CANVAS_NOGDICOMPAT) ?
0 : dummy_D2D1_RENDER_TARGET_USAGE_GDI_COMPATIBLE),
dummy_D2D1_FEATURE_LEVEL_DEFAULT
};
dummy_D2D1_HWND_RENDER_TARGET_PROPERTIES props2;
d2d_canvas_t* c;
dummy_ID2D1HwndRenderTarget* target;
HRESULT hr;
props2.hwnd = hWnd;
props2.pixelSize.width = rect.right - rect.left;
props2.pixelSize.height = rect.bottom - rect.top;
props2.presentOptions = dummy_D2D1_PRESENT_OPTIONS_NONE;
wd_lock();
/* Note ID2D1HwndRenderTarget is implicitly double-buffered. */
hr = dummy_ID2D1Factory_CreateHwndRenderTarget(d2d_factory, &props, &props2, &target);
wd_unlock();
if(FAILED(hr)) {
WD_TRACE_HR("wdCreateCanvasWithPaintStruct: "
"ID2D1Factory::CreateHwndRenderTarget() failed.");
return NULL;
}
c = d2d_canvas_alloc((dummy_ID2D1RenderTarget*)target, D2D_CANVASTYPE_HWND,
rect.right, (dwFlags & WD_CANVAS_LAYOUTRTL));
if(c == NULL) {
WD_TRACE("wdCreateCanvasWithPaintStruct: d2d_canvas_alloc() failed.");
dummy_ID2D1RenderTarget_Release((dummy_ID2D1RenderTarget*)target);
return NULL;
}
/* make sure text anti-aliasing is clear type */
dummy_ID2D1RenderTarget_SetTextAntialiasMode(c->target, dummy_D2D1_TEXT_ANTIALIAS_MODE_CLEARTYPE);
return (WD_HCANVAS) c;
} else {
BOOL use_doublebuffer = (dwFlags & WD_CANVAS_DOUBLEBUFFER);
gdix_canvas_t* c;
c = gdix_canvas_alloc(pPS->hdc, (use_doublebuffer ? &pPS->rcPaint : NULL),
rect.right, (dwFlags & WD_CANVAS_LAYOUTRTL));
if(c == NULL) {
WD_TRACE("wdCreateCanvasWithPaintStruct: gdix_canvas_alloc() failed.");
return NULL;
}
return (WD_HCANVAS) c;
}
}
