Quote from: tg2k3 on 2010-08-14 15:43:39

i have a very stupid question. is there some sort of introduction/tutorial/... available to get started with all this? i know how to code js/vbscript but i just have no clue how to even invoke the editor to edit something =)

When  you have read this topic and this link thru, then you know almost all about how to code in wsh, you have already big benefit, like you said you know how to code in js. I had to learn all of this from scratch.  But now i laugh how stupid i was six months ago

window.MinWidth = window.Height;
window.MaxWidth = window.Height;

DT_TOP = 0x00000000;
DT_LEFT = 0x00000000;
DT_CENTER = 0x00000001;
DT_RIGHT = 0x00000002;
DT_VCENTER = 0x00000004;
DT_BOTTOM = 0x00000008;
DT_WORDBREAK = 0x00000010;
DT_CALCRECT = 0x00000400;
DT_NOPREFIX = 0x00000800;
DT_END_ELLIPSIS = 0x00008000;

function RGB(r,g,b) {
    return (0xff000000|(r<<16)|(g<<8)|(b));
}

s = "The Plymouth Guildhall recording is sourced from an original soundboard tape. An audience bootleg recording of the show has been used to add ambience and to repair a missing intro section from Get Thy Bearings."
font = gdi.Font("Tahoma", 12, 0);
flags = DT_CENTER | DT_CALCRECT | DT_WORDBREAK | DT_NOPREFIX;
window.Repaint();

function print(gr, string, x, y, w, font, color, flags)
{
    rect = gr.MeasureString(string, font, x, y, w, 9999999999, flags);
    gr.DrawRect(rect.X, rect.Y, rect.Width, rect.Height, 1, RGB(255,0,0));
    gr.GdiDrawText(string, font, color, x, y, w, rect.Height+50, flags);
}
function on_paint(gr)
{
    ww = window.Width;
    print(gr, s, 4, 4, ww-8, font, RGB(0,0,0), flags);
    fb.trace(ww-8);
}

CalcTextHeight(str, IGdiFont)

var temp_bmp = gdi.CreateImage(1, 1);
var temp_gr = temp_bmp.GetGraphics();
function stringHeight(text, font, y, width, flags)
{
    var arr = temp_gr.GdiDrawText(text, font, 0xFFFFFFFF, 0, y, width, 1, DT_VCENTER|DT_CALCRECT|flags).toArray();
    return(y + arr[3] - arr[1]);
}

