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; } }