trunk/Src/wptW32API.cpp

/* wptW32API.cpp - Common W32 API functions
 *      Copyright (C) 2001, 2002, 2003, 2005 Timo Schulz
 *
 * This file is part of WinPT.
 *
 * WinPT is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 * 
 * WinPT is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with WinPT; if not, write to the Free Software Foundation, 
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

#include <windows.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <shellapi.h>
#include <shlobj.h>
#include <commctrl.h>
#include <time.h>

#include "wptNLS.h"
#include "wptW32API.h"
#include "wptErrors.h"
#include "wptVersion.h"
#include "wptTypes.h"


extern "C" void _SHFree (void *p);


static void
set_menu_text_ext (HMENU menu, int by_pos, int m_uid, const char *text)
{
    MENUITEMINFO mii;
    
    memset (&mii, 0, sizeof mii);
    mii.cbSize = sizeof mii;
    mii.fMask = MIIM_TYPE;
    mii.fType = MFT_STRING;
    mii.dwTypeData = (char *) text;
    SetMenuItemInfo (menu, m_uid, by_pos? TRUE : FALSE, &mii);
}


/* Set the text of a menu item @m_uid to @text. */
void
set_menu_text (HMENU menu, UINT m_uid, const char *text)
{
    set_menu_text_ext (menu, 0, m_uid, text);
}


/* Set the text of a menu item with the position @pos to @text. */
void
set_menu_text_bypos (HMENU menu, UINT pos, const char *text)
{
    set_menu_text_ext (menu, 1, pos, text);
}


/* Set the state of a menu item @m_uid to @state. */
void
set_menu_state (HMENU menu, UINT m_uid, UINT state)
{       
    MENUITEMINFO mii;

    memset (&mii, 0, sizeof (mii));
    mii.cbSize = sizeof (mii);
    mii.fMask = MIIM_STATE;
    mii.fState = state;
    SetMenuItemInfo (menu, m_uid, FALSE, &mii);
}


/* Retrieve the state of the menu item @m_uid and return it. */
UINT
get_menu_state (HMENU menu, UINT m_uid)
{
    MENUITEMINFO mii;

    memset (&mii, 0, sizeof (mii));
    mii.cbSize = sizeof (mii);
    mii.fMask = MIIM_STATE;
    GetMenuItemInfo (menu, m_uid, FALSE, &mii);
    return mii.fState;
}


enum {
    CDLG_FILE_OPEN = 0,
    CDLG_FILE_SAVE = 1
};

/* Use the common dialog to request a file from the user. 
   id can be either FILE_OPEN or FILE_SAVE. 
   The return value is the file name or NULL if cancel was chosen. */
const char *
get_filename_dlg (HWND hwnd, int id, const char * title, 
                  const char * filter, const char * name)
{
    static char file[512] = "";
    OPENFILENAME open;
    
    if (name && strlen (name) < (sizeof (file)-1))
        strcpy (file, name);
    else
        memset (file, 0, sizeof (file));
    if (!filter)
        filter = "All Files (*.*)\0*.*\0\0";
    /* XXX: problem with gettext because of the 'artificial' 
            double string termination!. */
    memset (&open, 0, sizeof (open));
    open.lStructSize = sizeof (OPENFILENAME);
    open.hInstance = glob_hinst;
    open.lpstrTitle = title;
    open.lpstrFilter = filter;
    open.hwndOwner = hwnd;
    open.lpstrFile = file;
    open.nMaxFile = sizeof (file) - 1;
    if (id == CDLG_FILE_OPEN)
        open.Flags = OFN_FILEMUSTEXIST|OFN_PATHMUSTEXIST;
    else
        open.Flags = OFN_OVERWRITEPROMPT;

    if (id == CDLG_FILE_OPEN && GetOpenFileName (&open))
        return open.lpstrFile;
    else if (id == CDLG_FILE_SAVE && GetSaveFileName (&open))
        return open.lpstrFile;
    
    return NULL;
}

const char*
get_filesave_dlg (HWND hwnd, const char *title,
                  const char *filter, const char *name)
{
    return get_filename_dlg (hwnd, CDLG_FILE_SAVE, title, filter, name);
}

const char*
get_fileopen_dlg (HWND hwnd, const char *title, const char *filter,
                  const char *name)
{
    return get_filename_dlg (hwnd, CDLG_FILE_OPEN, title, filter, name);
}


/* Use the common dialog to allow the user to select a folder.
   The return value is either the folder path or NULL if cancel was chosen. */