[
    object,
    dual,
    pointer_default(unique),
    library_block,
    uuid("9d6e404f-5ba7-4470-88d5-eb5980dffc07")
]
__interface IGdiGraphics: IGdiObj
{
	[propput] STDMETHOD(_ptr)(void * p);
	STDMETHOD(FillSolidRect)(float x, float y, float w, float h, DWORD color);
	STDMETHOD(FillGradRect)(float x, float y, float w, float h, float angle, DWORD color1,
		DWORD color2, [defaultvalue(1.0)] float focus);
	STDMETHOD(FillRoundRect)(float x, float y, float w, float h, float arc_width, float arc_height, DWORD color);
	STDMETHOD(FillEllipse)(float x, float y, float w, float h, DWORD color);
	STDMETHOD(FillPolygon)(DWORD color, [range(0, 1)]INT fillmode, VARIANT points);

	STDMETHOD(DrawLine)(float x1, float y1, float x2, float y2, float line_width, DWORD color);
	STDMETHOD(DrawRect)(float x, float y, float w, float h, float line_width, DWORD color);
	STDMETHOD(DrawRoundRect)(float x, float y, float w, float h, float arc_width,
		 float arc_height, float line_width, DWORD color);
	STDMETHOD(DrawEllipse)(float x, float y, float w, float h, float line_width, DWORD color);
	STDMETHOD(DrawPolygon)(DWORD color, float line_width, VARIANT points);

	STDMETHOD(DrawString)(BSTR str, IGdiFont* font, DWORD color, float x, 
		float y, float w, float h, [defaultvalue(0)] DWORD flags);
	STDMETHOD(GdiDrawText)(BSTR str, IGdiFont * font, DWORD color, int x, int y, int w, int h,
		[defaultvalue(0)] DWORD format, [out,retval] VARIANT * p);
	STDMETHOD(DrawImage)(IGdiBitmap* image, float dstX, float dstY, float dstW, float dstH, float srcX, float srcY,
		float srcW, float srcH, [defaultvalue(0)]float angle, [defaultvalue(255)]BYTE alpha);
	STDMETHOD(GdiDrawBitmap)(IGdiRawBitmap * bitmap, int dstX, int dstY, int dstW, 
		int dstH, int srcX, int srcY, int srcW, int srcH);
	STDMETHOD(GdiAlphaBlend)(IGdiRawBitmap * bitmap, int dstX, int dstY, int dstW, int dstH, int srcX,
		int srcY, int srcW, int srcH, [defaultvalue(255)]BYTE alpha);
	//STDMETHOD(GdiTransparentBlt)(IGdiRawBitmap * bitmap, int dstX, int dstY, int dstW, int dstH,
	//	int srcX, int srcY, int srcW, int srcH, DWORD color);
	STDMETHOD(MeasureString)(BSTR str, IGdiFont * font, float x, float y, float w, float h, 
		[defaultvalue(0)] DWORD flags, [out,retval] IMeasureStringInfo ** pp);
	STDMETHOD(CalcTextWidth)(BSTR str, IGdiFont * font, [out,retval] UINT * p);
	STDMETHOD(CalcTextHeight)(BSTR str, IGdiFont * font, [out,retval] UINT * p);
	STDMETHOD(EstimateLineWrap)(BSTR str, IGdiFont * font, int max_width, [out,retval] VARIANT * p);
	STDMETHOD(SetTextRenderingHint)([range(Gdiplus::TextRenderingHintSystemDefault, 
		Gdiplus::TextRenderingHintClearTypeGridFit)] UINT mode);
	STDMETHOD(SetSmoothingMode)([range(Gdiplus::SmoothingModeInvalid, 
		Gdiplus::SmoothingModeAntiAlias)] int mode);
	STDMETHOD(SetInterpolationMode)([range(Gdiplus::InterpolationModeInvalid, 
		Gdiplus::InterpolationModeHighQualityBicubic)] int mode);
	//STDMETHOD(SetCompositingMode)([range(Gdiplus::CompositingModeSourceOver, 
	//	Gdiplus::CompositingModeSourceCopy)] UINT mode);
	//STDMETHOD(SetCompositingQuality)([range(Gdiplus::CompositingQualityInvalid, 
	//	Gdiplus::CompositingQualityAssumeLinear)] int mode);
};
_COM_SMARTPTR_TYPEDEF(IGdiGraphics, __uuidof(IGdiGraphics));

	[
		object,
		dual,
		pointer_default(unique),
		custom(8AFCDA7F-33B7-3120-86A8-754D2C0C0578, "library_block"),
		uuid(9d6e404f-5ba7-4470-88d5-eb5980dffc07)
	] 
