static void test_D3DXLoadVolumeFromFileInMemory(IDirect3DDevice9 *device)
{
HRESULT hr;
D3DBOX src_box;
IDirect3DVolume9 *volume;
IDirect3DVolumeTexture9 *volume_texture;
hr = IDirect3DDevice9_CreateVolumeTexture(device, 4, 4, 2, 1, D3DUSAGE_DYNAMIC, D3DFMT_DXT3, D3DPOOL_DEFAULT,
&volume_texture, NULL);
if (FAILED(hr))
{
skip("Failed to create volume texture\n");
return;
}
IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, 0, &volume);
hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), NULL, D3DX_DEFAULT, 0, NULL);
ok(hr == D3D_OK, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, NULL, sizeof(dds_volume_map), NULL, D3DX_DEFAULT, 0, NULL);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, NULL, 0, NULL, D3DX_DEFAULT, 0, NULL);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, 0, NULL, D3DX_DEFAULT, 0, NULL);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
hr = D3DXLoadVolumeFromFileInMemory(NULL, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), NULL, D3DX_DEFAULT, 0, NULL);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
set_box(&src_box, 0, 0, 4, 4, 0, 2);
hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), &src_box, D3DX_DEFAULT, 0, NULL);
ok(hr == D3D_OK, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3D_OK);
set_box(&src_box, 0, 0, 0, 0, 0, 0);
hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), &src_box, D3DX_DEFAULT, 0, NULL);
ok(hr == E_FAIL, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, E_FAIL);
set_box(&src_box, 0, 0, 5, 4, 0, 2);
hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), &src_box, D3DX_DEFAULT, 0, NULL);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
set_box(&src_box, 0, 0, 4, 4, 0, 3);
hr = D3DXLoadVolumeFromFileInMemory(volume, NULL, NULL, dds_volume_map, sizeof(dds_volume_map), &src_box, D3DX_DEFAULT, 0, NULL);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromFileInMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
IDirect3DVolume9_Release(volume);
IDirect3DVolumeTexture9_Release(volume_texture);
}
/* Layout for generic boxes */
void
dlg_format_listbox(struct dialog_data *dlg_data,
struct widget_data *widget_data,
int x, int *y, int w, int max_height, int *rw,
enum format_align align, int format_only)
{
int min, optimal_h, height;
/* Height bussiness follows: */
/* This is only weird heuristic, it could scale well I hope. */
optimal_h = max_height * 7 / 10 - VERTICAL_LISTBOX_MARGIN;
min = get_opt_int((const unsigned char *)"ui.dialogs.listbox_min_height", NULL);
if (max_height - VERTICAL_LISTBOX_MARGIN < min) {
/* Big trouble: can't satisfy even the minimum :-(. */
height = max_height - VERTICAL_LISTBOX_MARGIN;
} else if (optimal_h < min) {
height = min;
} else {
height = optimal_h;
}
set_box(&widget_data->box, x, *y, w, height);
(*y) += height;
if (rw) *rw = w;
}
void
clear_terminal(struct terminal *term)
{
struct box box;
set_box(&box, 0, 0, term->width, term->height);
draw_box(term, &box, ' ', 0, NULL);
set_cursor(term, 0, 0, 1);
}
void
draw_shadow(struct terminal *term, struct box *box,
struct color_pair *color, int width, int height)
{
struct box dbox;
/* (horizontal) */
set_box(&dbox, box->x + width, box->y + box->height,
box->width - width, height);
draw_box(term, &dbox, ' ', 0, color);
/* (vertical) */
set_box(&dbox, box->x + box->width, box->y + height,
width, box->height);
draw_box(term, &dbox, ' ', 0, color);
}
void
draw_progress_bar(struct progress *progress, struct terminal *term,
int x, int y, int width,
unsigned char *text, struct color_pair *meter_color)
{
/* Note : values > 100% are theorically possible and were seen. */
int percent = 0;
struct box barprogress;
if (progress->size > 0)
percent = (int) ((longlong) 100 * progress->pos / progress->size);
/* Draw the progress meter part "[### ]" */
if (!text && width > 2) {
width -= 2;
draw_text(term, x++, y, "[", 1, 0, NULL);
draw_text(term, x + width, y, "]", 1, 0, NULL);
}
if (!meter_color) meter_color = get_bfu_color(term, "dialog.meter");
set_box(&barprogress,
x, y, int_min(width * percent / 100, width), 1);
draw_box(term, &barprogress, ' ', 0, meter_color);
/* On error, will print '?' only, should not occur. */
if (text) {
width = int_min(width, strlen(text));
} else if (width > 1) {
static unsigned char s[] = "????"; /* Reduce or enlarge at will. */
unsigned int slen = 0;
int max = int_min(sizeof(s), width) - 1;
if (ulongcat(s, &slen, percent, max, 0)) {
s[0] = '?';
slen = 1;
}
s[slen++] = '%';
/* Draw the percentage centered in the progress meter */
x += (1 + width - slen) / 2;
assert(slen <= width);
width = slen;
text = s;
}
draw_text(term, x, y, text, width, 0, NULL);
}
void
dlg_format_checkbox(struct dialog_data *dlg_data,
struct widget_data *widget_data,
int x, int *y, int w, int *rw,
enum format_align align, int format_only)
{
struct terminal *term = dlg_data->win->term;
unsigned char *text = widget_data->widget->text;
set_box(&widget_data->box, x, *y, CHECKBOX_LEN, CHECKBOX_HEIGHT);
if (w <= CHECKBOX_LS) return;
if (text && *text) {
if (rw) *rw -= CHECKBOX_LS;
dlg_format_text_do(dlg_data, text, x + CHECKBOX_LS, y,
w - CHECKBOX_LS, rw,
get_bfu_color(term, "dialog.checkbox-label"),
align, format_only);
if (rw) *rw += CHECKBOX_LS;
}
}
void
dlg_format_group(struct dialog_data *dlg_data,
struct widget_data *widget_data,
int n, int x, int *y, int w, int *rw, int format_only)
{
struct terminal *term = dlg_data->win->term;
int space_between_widgets = 1;
int line_width = 0;
int xpos;
struct color_pair *color = get_bfu_color(term, "dialog.text");
assert(n > 0);
if_assert_failed return;
while (n--) {
int widget_width;
int width;
unsigned char *text = widget_data->widget->text;
int label_length;
int label_padding;
#ifdef CONFIG_UTF8
if (term->utf8_cp) {
if (text && *text)
label_length = utf8_ptr2cells(text, NULL);
else
label_length = 0;
} else
#endif /* CONFIG_UTF8 */
label_length = (text && *text) ? strlen(text) : 0;
label_padding = (label_length > 0);
if (widget_data->widget->type == WIDGET_CHECKBOX) {
width = CHECKBOX_LEN;
} else if (widget_is_textfield(widget_data)) {
#ifdef CONFIG_UTF8
if (term->utf8_cp) {
width = utf8_ptr2cells(widget_data->widget->data,
NULL);
} else
#endif /* CONFIG_UTF8 */
width = widget_data->widget->datalen;
} else {
/* TODO: handle all widget types. */
widget_data++;
continue;
}
int_bounds(&label_length, 0, w - width - label_padding);
widget_width = width + label_padding + label_length;
if (line_width + widget_width > w) {
line_width = 0;
(*y) += 2; /* Next line */
}
xpos = x + line_width;
if (!format_only) {
if (widget_data->widget->type == WIDGET_CHECKBOX) {
/* Draw text at right of checkbox. */
if (label_length) {
#ifdef CONFIG_UTF8
if (term->utf8_cp) {
int lb = utf8_cells2bytes(
text,
label_length,
NULL);
draw_dlg_text(dlg_data, xpos + width
+ label_padding,
*y, text, lb, 0,
color);
} else
#endif /* CONFIG_UTF8 */
{
draw_dlg_text(dlg_data, xpos + width
+ label_padding,
*y, text,
label_length, 0,
color);
}
}
set_box(&widget_data->box, xpos, *y, width, 1);
} else if (widget_is_textfield(widget_data)) {
/* Draw label at left of widget. */
if (label_length) {
#ifdef CONFIG_UTF8
if (term->utf8_cp) {
int lb = utf8_cells2bytes(
text,
label_length,
NULL);
draw_dlg_text(dlg_data, xpos, *y,
text, lb, 0, color);
} else
#endif /* CONFIG_UTF8 */
{
draw_dlg_text(dlg_data, xpos, *y,
text, label_length,
0, color);
}
}
set_box(&widget_data->box,
xpos + label_padding + label_length, *y,
width, 1);
}
}
line_width += widget_width;
if (rw) int_bounds(rw, line_width, w);
line_width += space_between_widgets;
widget_data++;
}
(*y)++;
}
void key_event(void){
int i, c;
struct timespec length = { ttyclock->option.delay, ttyclock->option.nsdelay };
if (ttyclock->option.screensaver)
{
c = wgetch(stdscr);
if(c != ERR && ttyclock->option.noquit == False)
{
ttyclock->running = False;
}
else
{
nanosleep(&length, NULL);
for(i = 0; i < 8; ++i)
if(c == (i + '0'))
{
ttyclock->option.color = i;
init_pair(1, ttyclock->bg, i);
init_pair(2, i, ttyclock->bg);
}
}
return;
}
switch(c = wgetch(stdscr))
{
case KEY_UP:
case 'k':
case 'K':
if(ttyclock->geo.x >= 1
&& !ttyclock->option.center)
clock_move(ttyclock->geo.x - 1, ttyclock->geo.y, ttyclock->geo.w, ttyclock->geo.h);
break;
case KEY_DOWN:
case 'j':
case 'J':
if(ttyclock->geo.x <= (LINES - ttyclock->geo.h - DATEWINH)
&& !ttyclock->option.center)
clock_move(ttyclock->geo.x + 1, ttyclock->geo.y, ttyclock->geo.w, ttyclock->geo.h);
break;
case KEY_LEFT:
case 'h':
case 'H':
if(ttyclock->geo.y >= 1
&& !ttyclock->option.center)
clock_move(ttyclock->geo.x, ttyclock->geo.y - 1, ttyclock->geo.w, ttyclock->geo.h);
break;
case KEY_RIGHT:
case 'l':
case 'L':
if(ttyclock->geo.y <= (COLS - ttyclock->geo.w - 1)
&& !ttyclock->option.center)
clock_move(ttyclock->geo.x, ttyclock->geo.y + 1, ttyclock->geo.w, ttyclock->geo.h);
break;
case 'q':
case 'Q':
if (ttyclock->option.noquit == False)
ttyclock->running = False;
break;
case 's':
case 'S':
set_second();
break;
case 't':
case 'T':
ttyclock->option.twelve = !ttyclock->option.twelve;
/* Set the new ttyclock->date.datestr to resize date window */
update_hour();
clock_move(ttyclock->geo.x, ttyclock->geo.y, ttyclock->geo.w, ttyclock->geo.h);
break;
case 'c':
case 'C':
set_center(!ttyclock->option.center);
break;
case 'b':
case 'B':
ttyclock->option.bold = !ttyclock->option.bold;
break;
case 'r':
case 'R':
ttyclock->option.rebound = !ttyclock->option.rebound;
if(ttyclock->option.rebound && ttyclock->option.center)
ttyclock->option.center = False;
break;
case 'x':
case 'X':
set_box(!ttyclock->option.box);
break;
default:
nanosleep(&length, NULL);
for(i = 0; i < 8; ++i)
if(c == (i + '0'))
{
ttyclock->option.color = i;
init_pair(1, ttyclock->bg, i);
init_pair(2, i, ttyclock->bg);
}
break;
}
return;
}
void
dlg_format_buttons(struct dialog_data *dlg_data,
struct widget_data *widget_data, int n,
int x, int *y, int w, int *rw, enum format_align align, int format_only)
{
#ifdef CONFIG_UTF8
struct terminal *term = dlg_data->win->term;
#endif
int i1 = 0;
while (i1 < n) {
struct widget_data *widget_data1 = widget_data + i1;
int i2 = i1 + 1;
int mw;
while (i2 < n) {
mw = 0;
#ifdef CONFIG_UTF8
buttons_width(widget_data1, i2 - i1 + 1, NULL, &mw,
term->utf8_cp);
#else
buttons_width(widget_data1, i2 - i1 + 1, NULL, &mw);
#endif /* CONFIG_UTF8 */
if (mw <= w) i2++;
else break;
}
mw = 0;
#ifdef CONFIG_UTF8
buttons_width(widget_data1, i2 - i1, NULL, &mw, term->utf8_cp);
#else
buttons_width(widget_data1, i2 - i1, NULL, &mw);
#endif /* CONFIG_UTF8 */
if (rw) int_bounds(rw, mw, w);
if (!format_only) {
int i;
int p = x + (align == ALIGN_CENTER ? (w - mw) / 2 : 0);
#ifdef CONFIG_UTF8
int button_lr_len = utf8_ptr2cells(BUTTON_LEFT, NULL)
+ utf8_ptr2cells(BUTTON_RIGHT, NULL);
#endif /* CONFIG_UTF8 */
for (i = i1; i < i2; i++) {
#ifdef CONFIG_UTF8
if (term->utf8_cp)
set_box(&widget_data[i].box,
p, *y,
utf8_ptr2cells(widget_data[i].widget->text, NULL)
+ button_lr_len, BUTTON_HEIGHT);
else
#endif /* CONFIG_UTF8 */
set_box(&widget_data[i].box,
p, *y,
widget_data[i].widget->info.button.textlen
+ BUTTON_LR_LEN, BUTTON_HEIGHT);
p += widget_data[i].box.width + BUTTON_HSPACING;
}
}
*y += BUTTON_VSPACING + BUTTON_HEIGHT;
i1 = i2;
}
}
static void test_D3DXLoadVolumeFromMemory(IDirect3DDevice9 *device)
{
int i, x, y, z;
HRESULT hr;
D3DBOX src_box, dst_box;
D3DLOCKED_BOX locked_box;
IDirect3DVolume9 *volume;
IDirect3DVolumeTexture9 *volume_texture;
const DWORD pixels[] = { 0xc3394cf0, 0x235ae892, 0x09b197fd, 0x8dc32bf6,
0xffffffff, 0xffffffff, 0xffffffff, 0xffffffff,
0x00000000, 0x00000000, 0x00000000, 0xffffffff,
0xffffffff, 0x00000000, 0xffffffff, 0x00000000 };
hr = IDirect3DDevice9_CreateVolumeTexture(device, 256, 256, 4, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT,
&volume_texture, NULL);
if (FAILED(hr))
{
skip("Failed to create volume texture\n");
return;
}
IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, 0, &volume);
set_box(&src_box, 0, 0, 4, 1, 0, 4);
set_box(&dst_box, 0, 0, 4, 1, 0, 4);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
IDirect3DVolume9_LockBox(volume, &locked_box, &dst_box, D3DLOCK_READONLY);
for (i = 0; i < 16; i++) check_pixel_4bpp(&locked_box, i % 4, 0, i / 4, pixels[i]);
IDirect3DVolume9_UnlockBox(volume);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_UNKNOWN, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == E_FAIL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, E_FAIL);
hr = D3DXLoadVolumeFromMemory(volume, NULL, NULL, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, NULL, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, NULL, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
set_box(&src_box, 0, 0, 4, 4, 0, 1);
set_box(&dst_box, 0, 0, 4, 4, 0, 1);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, sizeof(pixels), NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
IDirect3DVolume9_LockBox(volume, &locked_box, &dst_box, D3DLOCK_READONLY);
for (i = 0; i < 16; i++) check_pixel_4bpp(&locked_box, i % 4, i / 4, 0, pixels[i]);
IDirect3DVolume9_UnlockBox(volume);
hr = D3DXLoadVolumeFromMemory(volume, NULL, NULL, pixels, D3DFMT_A8R8G8B8, 16, sizeof(pixels), NULL, &src_box, D3DX_FILTER_NONE, 0);
ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
IDirect3DVolume9_LockBox(volume, &locked_box, NULL, D3DLOCK_READONLY);
for (i = 0; i < 16; i++) check_pixel_4bpp(&locked_box, i % 4, i / 4, 0, pixels[i]);
for (z = 0; z < 4; z++)
{
for (y = 0; y < 256; y++)
{
for (x = 0; x < 256; x++)
if (z != 0 || y >= 4 || x >= 4) check_pixel_4bpp(&locked_box, x, y, z, 0);
}
}
IDirect3DVolume9_UnlockBox(volume);
set_box(&src_box, 0, 0, 2, 2, 1, 2);
set_box(&dst_box, 0, 0, 2, 2, 0, 1);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 8, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
IDirect3DVolume9_LockBox(volume, &locked_box, &dst_box, D3DLOCK_READONLY);
for (i = 0; i < 4; i++) check_pixel_4bpp(&locked_box, i % 2, i / 2, 0, pixels[i + 4]);
IDirect3DVolume9_UnlockBox(volume);
set_box(&src_box, 0, 0, 2, 2, 2, 3);
set_box(&dst_box, 0, 0, 2, 2, 1, 2);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 8, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
IDirect3DVolume9_LockBox(volume, &locked_box, &dst_box, D3DLOCK_READONLY);
for (i = 0; i < 4; i++) check_pixel_4bpp(&locked_box, i % 2, i / 2, 0, pixels[i + 8]);
IDirect3DVolume9_UnlockBox(volume);
set_box(&src_box, 0, 0, 4, 1, 0, 4);
set_box(&dst_box, -1, -1, 3, 0, 0, 4);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
set_box(&dst_box, 254, 254, 258, 255, 0, 4);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
set_box(&dst_box, 4, 1, 0, 0, 0, 4);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
set_box(&dst_box, 0, 0, 0, 0, 0, 0);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
set_box(&dst_box, 0, 0, 0, 0, 0, 1);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
set_box(&dst_box, 300, 300, 300, 300, 0, 0);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
IDirect3DVolume9_Release(volume);
IDirect3DVolumeTexture9_Release(volume_texture);
hr = IDirect3DDevice9_CreateVolumeTexture(device, 256, 256, 4, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &volume_texture, NULL);
if (FAILED(hr))
{
skip("Failed to create volume texture\n");
return;
}
IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, 0, &volume);
set_box(&src_box, 0, 0, 4, 1, 0, 4);
set_box(&dst_box, 0, 0, 4, 1, 0, 4);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 16, NULL, &src_box, D3DX_DEFAULT, 0);
ok(hr == D3DERR_INVALIDCALL, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3DERR_INVALIDCALL);
IDirect3DVolume9_Release(volume);
IDirect3DVolumeTexture9_Release(volume_texture);
hr = IDirect3DDevice9_CreateVolumeTexture(device, 8, 8, 1, 1, D3DUSAGE_DYNAMIC, D3DFMT_DXT1, D3DPOOL_DEFAULT, &volume_texture, NULL);
if (FAILED(hr))
{
skip("Failed to create volume texture\n");
return;
}
IDirect3DVolumeTexture9_GetVolumeLevel(volume_texture, 0, &volume);
set_box(&src_box, 1, 1, 7, 7, 0, 1);
set_box(&dst_box, 1, 1, 7, 7, 0, 1);
hr = D3DXLoadVolumeFromMemory(volume, NULL, &dst_box, pixels, D3DFMT_A8R8G8B8, 16, 32, NULL, &src_box, D3DX_DEFAULT, 0);
todo_wine ok(hr == D3D_OK, "D3DXLoadVolumeFromMemory returned %#x, expected %#x\n", hr, D3D_OK);
IDirect3DVolume9_Release(volume);
IDirect3DVolumeTexture9_Release(volume_texture);
}
void
draw_border(struct terminal *term, struct box *box,
struct color_pair *color, int width)
{
static const enum border_char p1[] = {
BORDER_SULCORNER,
BORDER_SURCORNER,
BORDER_SDLCORNER,
BORDER_SDRCORNER,
BORDER_SVLINE,
BORDER_SHLINE,
};
static const enum border_char p2[] = {
BORDER_DULCORNER,
BORDER_DURCORNER,
BORDER_DDLCORNER,
BORDER_DDRCORNER,
BORDER_DVLINE,
BORDER_DHLINE,
};
const enum border_char *p = (width > 1) ? p2 : p1;
struct box borderbox;
set_box(&borderbox, box->x - 1, box->y - 1,
box->width + 2, box->height + 2);
if (borderbox.width > 2) {
struct box bbox;
/* Horizontal top border */
set_box(&bbox, box->x, borderbox.y, box->width, 1);
draw_box(term, &bbox, p[5], SCREEN_ATTR_FRAME, color);
/* Horizontal bottom border */
bbox.y += borderbox.height - 1;
draw_box(term, &bbox, p[5], SCREEN_ATTR_FRAME, color);
}
if (borderbox.height > 2) {
struct box bbox;
/* Vertical left border */
set_box(&bbox, borderbox.x, box->y, 1, box->height);
draw_box(term, &bbox, p[4], SCREEN_ATTR_FRAME, color);
/* Vertical right border */
bbox.x += borderbox.width - 1;
draw_box(term, &bbox, p[4], SCREEN_ATTR_FRAME, color);
}
if (borderbox.width > 1 && borderbox.height > 1) {
int right = borderbox.x + borderbox.width - 1;
int bottom = borderbox.y + borderbox.height - 1;
/* Upper left corner */
draw_border_char(term, borderbox.x, borderbox.y, p[0], color);
/* Upper right corner */
draw_border_char(term, right, borderbox.y, p[1], color);
/* Lower left corner */
draw_border_char(term, borderbox.x, bottom, p[2], color);
/* Lower right corner */
draw_border_char(term, right, bottom, p[3], color);
}
set_screen_dirty(term->screen, borderbox.y, borderbox.y + borderbox.height);
}
void ReadCarFile(void)
{
char line[MAX_LINE_LENGTH]; /* Stores lines as they are read in */
int k,m,n; /* counters */
int skip; /* lines to skip at beginning of file */
double lowest, highest; /* temp coordinate finding variables */
double total_q;
double sq_c;
double cos_alpha; /* Added by SLTM Sept 13, 2010 */
double cos_gamma;
double sin_gamma;
double cos_beta;
double sin_beta;
double A, B, C;
double center[3];
double hmat[6];
double hinv[6];
double lamda[3];
/* Open .car file for reading */
sprintf(line,"%s.car",rootname);
if (pflag > 0) printf(" Reading car file: %s\n",line);
if( (CarF = fopen(line,"r")) == NULL ) {
printf("Cannot open %s\n",line);
exit(33);
}
/* Determine Number of molecules & atoms */
rewind(CarF);
no_molecules = -1; /* Set to -1 because counter will be incremented an
extra time at the end of the file */
fgets(line,MAX_LINE_LENGTH,CarF); /* Read header line */
/* Check for periodicity, if present, read cell constants */
if( strncmp(fgets(line,MAX_LINE_LENGTH,CarF),"PBC=ON",6) == 0) {
periodic = 1;
skip = 5; /* Data starts 5 lines from beginning of file */
fgets(line,MAX_LINE_LENGTH,CarF); /* Comment line */
fgets(line,MAX_LINE_LENGTH,CarF); /* Date stamp */
fscanf(CarF,"%*s %lf %lf %lf %lf %lf %lf %*s",
&pbc[0],&pbc[1],&pbc[2],&pbc[3],&pbc[4],&pbc[5]);
/* Added triclinic flag for non-orthogonal boxes Oct 5, 2010 SLTM */
if(pbc[3] != 90.0 || pbc[4] != 90.0 || pbc[5] != 90.0) {
TriclinicFlag = 1;
} else TriclinicFlag = 0;
} else {
periodic = 0;
skip = 4;
if (pflag > 1) {
printf(" %s is not a periodic system\n", rootname);
printf(" Assigning cell parameters based on coordinates\n");
}
fgets(line,MAX_LINE_LENGTH, CarF); /* Comment line */
fgets(line,MAX_LINE_LENGTH, CarF); /* Date Stamp */
}
/* First pass through file -- Count molecules */
while(fgets(line,MAX_LINE_LENGTH,CarF) != NULL )
if( strncmp(line,"end",3) == 0 )
no_molecules++;
/* Allocate space to keep track of the number of atoms within a molecule */
no_atoms = (int *) calloc(no_molecules,sizeof(int));
if ( no_atoms == NULL ) {
printf("Could not allocate memory for no_atoms\n");
exit(32);
}
/* Second pass through file -- Count atoms */
rewind(CarF);
for(n=0; n < skip; n++) /* Skip beginning lines */
fgets(line,MAX_LINE_LENGTH,CarF);
for(n=0; n < no_molecules; n++)
while( strncmp(fgets(line,MAX_LINE_LENGTH,CarF),"end",3) )
no_atoms[n]++;
for( total_no_atoms=0, n=0; n < no_molecules; n++ )
total_no_atoms += no_atoms[n];
molecule = (struct MoleculeList *) calloc(no_molecules,
sizeof(struct MoleculeList));
if (molecule == NULL) {
printf("Unable to allocate memory for molecule structure\n");
exit(32);
}
molecule[0].start = 0;
molecule[0].end = no_atoms[0];
for (n=1; n < no_molecules; n++) {
molecule[n].start = molecule[n-1].end;
molecule[n].end = molecule[n].start + no_atoms[n];
}
/* Allocate space for atoms Atom structures */
atoms = (struct Atom *) calloc(total_no_atoms,sizeof(struct Atom));
if( atoms == NULL ) {
printf("Could not allocate memory for AtomList\n");
exit(32);
}
/* Third pass through file -- Read+Parse Car File */
center[0] = center[1] = center[2] = 0.0;
rewind(CarF);
for(n=0; n < skip; n++)
fgets(line,MAX_LINE_LENGTH,CarF);
for(m=0; m < no_molecules; m++) {
for(k=molecule[m].start; k <
molecule[m].end; k++) {
atoms[k].molecule = m;
atoms[k].no = k;
fscanf(CarF,"%s %lf %lf %lf %*s %d %s %s %f",
atoms[k].name,
&(atoms[k].x[0]),
&(atoms[k].x[1]),
&(atoms[k].x[2]),
&(atoms[k].molecule),
atoms[k].potential,
atoms[k].element,
&(atoms[k].q));
atoms[k].x[0] += shift[0];
atoms[k].x[1] += shift[1];
atoms[k].x[2] += shift[2];
if (centerflag) {
center[0] += atoms[k].x[0];
center[1] += atoms[k].x[1];
center[2] += atoms[k].x[2];
}
}
fgets(line,MAX_LINE_LENGTH,CarF);
fgets(line,MAX_LINE_LENGTH,CarF);
} /* End m (molecule) loop */
center[0] /= (double) total_no_atoms;
center[1] /= (double) total_no_atoms;
center[2] /= (double) total_no_atoms;
for (total_q=0.0,k=0; k < total_no_atoms; k++)
total_q += atoms[k].q;
if (pflag > 1) {
printf(" There are %d atoms in %d molecules in this file\n",
total_no_atoms,no_molecules);
printf(" The total charge in the system is %7.3f.\n",total_q);
}
/* Search coordinates to find lowest and highest for x, y, and z */
if (periodic == 0) {
/* Added if/else statment STLM Oct 5 2010 */
if (TriclinicFlag == 0) {
/* no need to re-center the box, if we use min/max values */
center[0] = center[1] = center[2] = 0.0;
for ( k = 0; k < 3; k++) {
lowest = atoms[0].x[k];
highest = atoms[0].x[k];
for ( m = 1; m < total_no_atoms; m++) {
if (atoms[m].x[k] < lowest) lowest = atoms[m].x[k];
if (atoms[m].x[k] > highest) highest = atoms[m].x[k];
}
box[0][k] = lowest - 0.5;
box[1][k] = highest + 0.5;
box[2][k] = 0.0;
}
} else {
printf("This tool only works for periodic systems with triclinic boxes");
exit(32);
}
} else {
if (TriclinicFlag == 0) {
for (k=0; k < 3; k++) {
box[0][k] = -0.5*pbc[k] + center[k] + shift[k];
box[1][k] = 0.5*pbc[k] + center[k] + shift[k];
box[2][k] = 0.0;
}
} else {
sq_c = pbc[2]*pbc[2];
cos_alpha = cos(pbc[3]*PI_180);
cos_gamma = cos(pbc[5]*PI_180);
sin_gamma = sin(pbc[5]*PI_180);
cos_beta = cos(pbc[4]*PI_180);
sin_beta = sin(pbc[4]*PI_180);
if (pflag > 2) {
printf(" pbc[3] %f pbc[4] %f pbc[5] %f\n", pbc[3] ,pbc[4] ,pbc[5]);
printf(" cos_alpha %f cos_beta %f cos_gamma %f\n", cos_alpha ,cos_beta ,cos_gamma);
}
A = pbc[0];
B = pbc[1];
C = pbc[2];
box[0][0] = -0.5*A + center[0] + shift[0];
box[1][0] = 0.5*A + center[0] + shift[0];
box[0][1] = -0.5*B*sin_gamma + center[1] + shift[1];
box[1][1] = 0.5*B*sin_gamma + center[1] + shift[1];
box[0][2] = -0.5*sqrt(sq_c * sin_beta*sin_beta - C*(cos_alpha-cos_gamma*cos_beta)/sin_gamma) + center[2] + shift[2];
box[1][2] = 0.5*sqrt(sq_c * sin_beta*sin_beta - C*(cos_alpha-cos_gamma*cos_beta)/sin_gamma) + center[2] + shift[2];
box[2][0] = B * cos_gamma; /* This is xy SLTM */
box[2][1] = C * cos_beta; /* This is xz SLTM */
box[2][2] = C*(cos_alpha-cos_gamma*cos_beta)/sin_gamma; /* This is yz SLTM */
}
}
/* compute image flags */
set_box(box,hmat,hinv);
n = 0;
for (m = 0; m < total_no_atoms; m++) {
double tmp;
int w=0;
x2lamda(atoms[m].x,lamda,hinv,box[0]);
for (k = 0; k < 3; ++k) {
tmp = floor(lamda[k]);
atoms[m].image[k] = tmp;
lamda[k] -= tmp;
if (tmp != 0.0) ++w;
}
lamda2x(lamda, atoms[m].x,hmat,box[0]);
if (w > 0) ++n;
}
/* warn if atoms are outside the box */
if (n > 0) {
if (periodic) {
if (pflag > 1)
printf(" %d of %d atoms with nonzero image flags\n\n",n,total_no_atoms);
} else {
if (iflag == 0 || (pflag > 1))
printf(" %d of %d atoms outside the box\n\n",n,total_no_atoms);
condexit(32);
}
}
/* Close .car file */
if (fclose(CarF) !=0) {
printf("Error closing %s.car\n", rootname);
exit(31);
}
}
void geometry_t::init(const parameter_reader_t* const reader)
{
const std::string geom_type = reader->get_attribute("type");
// PRX_DEBUG_COLOR("MAKING GEOMETRY " << geom_type.c_str(), PRX_TEXT_CYAN);
if (geom_type == "box")
{
const vector_t dims = reader->get_attribute_as<vector_t>("dims");
if (dims.get_dim() != 3)
PRX_FATAL_S("Box must have three-dimensional dims attribute.")
set_box(dims[0], dims[1], dims[2]);
}
else if (geom_type == "sphere")
set_sphere(reader->get_attribute_as<double>("radius"));
else if (geom_type == "cone")
set_cone(reader->get_attribute_as<double>("radius"),
reader->get_attribute_as<double>("height"));
else if (geom_type == "cylinder")
set_cylinder(reader->get_attribute_as<double>("radius"),
reader->get_attribute_as<double>("height"));
else if (geom_type == "open_cylinder")
set_open_cylinder(reader->get_attribute_as<double>("radius"),
reader->get_attribute_as<double>("height"));
else if (geom_type == "capsule")
set_capsule(reader->get_attribute_as<double>("radius"),
reader->get_attribute_as<double>("height"));
else if (geom_type == "mesh")
set_mesh(reader->get_attribute_as<std::string>("filename"));
else if (geom_type == "point_cloud")
set_point_cloud();
else if (geom_type == "heightmap")
set_heightmap(reader->get_attribute_as<std::string>("filename"));
else if (geom_type == "polygon")
{
const std::vector< double > triangles = reader->get_attribute_as< std::vector<double> >("triangles");
set_polygon( triangles );
}
else
{
const std::string trace = reader->trace();
PRX_FATAL_S("Unrecognized geometry type (" << geom_type.c_str() << ") in " << trace.c_str());
}
if ( reader->has_attribute("scale"))
{
scale = reader->get_attribute_as<vector_t>("scale");
if (scale.get_dim() != 3)
PRX_FATAL_S("Scale must have 3 elements at " << reader->trace() );
}
else
set_scale(1.0,1.0,1.0);
if( reader->has_attribute("material" ) )
{
std::string color_string = reader->get_attribute("material");
if( color_string == "yellow" )
{ color[0] = 1; color[1] = 1; color[2] = 0; color[3] = 1.0; }
else if( color_string == "blue" )
{ color[0] = 0; color[1] = 0; color[2] = 1; color[3] = 1.0; }
else if( color_string == "dark_grey" )
{ color[0] = 0.25; color[1] = 0.25; color[2] = 0.25; color[3] = 1.0; }
else if( color_string == "black" )
{ color[0] = 0; color[1] = 0; color[2] = 0; color[3] = 1.0; }
else if( color_string == "green" )
{ color[0] = 0; color[1] = 1; color[2] = 0; color[3] = 1.0; }
else if( color_string == "red" )
{ color[0] = 1; color[1] = 0; color[2] = 0; color[3] = 1.0; }
else if( color_string == "silver" )
{ color[0] = 0.75; color[1] = 0.75; color[2] = 0.75; color[3] = 1.0; }
else if( color_string == "cyan" )
{ color[0] = 0.7; color[1] = 1; color[2] = 1; color[3] = 1.0; }
else if( color_string == "orange" )
{ color[0] = 1; color[1] = 0.6; color[2] = 0.05; color[3] = 1.0; }
else if( color_string == "brown" )
{ color[0] = 0.4; color[1] = 0.25; color[2] = 0.0; color[3] = 1.0;}
else if( color_string == "glass" )
{ color[0] = 0.5; color[1] = 0.5; color[2] = 0.55; color[3] = 0.18;}
else
{ color[0] = 1; color[1] = 1; color[2] = 1; color[3] = 1.0; }
}
else
{ color[0] = 1; color[1] = 1; color[2] = 1; color[3] = 1.0; }
}
void geometry_t::set_params( const std::vector<double>* params )
{
switch (type)
{
case PRX_SPHERE:
PRX_ASSERT(params->size() == 1);
set_sphere((*params)[0]);
break;
case PRX_BOX:
PRX_ASSERT(params->size() == 3);
set_box((*params)[0], (*params)[1], (*params)[2]);
break;
case PRX_CONE:
PRX_ASSERT(params->size() == 2);
set_cone((*params)[0], (*params)[1]);
break;
case PRX_CYLINDER:
PRX_ASSERT(params->size() == 2);
set_cylinder((*params)[0], (*params)[1]);
break;
case PRX_OPEN_CYLINDER:
PRX_ASSERT(params->size() == 2);
set_open_cylinder((*params)[0], (*params)[1]);
break;
case PRX_CAPSULE:
PRX_ASSERT(params->size() == 2);
set_capsule((*params)[0], (*params)[1]);
break;
case PRX_LINES:
// Must have at least two points.
PRX_ASSERT(params->size() >= 6);
// Must have three params per point.
PRX_ASSERT(params->size() % 3 == 0);
// Must have two points per line.
PRX_ASSERT(params->size() % 6 == 0);
this->type = type;
info = *params; // Copy the info directly
break;
case PRX_LINESTRIP:
// Must have at least two points.
PRX_ASSERT(params->size() >= 6);
// Must have three params per point.
PRX_ASSERT(params->size() % 3 == 0);
this->type = type;
info = *params; // Copy the info directly
break;
case PRX_CLOUD:
// Must have three params per point.
PRX_ASSERT(params->size() % 3 == 0);
info = *params; // Copy the info directly
break;
default:
PRX_FATAL_S("Invalid geometry type: " << type);
break;
}
}
void
dlg_format_group(struct terminal *term,
struct widget_data *widget_data,
int n, int x, int *y, int w, int *rw)
{
int space_between_widgets = 1;
int line_width = 0;
int xpos;
struct color_pair *color = get_bfu_color(term, "dialog.text");
assert(n > 0);
if_assert_failed return;
while (n--) {
int widget_width;
int width;
unsigned char *text = widget_data->widget->text;
int label_length = (text && *text) ? strlen(text) : 0;
int label_padding = (label_length > 0);
if (widget_data->widget->type == WIDGET_CHECKBOX) {
width = 3;
} else if (widget_is_textfield(widget_data)) {
width = widget_data->widget->datalen;
} else {
/* TODO: handle all widget types. */
widget_data++;
continue;
}
int_bounds(&label_length, 0, w - width - label_padding);
widget_width = width + label_padding + label_length;
if (line_width + widget_width > w) {
line_width = 0;
(*y) += 2; /* Next line */
}
xpos = x + line_width;
if (term) {
if (widget_data->widget->type == WIDGET_CHECKBOX) {
/* Draw text at right of checkbox. */
if (label_length)
draw_text(term, xpos + width + label_padding, *y,
text, label_length,
0, color);
set_box(&widget_data->box, xpos, *y, width, 1);
} else if (widget_is_textfield(widget_data)) {
/* Draw label at left of widget. */
if (label_length)
draw_text(term, xpos, *y,
text, label_length,
0, color);
set_box(&widget_data->box,
xpos + label_padding + label_length, *y,
width, 1);
}
}
line_width += widget_width;
if (rw) int_bounds(rw, line_width, w);
line_width += space_between_widgets;
widget_data++;
}
(*y)++;
}
void do_page(const month_grid& m, bool left_half, bool right_half)
{
s_ps->black();
s_ps->font("Arial", 10);
// s_ps->rectangle(X0, X0 + WIDTH, Y0, Y0 + HEIGHT);
set_box(X0, RIGHT, Y0, TOP);
thinline();
show_box();
// Line down the middle.
vrule(X0 + WIDTH / 2);
float column_width = WIDTH / 8;
// Top row: day names.
float top_row_height = 20;
// Title.
if (right_half)
{
// Right column; title & notes.
float x = X0 + WIDTH - column_width;
vrule(x);
s_ps->printf(x + 10, s_y1 - 20, m.m_month_name);
s_ps->printf(x + 10, s_y1 - 40, "%d", m.m_year);
}
if (left_half)
{
// Mini-title, for double-checking book layout.
s_ps->printf(X0 + WIDTH / 2 - 90, s_y0 + 3, "%s %d", m.m_month_name, m.m_year);
}
for (int i = 0; i < 7; i++)
{
if (left_half == false && i < 4) continue;
if (right_half == false && i >= 4) continue;
static const char* day_name[7] = { "SUNDAY", "MONDAY", "TUESDAY", "WEDNESDAY", "THURSDAY", "FRIDAY", "SATURDAY" };
float x = X0 + column_width * i;
set_box(x, x + column_width, TOP - top_row_height, TOP);
s_ps->gray(0.75f);
fill_box();
s_ps->black();
show_box();
s_ps->font("Arial", 8);
s_ps->printf(x + 5, TOP - top_row_height + 3, day_name[i]);
}
float row_height = (HEIGHT - top_row_height) / ROWS;
// Days.
for (int row = 0; row < ROWS; row++)
{
for (int col = 0; col < COLS; col++)
{
if (left_half == false && col < 4) continue;
if (right_half == false && col >= 4) continue;
int day_number = m.m_day_number[row][col];
if (day_number == 0)
{
// Not a day.
continue;
}
// Show this day.
float x = X0 + column_width * col;
float y = Y0 + row_height * (ROWS - 1 - row);
set_box(x, x + column_width, y, y + row_height);
thickline();
show_box();
// Show lines.
static const int LINES = 8;
float line_height = row_height / LINES;
for (int line = 0; line < LINES; line++)
{
thinline();
hrule(y + line_height * line);
}
// Show the day number.
s_ps->printf(s_x1 - 11, s_y0 + 3, "%2d", day_number);
}
}
}