const char*
get_folder_dlg (HWND hwnd, const char *title, const char *name)
{
    static char folder[MAX_PATH+1] = "";
    BROWSEINFO bi;
    ITEMIDLIST *il;

    memset (&bi, 0, sizeof (bi));
    bi.hwndOwner = hwnd;
    if (title)
        bi.lpszTitle = title;
    if (name && strlen (name) < MAX_PATH-1)
        strcpy (folder, name);
    else
        memset (folder, 0, sizeof (folder));
    il = SHBrowseForFolder (&bi);
    if (il) {
        SHGetPathFromIDList (il, folder);
        _SHFree (il);
        return folder;
    }
    return NULL;
}


/* Return the clipboard contents as a string or NULL
   if the clipboard does not contain text. */
char*
get_clip_text (HWND hwnd)
{
    HANDLE clipmem;
    char *cliptxt, *p;  
    int len;
    
    if (OpenClipboard (hwnd) == FALSE)
        return NULL;
    clipmem = GetClipboardData (CF_TEXT);
    if (clipmem == NULL) {
        p = NULL;
        goto leave;
    }
    cliptxt = (char *) GlobalLock (clipmem);
    if (cliptxt == NULL) {
        p = NULL;
        goto leave;
    }
    
    len =  strlen (cliptxt);
    p = new char[len + 1];
    if (!p)
        BUG (NULL);
    memcpy (p, cliptxt, len);
    p[len] = '\0';
    GlobalUnlock (clipmem);
    
leave:
    CloseClipboard ();
    return p;
}


/* Set @text as the new clipboard content. */
int
set_clip_text (HWND hwnd, const char *text, int nbytes)
{    
    HANDLE clipmem;
    int rc = 0;
    char *p;
    
    if (OpenClipboard (hwnd) == FALSE)  
        return WPTERR_CLIP_OPEN;
    EmptyClipboard ();

    clipmem = GlobalAlloc (GHND, nbytes + 1);
    if (clipmem == NULL)
        BUG (NULL);
    p = (char *) GlobalLock (clipmem);
    if (p == NULL) {
        rc = WPTERR_GENERAL;;
        goto leave;     
    }
    memcpy (p, text, nbytes);
    p[nbytes] = '\0';
    
    GlobalUnlock (clipmem);
    SetClipboardData (CF_TEXT, clipmem);
    GlobalFree (clipmem);
    
leave:
    CloseClipboard ();
    return rc;
}


/* Append or prepend some text to the clipboard contents.
   If as_footer = 1, append the text otherwise prepend. */
int
set_clip_text2 (HWND hwnd, const char *text, int nbytes, int as_footer)
{
    char *p, *new_text;

    p = get_clip_text (hwnd);
    if (!p)
        return WPTERR_CLIP_GET;
    new_text = new char [strlen (p)+strlen (text)+8];
    if (!new_text)
        BUG (0);
    if (as_footer == 0)
        sprintf (new_text, "%s\r\n%s\r\n\r\n", text, p);
    else
        sprintf (new_text, "%s\n%s\n\n", p, text);
    set_clip_text (hwnd, new_text, strlen (new_text)+1);
    free_if_alloc (p);
    free_if_alloc (new_text);
    return 0;
}


/* Make a file name out of the path @path, the file @file and 
   an extension. @ext.
   Return value: the full file name on success. */
char*
make_filename (const char *path, const char *file, const char *ext)
{
    char *p;
    size_t size = 0;

    if( path && *path )
        size += strlen( path );
    if( file && *file )
        size += strlen( file );
    if( ext && *ext )
        size += strlen( ext );
    p = new char[size + 4];
    memset( p, 0, size );
    if( path ) {
        strcat( p, path );
        if( path[strlen( path ) -1] != '\\' )
            strcat( p, "\\" );
    }
    if( file )
        strcat( p, file );
    if( ext ) {
        strcat( p, "." );
        strcat( p, ext );
    }
    return p;
}


/* Generate a file name from a special dirctory. */
char*
make_special_filename (int folder, const char *file, const char *ext)
{
    BOOL ec;
    char path[MAX_PATH], *p;
    size_t n=0;

    /* MSDN: buf must be at least MAX_PATH=256 bytes */
    ec = SHGetSpecialFolderPath (HWND_DESKTOP, path, folder, TRUE);
    if (ec != 1) {
        log_debug ("SHGetSpecialFolderPath() failed\r\n", (int)GetLastError ());
        return NULL;
    }

    n = strlen (path)+1;
    if (file)
        n += strlen (file)+1;
    if (ext)
        n += strlen (ext)+1;
    p = new char[n+2];
    if (!p)
        BUG (0);
    memset (p, 0, n+2);
    strcpy (p, path);    
    if (file) {
        strcat (p, "\\");
        strcat (p, file);
    }
    if (ext)
        strcat (p, ext);
    return p;
}