#line 111 "h:\\fb2k-sdk\\foobar2000\\foo-wsh-panel-mod\\foo_uie_wsh_panel_mod\\script_interface.h"
	interface IGdiGraphics : IGdiObj {
#line 113 "h:\\fb2k-sdk\\foobar2000\\foo-wsh-panel-mod\\foo_uie_wsh_panel_mod\\script_interface.h"
		[propput] HRESULT  _ptr([in]void *p);
		HRESULT  FillSolidRect([in]float x, [in]float y, [in]float w, [in]float h, [in]DWORD color);
		HRESULT  FillGradRect([in]float x, [in]float y, [in]float w, [in]float h, [in]float angle, 
			[in]DWORD color1, [in]DWORD color2, [defaultvalue("1.000000")] float focus);
		HRESULT  FillRoundRect([in]float x, [in]float y, [in]float w, [in]float h, [in]float arc_width, 
			[in]float arc_height, [in]DWORD color);
		HRESULT  FillEllipse([in]float x, [in]float y, [in]float w, [in]float h, [in]DWORD color);
		HRESULT  FillPolygon([in]DWORD color, [range(0, 1)] INT fillmode, [in]VARIANT points);
#line 120 "h:\\fb2k-sdk\\foobar2000\\foo-wsh-panel-mod\\foo_uie_wsh_panel_mod\\script_interface.h"
		HRESULT  DrawLine([in]float x1, [in]float y1, [in]float x2, [in]float y2, [in]float line_width, 
			[in]DWORD color);
		HRESULT  DrawRect([in]float x, [in]float y, [in]float w, [in]float h, [in]float line_width, 
			[in]DWORD color);
		HRESULT  DrawRoundRect([in]float x, [in]float y, [in]float w, [in]float h, [in]float arc_width, 
			[in]float arc_height, [in]float line_width, [in]DWORD color);
		HRESULT  DrawEllipse([in]float x, [in]float y, [in]float w, [in]float h, [in]float line_width, 
			[in]DWORD color);
		HRESULT  DrawPolygon([in]DWORD color, [in]float line_width, [in]VARIANT points);
#line 126 "h:\\fb2k-sdk\\foobar2000\\foo-wsh-panel-mod\\foo_uie_wsh_panel_mod\\script_interface.h"
		HRESULT  DrawString([in]BSTR str, [in]IGdiFont *font, [in]DWORD color, [in]float x, 
			[in]float y, [in]float w, [in]float h, [defaultvalue(0)] DWORD flags);
		HRESULT  GdiDrawText([in]BSTR str, [in]IGdiFont *font, [in]DWORD color, [in]int x, 
			[in]int y, [in]int w, [in]int h, [defaultvalue(0)] DWORD format, 
			[out,retval] VARIANT *p);
		HRESULT  DrawImage([in]IGdiBitmap *image, [in]float dstX, [in]float dstY, 
			[in]float dstW, [in]float dstH, [in]float srcX, [in]float srcY, [in]float srcW, 
			[in]float srcH, [defaultvalue(0)] float angle, [defaultvalue(255)] BYTE alpha);
		HRESULT  GdiDrawBitmap([in]IGdiRawBitmap *bitmap, [in]int dstX, [in]int dstY, 
			[in]int dstW, [in]int dstH, [in]int srcX, [in]int srcY, [in]int srcW, [in]int srcH);
		HRESULT  GdiAlphaBlend([in]IGdiRawBitmap *bitmap, [in]int dstX, [in]int dstY, 
			[in]int dstW, [in]int dstH, [in]int srcX, [in]int srcY, [in]int srcW, 
			[in]int srcH, [defaultvalue(255)] BYTE alpha);
#line 132 "h:\\fb2k-sdk\\foobar2000\\foo-wsh-panel-mod\\foo_uie_wsh_panel_mod\\script_interface.h"
		HRESULT  MeasureString([in]BSTR str, [in]IGdiFont *font, [in]float x, [in]float y, [in]float w, 
			[in]float h, [defaultvalue(0)] DWORD flags, [out,retval] IMeasureStringInfo **pp);
		HRESULT  CalcTextWidth([in]BSTR str, [in]IGdiFont *font, [out,retval] UINT *p);
		HRESULT  CalcTextHeight([in]BSTR str, [in]IGdiFont *font, [out,retval] UINT *p);
		HRESULT  EstimateLineWrap([in]BSTR str, [in]IGdiFont *font, [in]int max_width, [out,retval] VARIANT *p);
		HRESULT  SetTextRenderingHint([range(0, 5)] UINT mode);
		HRESULT  SetSmoothingMode([range(-1, 4)] int mode);
		HRESULT  SetInterpolationMode([range(-1, 7)] int mode);
	};

is it a way to accurately measure a string drawn with GdiDrawText()? (I need to know only the height of the string).

@r0lZ:

Quote

is it a way to accurately measure a string drawn with GdiDrawText()? (I need to know only the height of the string).

No simple way, you have to write some functions to calculate them on your own. (use a temp IGraphics is a fine trick anyway)
FYI, if you want a different line length, the simple way is make use of EstimateLineWrap() method.

Could you consider to add a new callback or a window property to reflect the visible/invisible state of the window? (Ideally, the flag should also reflect the state of the entire foobar window, and be off when, for example, foobar is minimized.) It is a pity to have to refresh graphics that are not visible anyway. Thanks in advance.

