/* set_mouse_sprite: * Sets the sprite to be used for the mouse pointer. If the sprite is * NULL, restores the default arrow. */ void set_mouse_sprite(struct BITMAP *sprite) { BITMAP *old_mouse_screen = _mouse_screen; int am_using_sys_cursor = use_system_cursor; if (!mouse_driver) return; if (_mouse_screen && !am_using_sys_cursor) show_mouse(NULL); if (sprite) mouse_sprite = sprite; else { if (_mouse_pointer) destroy_bitmap(_mouse_pointer); _mouse_pointer = create_mouse_pointer(mouse_arrow_data); mouse_sprite = _mouse_pointer; } cursors[MOUSE_CURSOR_ALLEGRO] = mouse_sprite; lock_bitmap((struct BITMAP*)mouse_sprite); /* make sure the ms bitmap is big enough */ if ((!ms) || (ms->w < mouse_sprite->w) || (ms->h < mouse_sprite->h) || (bitmap_color_depth(mouse_sprite) != bitmap_color_depth(ms))) { if (ms) { destroy_bitmap(ms); destroy_bitmap(mtemp); } ms = create_bitmap(mouse_sprite->w, mouse_sprite->h); lock_bitmap(ms); mtemp = create_bitmap(mouse_sprite->w*2, mouse_sprite->h*2); lock_bitmap(mtemp); } mouse_x_focus = 1; mouse_y_focus = 1; if (!am_using_sys_cursor) hw_cursor_dirty = TRUE; if (old_mouse_screen && !am_using_sys_cursor) show_mouse(old_mouse_screen); }
bitmapinit() { fbbm_rop_reset(consfb); if (!consfb->Mono) { lock_bitmap(); fbbm_init_palette(consfb); unlock_bitmap(); } }
void blit_panel(panel_t *panel) { // printf("%s w:%d h:%d stride: %d\n",__FUNCTION__, // cpt->ctrl.w, cpt->ctrl.h, cpt->ctx.stride); lock_bitmap(&panel->bitmap); Blit(panel->ctx.pixmap->data, panel->draw.l, panel->draw.t, 0, 0, panel->ctrl.w, panel->ctrl.h, panel->ctrl.w, panel->ctrl.h, panel->ctx.pixmap->pitch); };
/* * shrink_fork() * * Try to remove enough allocation blocks from 'fork' * so that it is 'ablocks' allocation blocks long. */ static void shrink_fork(struct hfs_fork *fork, int ablocks) { struct hfs_mdb *mdb = fork->entry->mdb; struct hfs_extent *ext; int i, error, next, count; hfs_u32 ablksz = mdb->alloc_blksz; next = (fork->psize / ablksz) - 1; ext = find_ext(fork, next); while (ext && ext->start && (ext->start >= ablocks)) { next = ext->start - 1; delete_extent(fork, ext); ext = find_ext(fork, next); } if (!ext) { fork->psize = (next + 1) * ablksz; return; } if ((count = next + 1 - ablocks) > 0) { for (i=2; (i>=0) && !ext->length[i]; --i) {}; lock_bitmap(mdb); while (count && (ext->length[i] <= count)) { ext->end -= ext->length[i]; count -= ext->length[i]; error = hfs_clear_vbm_bits(mdb, ext->block[i], ext->length[i]); if (error) { hfs_warn("hfs_truncate: error %d freeing " "blocks.\n", error); } ext->block[i] = ext->length[i] = 0; --i; } if (count) { ext->end -= count; ext->length[i] -= count; error = hfs_clear_vbm_bits(mdb, ext->block[i] + ext->length[i], count); if (error) { hfs_warn("hfs_truncate: error %d freeing " "blocks.\n", error); } } unlock_bitmap(mdb); update_ext(fork, ext); } fork->psize = ablocks * ablksz; }
void draw_panel(panel_t *panel) { int *pixmap, *src; int i, j, w; lock_bitmap(&panel->bitmap); blit_raw(&panel->ctx, res_panel_left, 0, 0, PANEL_CORNER_W, PANEL_HEIGHT, PANEL_CORNER_W*4); w = panel->ctrl.w - (2*PANEL_CORNER_W); if( w > 0) { pixmap = (int*)panel->ctx.pixmap->data; pixmap+= PANEL_CORNER_W; src = res_panel_body; for(i = 0; i < PANEL_HEIGHT; i++) { for(j = 0; j < w; j++) pixmap[j] = src[i]; pixmap+= panel->ctx.pixmap->pitch/4; } }; blit_raw(&panel->ctx, res_panel_right, panel->ctrl.w - PANEL_CORNER_W, 0, PANEL_CORNER_W, PANEL_HEIGHT, PANEL_CORNER_W*4); ctrl_t *child; child = (ctrl_t*)panel->ctrl.child.next; while( &child->link != &panel->ctrl.child) { send_message(child, MSG_PAINT, 0, 0); child = (ctrl_t*)child->link.next; }; };
/* * delete_extent() * * Description: * Deletes an extent record from a fork, reducing its physical length. * Input Variable(s): * struct hfs_fork *fork: the fork * struct hfs_extent *ext: the current last extent for 'fork' * Output Variable(s): * NONE * Returns: * void * Preconditions: * 'fork' points to a valid (struct hfs_fork) * 'ext' point to a valid (struct hfs_extent) which is the last in 'fork' * and which is not also the first extent in 'fork'. * Postconditions: * The extent record has been removed if possible, and a warning has been * printed otherwise. */ static void delete_extent(struct hfs_fork *fork, struct hfs_extent *ext) { struct hfs_mdb *mdb = fork->entry->mdb; struct hfs_ext_key key; int error; if (fork->cache == ext) { set_cache(fork, ext->prev); } ext->prev->next = NULL; if (ext->count != 1) { hfs_warn("hfs_truncate: extent has count %d.\n", ext->count); } lock_bitmap(mdb); error = hfs_clear_vbm_bits(mdb, ext->block[2], ext->length[2]); if (error) { hfs_warn("hfs_truncate: error %d freeing blocks.\n", error); } error = hfs_clear_vbm_bits(mdb, ext->block[1], ext->length[1]); if (error) { hfs_warn("hfs_truncate: error %d freeing blocks.\n", error); } error = hfs_clear_vbm_bits(mdb, ext->block[0], ext->length[0]); if (error) { hfs_warn("hfs_truncate: error %d freeing blocks.\n", error); } unlock_bitmap(mdb); build_key(&key, fork, ext->start); error = hfs_bdelete(mdb->ext_tree, HFS_BKEY(&key)); if (error) { hfs_warn("hfs_truncate: error %d deleting an extent.\n", error); } HFS_DELETE(ext); }
int main(int argc,char **argv) { WNDCLASS wnd; HRESULT hr; RECT rect; MSG msg; char *a; int i; for (i=1;i < argc;) { a = argv[i++]; if (*a == '-') { do { a++; } while (*a == '-'); if (!strcmp(a,"nodpiaware")) { gdi_no_dpiaware = true; } else if (!strcmp(a,"dpiaware")) { gdi_no_dpiaware = false; } else { fprintf(stderr,"Unhandled switch %s\n",a); return 1; } } else { fprintf(stderr,"Unhandled arg %s\n",a); return 1; } } if (sizeof(rgb24bpp_t) != 3) fprintf(stderr,"WARNING: uint24_t is not 3 bytes long, it is %u bytes\n",(unsigned int)sizeof(rgb24bpp_t)); /* Please don't scale me in the name of "DPI awareness" */ if (!gdi_no_dpiaware) win32_dpi_aware(); /* Bring up DirectX */ /* NTS: On multi-monitor setups, this will create an "emulated" object. Hardware accel won't be possible unless we enum monitors. */ if ((hr=DirectDrawCreate(NULL,&ddraw1,NULL)) != DD_OK) { fprintf(stderr,"DirectDrawCreate failed, HRESULT=0x%08lx\n",hr); return 1; } if ((hr=ddraw1->QueryInterface(IID_IDirectDraw2,(void**)(&ddraw))) != S_OK) { fprintf(stderr,"Unable to query IDirectDraw2 from IDirectDraw, HR=0x%08lx\n",hr); return 1; } ddraw1->Release(); ddraw1 = NULL; if ((hr=ddraw->SetCooperativeLevel(hwndMain,ddrawCooperativeLevel=DDSCL_NORMAL)) != DD_OK) { fprintf(stderr,"Unable to ask for Normal cooperative mode, HR=0x%08lx\n",hr); return 1; } myInstance = GetModuleHandle(NULL); memset(&wnd,0,sizeof(wnd)); wnd.lpfnWndProc = WndProc; wnd.hInstance = myInstance; wnd.lpszClassName = hwndMainClass; wnd.hCursor = LoadCursor(NULL,IDC_ARROW); if (!RegisterClass(&wnd)) { fprintf(stderr,"RegisterClass() failed\n"); return 1; } rect.top = 0; rect.left = 0; rect.right = 640; rect.bottom = 480; AdjustWindowRect(&rect,WS_OVERLAPPEDWINDOW,FALSE); hwndMain = CreateWindow(hwndMainClass,hwndMainTitle, hwndMainStyle=WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,CW_USEDEFAULT, rect.right - rect.left,rect.bottom - rect.top, NULL,NULL, myInstance,NULL); if (!hwndMain) { fprintf(stderr,"CreateWindow() failed\n"); return 1; } if (!init_dx_primary_surface()) { fprintf(stderr,"Failed to init primary surface\n"); return 1; } GetClientRect(hwndMain,&rect); if (!init_bitmap(rect.right,rect.bottom)) { fprintf(stderr,"nit_bitmap() failed for %ux%u\n",(unsigned int)rect.right,(unsigned int)rect.bottom); return 1; } if (lock_bitmap()) { render_pattern(dx_bitmap); unlock_bitmap(); } ShowWindow(hwndMain,SW_SHOW); UpdateWindow(hwndMain); while (GetMessage(&msg,NULL,0,0)) { TranslateMessage(&msg); DispatchMessage(&msg); } free_dx_primary_surface(); free_bitmap(); if (ddraw != NULL) { ddraw->RestoreDisplayMode(); ddraw->Release(); ddraw = NULL; } if (menuDisplayModes != NULL) { DestroyMenu(menuDisplayModes); menuDisplayModes = NULL; } return 0; }
static LRESULT CALLBACK WndProc(HWND hwnd,UINT uMsg,WPARAM wParam,LPARAM lParam) { switch (uMsg) { case WM_CREATE: break; case WM_PAINT: { PAINTSTRUCT ps; BeginPaint(hwnd,&ps); EndPaint(hwnd,&ps); if (ddsurfacePrimary == NULL) { unlock_bitmap(); free_bitmap(); free_dx_primary_surface(); init_dx_primary_surface(); RECT rct; GetClientRect(hwndMain,&rct); if (!init_bitmap(rct.right,rct.bottom)) fprintf(stderr,"WARNING WM_RESIZE init_bitmap(%u,%u) failed\n", (unsigned int)rct.right,(unsigned int)rct.bottom); if (lock_bitmap()) { render_pattern(dx_bitmap); unlock_bitmap(); } } update_screen(); } break; case WM_DISPLAYCHANGE: { announce_fmt = true; unlock_bitmap(); free_bitmap(); free_dx_primary_surface(); init_dx_primary_surface(); RECT rct; GetClientRect(hwndMain,&rct); if (!init_bitmap(rct.right,rct.bottom)) fprintf(stderr,"WARNING WM_RESIZE init_bitmap(%u,%u) failed\n", (unsigned int)rct.right,(unsigned int)rct.bottom); if (lock_bitmap()) { render_pattern(dx_bitmap); unlock_bitmap(); } InvalidateRect(hwndMain,NULL,FALSE); // DWM compositor-based versions set WM_PAINT such that only the affected area will repaint } return DefWindowProc(hwnd,uMsg,wParam,lParam); case WM_SIZE: if (!init_bitmap(LOWORD(lParam),HIWORD(lParam))) fprintf(stderr,"WARNING WM_RESIZE init_bitmap(%u,%u) failed\n", LOWORD(lParam),HIWORD(lParam)); if (lock_bitmap()) { render_pattern(dx_bitmap); unlock_bitmap(); } InvalidateRect(hwndMain,NULL,FALSE); // DWM compositor-based versions set WM_PAINT such that only the affected area will repaint break; case WM_RBUTTONUP: populateDisplayModes(); if (menuDisplayModes != NULL) { POINT pt; GetCursorPos(&pt); TrackPopupMenu(menuDisplayModes,TPM_LEFTALIGN|TPM_TOPALIGN|TPM_RIGHTBUTTON,pt.x,pt.y,0,hwnd,NULL); } break; case WM_COMMAND: if (wParam >= 4000 && wParam < (WPARAM)(4000+displayModesCount)) { DDSURFACEDESC devmode = displayModes[wParam-4000]; HRESULT hr; fprintf(stderr,"Setting display to %u x %u x %ubpp\n", (unsigned int)devmode.dwWidth, (unsigned int)devmode.dwHeight, (unsigned int)devmode.ddpfPixelFormat.dwRGBBitCount); if ((hr=ddraw->SetDisplayMode(devmode.dwWidth,devmode.dwHeight,devmode.ddpfPixelFormat.dwRGBBitCount,devmode.dwRefreshRate,0)) != DD_OK) fprintf(stderr,"Failed to set display mode HR=0x%08lx\n",hr); if (hr == DDERR_NOEXCLUSIVEMODE) { // NTS: Windows 95/98/ME DirectX demands we enter Exclusive cooperative mode before it allows mode changes that change bit depth fprintf(stderr,"Sorry, Windows demands we set the cooperative mode to Exclusive\n"); // Windows 9x/ME behavior for NORMAL cooperative mode DirectX apps try_exclusive_mode(); if ((hr=ddraw->SetDisplayMode(devmode.dwWidth,devmode.dwHeight,devmode.ddpfPixelFormat.dwRGBBitCount,devmode.dwRefreshRate,0)) != DD_OK) fprintf(stderr,"Failed to set display mode HR=0x%08lx\n",hr); } if (hr == DD_OK) { if (is_exclusive_mode()) { // NTS: When we're in Exclusive Fullscreen mode, Windows doesn't broadcast WM_DISPLAYCHANGE or WM_PAINT the way it normally does while we're active. // So for our display code to work we have to poke and prod the window manager and make our window fullscreen, with focus. unlock_bitmap(); free_bitmap(); free_dx_primary_surface(); init_dx_primary_surface(); RECT rct; GetClientRect(hwndMain,&rct); if (!init_bitmap(rct.right,rct.bottom)) fprintf(stderr,"WARNING WM_RESIZE init_bitmap(%u,%u) failed\n", (unsigned int)rct.right,(unsigned int)rct.bottom); if (lock_bitmap()) { render_pattern(dx_bitmap); unlock_bitmap(); } InvalidateRect(hwndMain,NULL,FALSE); // DWM compositor-based versions set WM_PAINT such that only the affected area will repaint try_exclusive_mode(); } hasSetMode = true; } } else if (wParam == 5000) { try_exclusive_mode(); update_screen(); } else if (wParam == 5001) { leave_exclusive_mode(); } else if (wParam == 5002) { leave_exclusive_mode(); ddraw->RestoreDisplayMode(); } else { return DefWindowProc(hwnd,uMsg,wParam,lParam); } break; case WM_KEYDOWN: switch (wParam) { case VK_ESCAPE: PostMessage(hwnd,WM_CLOSE,0,0); break; case VK_SPACE: if ((++pattern) >= 2) pattern = 0; if (lock_bitmap()) { render_pattern(dx_bitmap); unlock_bitmap(); } InvalidateRect(hwndMain,NULL,FALSE); // DWM compositor-based versions set WM_PAINT such that only the affected area will repaint break; } break; case WM_DESTROY: PostQuitMessage(0); break; default: return DefWindowProc(hwnd,uMsg,wParam,lParam); } return 0; }
void update_screen() { IDirectDrawSurface *dst; RECT dstRect; RECT srcRect; HRESULT hr; POINT pt; // NTS: dx_bitmap.is_valid() is not a valid test because base==canvas==NULL unless surface is locked if (ddsurfaceBMP == NULL) return; // NTS: We must provide a source rect, else Windows XP in 24bpp mode will conveniently choose to render the // right half (where extra padding+junk exist) rather than from the left side. Provide a source rect // to make it 100% clear which part of the surface we want blitted to screen. pt.x = pt.y = 0; ClientToScreen(hwndMain,&pt); GetClientRect(hwndMain,&dstRect); OffsetRect(&dstRect,pt.x,pt.y); srcRect.top = srcRect.left = 0; srcRect.right = dx_bitmap.width; srcRect.bottom = dx_bitmap.height; if (ddsurfaceGDI != NULL) dst = ddsurfaceGDI; else if (ddsurfacePrimary != NULL) dst = ddsurfacePrimary; else dst = NULL; if (dst != NULL) hr = dst->Blt(&dstRect,ddsurfaceBMP,&srcRect,0,NULL); else hr = DD_OK; if (hr == DDERR_SURFACELOST) { fprintf(stderr,"Whoops, the primary surface was lost.\n"); if ((hr=dst->Restore()) != DD_OK) { fprintf(stderr,"Unable to restore surface hr=0x%08lx.\n",hr); unlock_bitmap(); free_bitmap(); free_dx_primary_surface(); init_dx_primary_surface(); RECT rct; GetClientRect(hwndMain,&rct); if (!init_bitmap(rct.right,rct.bottom)) fprintf(stderr,"WARNING WM_RESIZE init_bitmap(%u,%u) failed\n", (unsigned int)rct.right,(unsigned int)rct.bottom); if (lock_bitmap()) { render_pattern(dx_bitmap); unlock_bitmap(); } InvalidateRect(hwndMain,NULL,FALSE); // DWM compositor-based versions set WM_PAINT such that only the affected area will repaint } } else if (hr != DD_OK) { fprintf(stderr,"DirectX blit failed, HR=0x%08lx\n",hr); } }
/* * grow_fork() * * Try to add enough allocation blocks to 'fork' * so that it is 'ablock' allocation blocks long. */ static int grow_fork(struct hfs_fork *fork, int ablocks) { struct hfs_cat_entry *entry = fork->entry; struct hfs_mdb *mdb = entry->mdb; struct hfs_extent *ext; int i, start, err; hfs_u16 need, len=0; hfs_u32 ablksz = mdb->alloc_blksz; hfs_u32 blocks, clumpablks; blocks = fork->psize; need = ablocks - blocks/ablksz; if (need < 1) { /* no need to grow the fork */ return 0; } /* round up to clumpsize */ if (entry->u.file.clumpablks) { clumpablks = entry->u.file.clumpablks; } else { clumpablks = mdb->clumpablks; } need = ((need + clumpablks - 1) / clumpablks) * clumpablks; /* find last extent record and try to extend it */ if (!(ext = find_ext(fork, blocks/ablksz - 1))) { /* somehow we couldn't find the end of the file! */ return -1; } /* determine which is the last used extent in the record */ /* then try to allocate the blocks immediately following it */ for (i=2; (i>=0) && !ext->length[i]; --i) {}; if (i>=0) { /* try to extend the last extent */ start = ext->block[i] + ext->length[i]; err = 0; lock_bitmap(mdb); len = hfs_vbm_count_free(mdb, start); if (!len) { unlock_bitmap(mdb); goto more_extents; } if (need < len) { len = need; } err = hfs_set_vbm_bits(mdb, start, len); unlock_bitmap(mdb); if (err) { relse_ext(ext); return -1; } zero_blocks(mdb, start, len); ext->length[i] += len; ext->end += len; blocks = (fork->psize += len * ablksz); need -= len; update_ext(fork, ext); } more_extents: /* add some more extents */ while (need) { len = need; err = 0; lock_bitmap(mdb); start = hfs_vbm_search_free(mdb, &len); if (need < len) { len = need; } err = hfs_set_vbm_bits(mdb, start, len); unlock_bitmap(mdb); if (!len || err) { relse_ext(ext); return -1; } zero_blocks(mdb, start, len); /* determine which is the first free extent in the record */ for (i=0; (i<3) && ext->length[i]; ++i) {}; if (i < 3) { ext->block[i] = start; ext->length[i] = len; ext->end += len; update_ext(fork, ext); } else { if (!(ext = new_extent(fork, ext, blocks/ablksz, start, len, ablksz))) { lock_bitmap(mdb); hfs_clear_vbm_bits(mdb, start, len); unlock_bitmap(mdb); return -1; } } blocks = (fork->psize += len * ablksz); need -= len; } set_cache(fork, ext); relse_ext(ext); return 0; }