/* return 0 if the file @fname exists, otherwise >0. */
int
file_exist_check (const char *fname)
{
    struct stat st;
    if (stat (fname, &st) == -1)
        return WPTERR_FILE_EXIST;
    return 0;
}


/* Check if the current folder exists.
   Return 0 for success. */
int
dir_exist_check (const char *dir)
{
    struct stat statbuf;    
    
    if (stat (dir, &statbuf) == -1)
        return WPTERR_GENERAL;
    if (statbuf.st_mode & _S_IFDIR)
        return 0;
    return WPTERR_GENERAL;
}


/* Return the file size of the given file @fname. */
DWORD
get_file_size (const char *fname)
{
    DWORD fsize;
    HANDLE fh;

    fh = CreateFile (fname, GENERIC_READ, FILE_SHARE_READ,
                     NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
    if (fh == INVALID_HANDLE_VALUE)
        return 0;
    fsize = GetFileSize (fh, NULL);
    if (fsize == 0xFFFFFFFF)
        fsize = 0;
    CloseHandle (fh);
    return fsize;
}


/* Start a dialog with the exception that before it is checked that the
   dialog is not already openened. */
int
dialog_box_param (HINSTANCE hinst, LPCTSTR name, HWND parent, DLGPROC fnc, 
                  LPARAM param, LPCTSTR title, int title_id)
{
    if (FindWindowEx (GetDesktopWindow (), NULL, NULL, title))
        return -1;
    return DialogBoxParam (hinst, name, parent, fnc, param);
}


/* Wrapper for message box which forces the message box into the
   foreground and it is displayed always on top. */
int
msg_box (HWND hwnd, const char *text, const char *title, int mode)
{
    mode |= MB_SETFOREGROUND;
    mode |= MB_TASKMODAL;
    mode |= MB_TOPMOST;
    return MessageBox(hwnd, text, title, mode);
}


/* Safe strdup version (C++ version). */
char*
m_strdup (const char *str)
{
    char *p = new char[strlen (str) + 1];
    if (!p)
        BUG (NULL);
    strcpy (p, str);
    return p;
}


/* Center the hwndChild relative to parent.
   The style param allows to specificy additional styles (like topmost). */
void
center_window2 (HWND hwndChild, HWND parent, HWND style) 
{     
    HWND hwndParent;
    RECT rChild, rParent;    
    HDC hdc;
    int wChild, hChild, wParent, hParent;     
    int wScreen, hScreen, xNew, yNew;
    int flags = SWP_NOSIZE | SWP_NOZORDER;

    hwndParent = parent;
    if (hwndParent == NULL)
        hwndParent = GetDesktopWindow ();
    GetWindowRect (hwndChild, &rChild);     
    wChild = rChild.right - rChild.left;     
    hChild = rChild.bottom - rChild.top;

    GetWindowRect (hwndParent, &rParent);     
    wParent = rParent.right - rParent.left;     
    hParent = rParent.bottom - rParent.top;      
    
    hdc = GetDC (hwndChild);     
    wScreen = GetDeviceCaps (hdc, HORZRES);     
    hScreen = GetDeviceCaps (hdc, VERTRES);     
    ReleaseDC (hwndChild, hdc);      
    xNew = rParent.left + ((wParent - wChild) /2);     
    if (xNew < 0)
        xNew = 0;
    else if ((xNew+wChild) > wScreen) 
        xNew = wScreen - wChild;
    yNew = rParent.top  + ((hParent - hChild) /2);
    if (yNew < 0)
        yNew = 0;
    else if ((yNew+hChild) > hScreen)
        yNew = hScreen - hChild;
    if (style == HWND_TOPMOST || style == HWND_NOTOPMOST)
        flags = SWP_NOMOVE | SWP_NOSIZE;
    SetWindowPos (hwndChild, style? style : NULL, xNew, yNew, 0, 0, flags);
}


/* Center the given hwndChild window with no special style. */
void
center_window (HWND hwndChild, HWND hwndParent) 
{
    center_window2 (hwndChild, hwndParent, NULL);
}


/* Retrieve the product verion of the given file @fname.
   Format: MAJOR.MINOR.PATCH1.PATCH2
   Return value: 0 on success. */
int
get_file_version (const char *fname, WORD *major, WORD *minor, 
                  WORD *patch1, WORD *patch2)
{
    VS_FIXEDFILEINFO *inf = {0};
    char file[MAX_PATH+1] = {0};
    LPVOID buf, data;
    DWORD arg;
    DWORD size;
    UINT qlen;

    strncpy (file, fname, MAX_PATH);
    size = GetFileVersionInfoSize (file, &arg);
    if (!size)
        return -1;
    buf = (LPVOID)new CHAR[size];
    if (!buf)
        BUG (NULL);
    GetFileVersionInfo (file, 0, size, buf);

    qlen=0;
    VerQueryValue (buf, "\\", &data, &qlen);
    if (!qlen) {
        delete [] (char*)buf;
        return -1;
    }
    inf = (VS_FIXEDFILEINFO*)data;

    if (major)
        *major = HIWORD (inf->dwProductVersionMS);
    if (minor)
        *minor = LOWORD (inf->dwProductVersionMS);
    if (patch1)
        *patch1 = HIWORD (inf->dwProductVersionLS);     
    if (patch2)
        *patch2 = LOWORD (inf->dwProductVersionLS);

    delete [] (char*)buf;
    return 0;
}


/* Return date in a format which complies with the
   system locale settings. */
const char*
get_locale_date (long tm_t, char *buf, DWORD buflen)
{ 
    SYSTEMTIME st; 
    struct tm *ptm;

    ptm = localtime (&tm_t);  
    st.wYear = (WORD)ptm->tm_year;
    st.wMonth = (WORD)ptm->tm_mon;
    st.wDay = (WORD)ptm->tm_mday;
    st.wYear += 1900;
    st.wMonth += 1;
    if (!GetDateFormat (LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st, 
                        NULL, buf, buflen))
        return NULL;
    return buf;
}


/* Generate a temporary file name by using the users
   temp path and optionally a name @name provided by the caller.
   Return value: 0 on success. */
int
get_temp_name (char *buf, DWORD buflen, const char *name)
{
    char tmp[32];

    if (!name) {
        sprintf (tmp, "%08lX", GetTickCount ());
        name = tmp;
    }
    if (!GetTempPath (buflen - strlen (name) -2, buf)) {
        log_debug ("GetTempPath() failed ec=%d\n", (int)GetLastError ());
        return -1;
    }
    strcat (buf, name);
    return 0;
}


struct reminder_hd_s {
    int msecs;
    HWND dlg;
    HANDLE hd;
};


static DWORD CALLBACK
foreground_reminder_thread (void *c)
{
    struct reminder_hd_s *ctx = (struct reminder_hd_s *)c;
    Sleep (ctx->msecs);
    SetForegroundWindow (ctx->dlg);
    CloseHandle (ctx->hd);
    delete ctx;
    ExitThread (0);
    return 0;
}

/* Try to force the window @dlg to the foreground.
   On NT5 or later this will not work if the user
   is working in another window (console for example). */
void
force_foreground_window (HWND dlg, int msecs)
{
    struct reminder_hd_s *hd;
    DWORD tid;

    hd = new reminder_hd_s;
    hd->dlg = dlg;
    hd->msecs = msecs;
    hd->hd = CreateThread (NULL, 0, foreground_reminder_thread, 
                           hd, NULL, &tid);
}
1	werner	36	/* wptW32API.cpp - Common W32 API functions
2	twoaday	121	* Copyright (C) 2001, 2002, 2003, 2005 Timo Schulz
3	werner	36	*
4			* This file is part of WinPT.
5			*
6			* WinPT is free software; you can redistribute it and/or modify
7			* it under the terms of the GNU General Public License as published by
8			* the Free Software Foundation; either version 2 of the License, or
9			* (at your option) any later version.
10			*
11			* WinPT is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
16			* You should have received a copy of the GNU General Public License
17			* along with WinPT; if not, write to the Free Software Foundation,
18			* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
19			*/
20	twoaday	121
21	werner	36	#ifdef HAVE_CONFIG_H
22			#include <config.h>
23			#endif
24
25			#include <windows.h>
26			#include <stdio.h>
27			#include <sys/types.h>
28			#include <sys/stat.h>
29			#include <shellapi.h>
30			#include <shlobj.h>
31			#include <commctrl.h>
32	twoaday	129	#include <time.h>
33	werner	36
34			#include "wptNLS.h"
35			#include "wptW32API.h"
36			#include "wptErrors.h"
37			#include "wptVersion.h"
38			#include "wptTypes.h"
39
40
41			extern "C" void _SHFree (void *p);
42
43
44			static void
45			set_menu_text_ext (HMENU menu, int by_pos, int m_uid, const char *text)
46			{
47			MENUITEMINFO mii;
48
49			memset (&mii, 0, sizeof mii);
50			mii.cbSize = sizeof mii;
51			mii.fMask = MIIM_TYPE;
52			mii.fType = MFT_STRING;
53			mii.dwTypeData = (char *) text;
54			SetMenuItemInfo (menu, m_uid, by_pos? TRUE : FALSE, &mii);
55			}
56
57
58			/* Set the text of a menu item @m_uid to @text. */
59			void
60	twoaday	129	set_menu_text (HMENU menu, UINT m_uid, const char *text)
61	werner	36	{
62			set_menu_text_ext (menu, 0, m_uid, text);
63			}
64
65
66			/* Set the text of a menu item with the position @pos to @text. */
67			void
68	twoaday	129	set_menu_text_bypos (HMENU menu, UINT pos, const char *text)
69	werner	36	{
70			set_menu_text_ext (menu, 1, pos, text);
71			}
72
73
74			/* Set the state of a menu item @m_uid to @state. */
75			void
76	twoaday	129	set_menu_state (HMENU menu, UINT m_uid, UINT state)
77	werner	36	{
78			MENUITEMINFO mii;
79
80	twoaday	121	memset (&mii, 0, sizeof (mii));
81	werner	36	mii.cbSize = sizeof (mii);
82			mii.fMask = MIIM_STATE;
83			mii.fState = state;
84			SetMenuItemInfo (menu, m_uid, FALSE, &mii);
85			}
86
87
88	twoaday	129	/* Retrieve the state of the menu item @m_uid and return it. */
89			UINT
90			get_menu_state (HMENU menu, UINT m_uid)
91			{
92			MENUITEMINFO mii;
93
94			memset (&mii, 0, sizeof (mii));
95			mii.cbSize = sizeof (mii);
96			mii.fMask = MIIM_STATE;
97			GetMenuItemInfo (menu, m_uid, FALSE, &mii);
98			return mii.fState;
99			}
100
101
102	twoaday	77	enum {
103			CDLG_FILE_OPEN = 0,
104			CDLG_FILE_SAVE = 1
105			};
106	werner	36
107			/* Use the common dialog to request a file from the user.
108			id can be either FILE_OPEN or FILE_SAVE.
109			The return value is the file name or NULL if cancel was chosen. */
110			const char *
111			get_filename_dlg (HWND hwnd, int id, const char * title,
112			const char * filter, const char * name)
113			{
114			static char file[512] = "";
115			OPENFILENAME open;
116
117			if (name && strlen (name) < (sizeof (file)-1))
118			strcpy (file, name);
119			else
120			memset (file, 0, sizeof (file));
121			if (!filter)
122	twoaday	167	filter = "All Files (.)\0.\0\0";
123	werner	36	/* XXX: problem with gettext because of the 'artificial'
124			double string termination!. */
125			memset (&open, 0, sizeof (open));
126			open.lStructSize = sizeof (OPENFILENAME);
127			open.hInstance = glob_hinst;
128			open.lpstrTitle = title;
129			open.lpstrFilter = filter;
130			open.hwndOwner = hwnd;
131			open.lpstrFile = file;
132			open.nMaxFile = sizeof (file) - 1;
133	twoaday	77	if (id == CDLG_FILE_OPEN)
134	werner	36	open.Flags = OFN_FILEMUSTEXIST\|OFN_PATHMUSTEXIST;
135			else
136			open.Flags = OFN_OVERWRITEPROMPT;
137
138	twoaday	77	if (id == CDLG_FILE_OPEN && GetOpenFileName (&open))
139	werner	36	return open.lpstrFile;
140	twoaday	77	else if (id == CDLG_FILE_SAVE && GetSaveFileName (&open))
141	werner	36	return open.lpstrFile;
142
143			return NULL;
144			}
145
146			const char*
147			get_filesave_dlg (HWND hwnd, const char *title,
148			const char filter, const char name)
149			{
150	twoaday	77	return get_filename_dlg (hwnd, CDLG_FILE_SAVE, title, filter, name);
151	werner	36	}
152
153	twoaday	121	const char*
154	werner	36	get_fileopen_dlg (HWND hwnd, const char title, const char filter,
155			const char *name)
156			{
157	twoaday	77	return get_filename_dlg (hwnd, CDLG_FILE_OPEN, title, filter, name);
158	werner	36	}
159
160
161			/* Use the common dialog to allow the user to select a folder.
162			The return value is either the folder path or NULL if cancel was chosen. */
163			const char*
164	twoaday	121	get_folder_dlg (HWND hwnd, const char title, const char name)
165	werner	36	{
166			static char folder[MAX_PATH+1] = "";
167			BROWSEINFO bi;
168	twoaday	121	ITEMIDLIST *il;
169	werner	36
170			memset (&bi, 0, sizeof (bi));
171			bi.hwndOwner = hwnd;
172			if (title)
173			bi.lpszTitle = title;
174			if (name && strlen (name) < MAX_PATH-1)
175			strcpy (folder, name);
176			else
177			memset (folder, 0, sizeof (folder));
178			il = SHBrowseForFolder (&bi);
179			if (il) {
180			SHGetPathFromIDList (il, folder);
181			_SHFree (il);
182			return folder;
183			}
184			return NULL;
185			}
186
187
188			/* Return the clipboard contents as a string or NULL
189			if the clipboard does not contain text. */
190			char*
191			get_clip_text (HWND hwnd)
192			{
193			HANDLE clipmem;
194			char cliptxt, p;
195			int len;
196
197			if (OpenClipboard (hwnd) == FALSE)
198			return NULL;
199			clipmem = GetClipboardData (CF_TEXT);
200			if (clipmem == NULL) {
201			p = NULL;
202			goto leave;
203			}
204			cliptxt = (char *) GlobalLock (clipmem);
205			if (cliptxt == NULL) {
206			p = NULL;
207			goto leave;
208			}
209
210			len = strlen (cliptxt);
211			p = new char[len + 1];
212			if (!p)
213			BUG (NULL);
214			memcpy (p, cliptxt, len);
215			p[len] = '\0';
216			GlobalUnlock (clipmem);
217
218			leave:
219			CloseClipboard ();
220			return p;
221			}
222
223
224			/* Set @text as the new clipboard content. */
225			int
226			set_clip_text (HWND hwnd, const char *text, int nbytes)
227			{
228			HANDLE clipmem;
229			int rc = 0;
230			char *p;
231
232			if (OpenClipboard (hwnd) == FALSE)
233			return WPTERR_CLIP_OPEN;
234			EmptyClipboard ();
235
236			clipmem = GlobalAlloc (GHND, nbytes + 1);
237			if (clipmem == NULL)
238			BUG (NULL);
239			p = (char *) GlobalLock (clipmem);
240			if (p == NULL) {
241			rc = WPTERR_GENERAL;;
242			goto leave;
243			}
244			memcpy (p, text, nbytes);
245			p[nbytes] = '\0';
246
247			GlobalUnlock (clipmem);
248			SetClipboardData (CF_TEXT, clipmem);
249	twoaday	181	GlobalFree (clipmem);
250	werner	36
251			leave:
252			CloseClipboard ();
253			return rc;
254	twoaday	181	}
255	werner	36
256
257			/* Append or prepend some text to the clipboard contents.
258			If as_footer = 1, append the text otherwise prepend. */
259			int
260			set_clip_text2 (HWND hwnd, const char *text, int nbytes, int as_footer)
261			{
262			char p, new_text;
263
264			p = get_clip_text (hwnd);
265			if (!p)
266			return WPTERR_CLIP_GET;
267			new_text = new char [strlen (p)+strlen (text)+8];
268			if (!new_text)
269			BUG (0);
270			if (as_footer == 0)
271			sprintf (new_text, "%s\r\n%s\r\n\r\n", text, p);
272			else
273			sprintf (new_text, "%s\n%s\n\n", p, text);
274			set_clip_text (hwnd, new_text, strlen (new_text)+1);
275			free_if_alloc (p);
276			free_if_alloc (new_text);
277			return 0;
278			}
279
280
281	twoaday	121	/* Make a file name out of the path @path, the file @file and
282			an extension. @ext.
283			Return value: the full file name on success. */
284	werner	36	char*
285			make_filename (const char path, const char file, const char *ext)
286			{
287			char *p;
288			size_t size = 0;
289
290			if( path && *path )
291			size += strlen( path );
292			if( file && *file )
293			size += strlen( file );
294			if( ext && *ext )
295			size += strlen( ext );
296			p = new char[size + 4];
297			memset( p, 0, size );
298			if( path ) {
299			strcat( p, path );
300			if( path[strlen( path ) -1] != '\\' )
301			strcat( p, "\\" );
302			}
303			if( file )
304			strcat( p, file );
305			if( ext ) {
306			strcat( p, "." );
307			strcat( p, ext );
308			}
309			return p;
310	twoaday	121	}
311	werner	36
312
313	twoaday	150	/* Generate a file name from a special dirctory. */
314			char*
315			make_special_filename (int folder, const char file, const char ext)
316			{
317			BOOL ec;
318			char path[MAX_PATH], *p;
319			size_t n=0;
320
321			/* MSDN: buf must be at least MAX_PATH=256 bytes */
322			ec = SHGetSpecialFolderPath (HWND_DESKTOP, path, folder, TRUE);
323			if (ec != 1) {
324			log_debug ("SHGetSpecialFolderPath() failed\r\n", (int)GetLastError ());
325			return NULL;
326			}
327
328			n = strlen (path)+1;
329			if (file)
330			n += strlen (file)+1;
331			if (ext)
332			n += strlen (ext)+1;
333			p = new char[n+2];
334			if (!p)
335			BUG (0);
336			memset (p, 0, n+2);
337			strcpy (p, path);
338			if (file) {
339			strcat (p, "\\");
340			strcat (p, file);
341			}
342			if (ext)
343			strcat (p, ext);
344			return p;
345			}
346
347
348	twoaday	121	/* return 0 if the file @fname exists, otherwise >0. */
349	werner	36	int
350	twoaday	121	file_exist_check (const char *fname)
351	werner	36	{
352			struct stat st;
353			if (stat (fname, &st) == -1)
354			return WPTERR_FILE_EXIST;
355			return 0;
356			}
357
358
359			/* Check if the current folder exists.
360			Return 0 for success. */
361			int
362			dir_exist_check (const char *dir)
363			{
364			struct stat statbuf;
365
366	twoaday	105	if (stat (dir, &statbuf) == -1)
367	werner	36	return WPTERR_GENERAL;
368	twoaday	105	if (statbuf.st_mode & _S_IFDIR)
369	werner	36	return 0;
370			return WPTERR_GENERAL;
371			}
372
373
374	twoaday	77	/* Return the file size of the given file @fname. */
375			DWORD
376	werner	36	get_file_size (const char *fname)
377			{
378	twoaday	77	DWORD fsize;
379	werner	36	HANDLE fh;
380
381	twoaday	77	fh = CreateFile (fname, GENERIC_READ, FILE_SHARE_READ,
382			NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
383			if (fh == INVALID_HANDLE_VALUE)
384	werner	36	return 0;
385	twoaday	77	fsize = GetFileSize (fh, NULL);
386			if (fsize == 0xFFFFFFFF)
387	werner	36	fsize = 0;
388	twoaday	77	CloseHandle (fh);
389	werner	36	return fsize;
390	twoaday	77	}
391	werner	36
392
393			/* Start a dialog with the exception that before it is checked that the
394			dialog is not already openened. */
395			int
396	twoaday	105	dialog_box_param (HINSTANCE hinst, LPCTSTR name, HWND parent, DLGPROC fnc,
397			LPARAM param, LPCTSTR title, int title_id)
398	werner	36	{
399	twoaday	105	if (FindWindowEx (GetDesktopWindow (), NULL, NULL, title))
400	werner	36	return -1;
401	twoaday	105	return DialogBoxParam (hinst, name, parent, fnc, param);
402			}
403	werner	36
404
405			/* Wrapper for message box which forces the message box into the
406			foreground and it is displayed always on top. */
407			int
408			msg_box (HWND hwnd, const char text, const char title, int mode)
409			{
410			mode \|= MB_SETFOREGROUND;
411			mode \|= MB_TASKMODAL;
412			mode \|= MB_TOPMOST;
413			return MessageBox(hwnd, text, title, mode);
414			}
415
416
417	twoaday	121	/* Safe strdup version (C++ version). */
418	werner	36	char*
419			m_strdup (const char *str)
420			{
421	twoaday	121	char *p = new char[strlen (str) + 1];
422			if (!p)
423			BUG (NULL);
424			strcpy (p, str);
425	werner	36	return p;
426	twoaday	121	}
427	werner	36
428
429			/* Center the hwndChild relative to parent.
430			The style param allows to specificy additional styles (like topmost). */
431			void
432			center_window2 (HWND hwndChild, HWND parent, HWND style)
433			{
434			HWND hwndParent;
435			RECT rChild, rParent;
436			HDC hdc;
437			int wChild, hChild, wParent, hParent;
438			int wScreen, hScreen, xNew, yNew;
439			int flags = SWP_NOSIZE \| SWP_NOZORDER;
440
441			hwndParent = parent;
442			if (hwndParent == NULL)
443			hwndParent = GetDesktopWindow ();
444			GetWindowRect (hwndChild, &rChild);
445			wChild = rChild.right - rChild.left;
446			hChild = rChild.bottom - rChild.top;
447
448			GetWindowRect (hwndParent, &rParent);
449			wParent = rParent.right - rParent.left;
450			hParent = rParent.bottom - rParent.top;
451
452			hdc = GetDC (hwndChild);
453			wScreen = GetDeviceCaps (hdc, HORZRES);
454			hScreen = GetDeviceCaps (hdc, VERTRES);
455			ReleaseDC (hwndChild, hdc);
456			xNew = rParent.left + ((wParent - wChild) /2);
457			if (xNew < 0)
458			xNew = 0;
459			else if ((xNew+wChild) > wScreen)
460			xNew = wScreen - wChild;
461			yNew = rParent.top + ((hParent - hChild) /2);
462			if (yNew < 0)
463			yNew = 0;
464			else if ((yNew+hChild) > hScreen)
465			yNew = hScreen - hChild;
466			if (style == HWND_TOPMOST \|\| style == HWND_NOTOPMOST)
467			flags = SWP_NOMOVE \| SWP_NOSIZE;
468			SetWindowPos (hwndChild, style? style : NULL, xNew, yNew, 0, 0, flags);
469			}
470
471
472			/* Center the given hwndChild window with no special style. */
473			void
474			center_window (HWND hwndChild, HWND hwndParent)
475			{
476			center_window2 (hwndChild, hwndParent, NULL);
477			}
478	twoaday	121
479
480			/* Retrieve the product verion of the given file @fname.
481			Format: MAJOR.MINOR.PATCH1.PATCH2
482			Return value: 0 on success. */
483			int
484			get_file_version (const char fname, WORD major, WORD *minor,
485			WORD patch1, WORD patch2)
486			{
487			VS_FIXEDFILEINFO *inf = {0};
488			char file[MAX_PATH+1] = {0};
489			LPVOID buf, data;
490			DWORD arg;
491			DWORD size;
492			UINT qlen;
493
494			strncpy (file, fname, MAX_PATH);
495			size = GetFileVersionInfoSize (file, &arg);
496			if (!size)
497			return -1;
498			buf = (LPVOID)new CHAR[size];
499			if (!buf)
500			BUG (NULL);
501			GetFileVersionInfo (file, 0, size, buf);
502
503			qlen=0;
504			VerQueryValue (buf, "\\", &data, &qlen);
505			if (!qlen) {
506			delete [] (char*)buf;
507			return -1;
508			}
509			inf = (VS_FIXEDFILEINFO*)data;
510
511			if (major)
512			*major = HIWORD (inf->dwProductVersionMS);
513			if (minor)
514			*minor = LOWORD (inf->dwProductVersionMS);
515			if (patch1)
516			*patch1 = HIWORD (inf->dwProductVersionLS);
517			if (patch2)
518			*patch2 = LOWORD (inf->dwProductVersionLS);
519
520			delete [] (char*)buf;
521			return 0;
522			}
523
524
525	twoaday	129	/* Return date in a format which complies with the
526			system locale settings. */
527			const char*
528			get_locale_date (long tm_t, char *buf, DWORD buflen)
529			{
530			SYSTEMTIME st;
531			struct tm *ptm;
532	twoaday	121
533	twoaday	129	ptm = localtime (&tm_t);
534			st.wYear = (WORD)ptm->tm_year;
535			st.wMonth = (WORD)ptm->tm_mon;
536			st.wDay = (WORD)ptm->tm_mday;
537			st.wYear += 1900;
538			st.wMonth += 1;
539			if (!GetDateFormat (LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st,
540			NULL, buf, buflen))
541			return NULL;
542			return buf;
543			}
544	twoaday	121
545
546	twoaday	175	/* Generate a temporary file name by using the users
547			temp path and optionally a name @name provided by the caller.
548			Return value: 0 on success. */
549			int
550			get_temp_name (char buf, DWORD buflen, const char name)
551			{
552			char tmp[32];
553
554			if (!name) {
555			sprintf (tmp, "%08lX", GetTickCount ());
556			name = tmp;
557			}
558			if (!GetTempPath (buflen - strlen (name) -2, buf)) {
559			log_debug ("GetTempPath() failed ec=%d\n", (int)GetLastError ());
560			return -1;
561			}
562			strcat (buf, name);
563			return 0;
564			}
565
566
567	twoaday	129	struct reminder_hd_s {
568			int msecs;
569			HWND dlg;
570			HANDLE hd;
571			};
572	twoaday	121
573
574	twoaday	129	static DWORD CALLBACK
575			foreground_reminder_thread (void *c)
576			{
577			struct reminder_hd_s ctx = (struct reminder_hd_s )c;
578			Sleep (ctx->msecs);
579			SetForegroundWindow (ctx->dlg);
580			CloseHandle (ctx->hd);
581			delete ctx;
582			ExitThread (0);
583	twoaday	121	return 0;
584	twoaday	129	}
585	twoaday	121
586	twoaday	129	/* Try to force the window @dlg to the foreground.
587			On NT5 or later this will not work if the user
588			is working in another window (console for example). */
589			void
590			force_foreground_window (HWND dlg, int msecs)
591			{
592			struct reminder_hd_s *hd;
593			DWORD tid;
594	twoaday	121
595	twoaday	129	hd = new reminder_hd_s;
596			hd->dlg = dlg;
597			hd->msecs = msecs;
598			hd->hd = CreateThread (NULL, 0, foreground_reminder_thread,
599			hd, NULL, &tid);
600			}