var back_buffer = null, back_buffer_gr = null;
var ww = 0, wh = 0;
// Draw some stuff on the background buffer every 500ms
var timer = window.CreateTimerInterval(500);

function RGB(r, g, b) {
    return (0xff000000 | (r << 16) | (g << 8) | (b));
}


function on_size() {
    ww = window.Width;
    wh = window.Height;
    
    // Create a background buffer, but first remember to clean previous one
    if (back_buffer) {
        back_buffer.ReleaseGraphics(back_buffer_gr);
        back_buffer.Dispose();
    }
    back_buffer = gdi.CreateImage(ww, wh);
    // Get IGraphics interface of this background buffer
    back_buffer_gr = back_buffer.GetGraphics();
}

function on_paint(gr) {
    draw_on_background();
    gr.DrawImage(back_buffer, 0, 0, ww, wh, 0, 0, ww, wh);
}

function on_timer() {
    draw_on_background();
}

function draw_on_background() {
    // Refresh your background image here.
    if (back_buffer_gr) {
        back_buffer_gr.FillGradRect(0, 0, ww, wh, 90, RGB(240, 240, 240), RGB(190, 190, 190));
    }
}

I'll consider that. However, if you want to refresh graphics even it's not visible, why not providing a background buffer and draws on it?

g_theme.DrawThemeBackground(gr, this.x, this.y, this.w, this.h);

1. I'll add multiple selection support for applying context menu commands in the near future (but only in context menu).

var g_theme = window.CreateThemeManager("PROGRESS");
var g_bar_height = 4;
var g_cycles = 0;
var ww = 0,
	wh = 0;
var top = 0;
var g_pos = 0;
var g_drag = false;
var g_length = 1;

function clamp(x, l, h) {
	return (x < l) ? l : ((x > h) ? h : x);
}


function on_size() {
	ww = window.Width;
	wh = window.Height;
	top = (wh - g_bar_height) >> 1;
}

function on_paint(gr) {
	g_theme.SetPartAndStateID(1, 0);
	g_theme.DrawThemeBackground(gr, 0, top, ww, g_bar_height);

	if (fb.IsPlaying && g_length > 0) {
		g_theme.SetPartAndStateID(5, fb.IsPaused ? 3 : 1);
		g_theme.DrawThemeBackground(gr, 0, top, g_pos, g_bar_height);
	}
}

function on_mouse_lbtn_down(x, y) {
	if (g_length > 0) {
		g_drag = true;
		on_mouse_move(x, y);
	}
}

function on_mouse_lbtn_up(x, y) {
	if (g_length > 0 && g_drag) {
		g_drag = false;
		fb.PlaybackTime = g_length * g_pos / ww;
		on_mouse_move(x, y);
	}
}

function on_mouse_move(x, y) {
	if (g_drag) {
		g_pos = clamp(x, 0, ww);
		window.Repaint();
	}
}

function on_mouse_wheel(delta) {
	fb.PlaybackTime = fb.PlaybackTime + delta * 2;
}

function on_playback_time(time) {
	if (!g_drag) {
		if (g_length > 0) g_pos = ww * time / g_length;
		window.Repaint();
	}
}

function on_playback_seek() {
	if (!g_drag && g_length > 0) window.Repaint();
}

function on_playback_pause() {
	window.Repaint();
}

function on_playback_stop() {
	g_length = 0;
	g_pos = 0;
	g_drag = false;
	window.Repaint();
}

function on_playback_new_track() {
	g_length = fb.PlaybackLength;
	g_pos = 0;
	g_drag = false;
	window.Repaint();
}

if (fb.IsPlaying) on_playback_new_track();

v1.4.0 Beta 1
- ADD: New IFbMetadbHandleList interface for a list of metadb handles.
- ADD: fb.GetSelections() method.
- CHG: fb.RunContextCommandWithMetadb() now accept IFbMetadbHandleList.
- ADD: Autoplaylist functions: fb.IsAutoPlaylist(), fb.CreateAutoPlaylist() and fb.ShowAutoPlaylistUI().
- FIX: Script crashes with themes API while changing Windows themes.
- ADD: UI improvements.