/[winpt]/trunk/Src/wptW32API.cpp
ViewVC logotype

Diff of /trunk/Src/wptW32API.cpp

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 24 by twoaday, Sat Oct 8 10:43:08 2005 UTC revision 328 by twoaday, Fri Sep 25 16:07:38 2009 UTC
# Line 1  Line 1 
1  /* wptW32API.cpp - Common W32 API functions  /* wptW32API.cpp - Common W32 API functions
2   *      Copyright (C) 2001, 2002, 2003 Timo Schulz   *      Copyright (C) 2001-2003, 2005-2006, 2009 Timo Schulz
3   *   *
4   * This file is part of WinPT.   * This file is part of WinPT.
5   *   *
6   * WinPT is free software; you can redistribute it and/or modify   * 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   * 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   * the Free Software Foundation; either version 2 of the License, or
9   * (at your option) any later version.   * (at your option) any later version.
10   *   *
11   * WinPT is distributed in the hope that it will be useful,   * WinPT is distributed in the hope that it will be useful,
12   * but WITHOUT ANY WARRANTY; without even the implied warranty of   * but WITHOUT ANY WARRANTY; without even the implied warranty of
13   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14   * GNU General Public License for more details.   * GNU General Public License for more details.
15   *   */
16   * You should have received a copy of the GNU General Public License  #ifdef HAVE_CONFIG_H
17   * along with WinPT; if not, write to the Free Software Foundation,  #include <config.h>
18   * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA  #endif
19   */  
20    #include <windows.h>
21  #include <windows.h>  #include <stdio.h>
22  #include <stdio.h>  #include <sys/types.h>
23  #include <sys/types.h>  #include <sys/stat.h>
24  #include <sys/stat.h>  #include <shellapi.h>
25  #include <shellapi.h>  #include <shlobj.h>
26  #include <shlobj.h>  #include <commctrl.h>
27  #include <commctrl.h>  #include <time.h>
28    
29  #include "wptNLS.h"  #include "wptNLS.h"
30  #include "wptW32API.h"  #include "wptW32API.h"
31  #include "wptErrors.h"  #include "wptErrors.h"
32  #include "wptVersion.h"  #include "wptVersion.h"
33  #include "wptTypes.h"  #include "wptUTF8.h"
34    #include "wptTypes.h"
35    #include "StringBuffer.h"
36  extern "C" void _SHFree (void *p);  
37    
38  /* The the text of a menu item. */  extern "C" void _SHFree (void *p);
39  void  
40  set_menu_text (HMENU menu, int m_uid, const char *text)  
41  {  /* Insert a new item into the menu @hm at position @pos. */
42      MENUITEMINFO mii;  void
43      char menu_text[80];  insert_menu_item (HMENU hm, int pos, UINT m_id, const char *text)
44        {
45      memset (&mii, 0, sizeof (mii));      MENUITEMINFO mi;
46      mii.cbSize = sizeof (mii);  
47      mii.fMask = MIIM_TYPE;      memset (&mi, 0, sizeof mi);
48      mii.dwTypeData = menu_text;      mi.cbSize = sizeof mi;
49      mii.cch = sizeof (menu_text);      mi.fType = MF_STRING;
50      GetMenuItemInfo (menu, m_uid, FALSE, &mii);      mi.dwTypeData = (char *)text;
51            mi.cch = strlen (text);
52      memset (&mii, 0, sizeof mii);      mi.wID = m_id;
53      mii.cbSize = sizeof mii;      mi.fMask = MIIM_ID|MIIM_DATA| MIIM_TYPE;
54      mii.fMask = MIIM_TYPE;      InsertMenuItem (hm, pos, FALSE, &mi);
55      mii.fType = MFT_STRING;  }
56      mii.dwTypeData = (char *) text;  
57      SetMenuItemInfo (menu, m_uid, FALSE, &mii);  
58  } /* set_menu_text */  static void
59    set_menu_text_ext (HMENU menu, int by_pos, int m_uid, const char *text)
60    {
61  void      MENUITEMINFO mii;
62  set_menu_state (HMENU menu, int m_uid, int state)      
63  {            memset (&mii, 0, sizeof mii);
64      MENUITEMINFO mii;      mii.cbSize = sizeof mii;
65        mii.fMask = MIIM_TYPE;
66      memset( &mii, 0, sizeof (mii) );      mii.fType = MFT_STRING;
67      mii.cbSize = sizeof (mii);      mii.dwTypeData = (char *) text;
68      mii.fMask = MIIM_STATE;      SetMenuItemInfo (menu, m_uid, by_pos? TRUE : FALSE, &mii);
69      mii.fState = state;  }
70      SetMenuItemInfo (menu, m_uid, FALSE, &mii);  
71  } /* set_menu_state */  
72    /* Set the text of a menu item @m_uid to @text. */
73    void
74  /* Use the common dialog to request a file from the user.  set_menu_text (HMENU menu, UINT m_uid, const char *text)
75     id can be either FILE_OPEN or FILE_SAVE.  {
76     The return value is the file name or NULL if cancel was chosen. */      set_menu_text_ext (menu, 0, m_uid, text);
77  const char *  }
78  get_filename_dlg (HWND hwnd, int id, const char * title,  
79                    const char * filter, const char * name)  
80  {  /* Set the text of a menu item with the position @pos to @text. */
81      static char file[512] = "";  void
82      OPENFILENAME open;  set_menu_text_bypos (HMENU menu, UINT pos, const char *text)
83        {
84      if (name && strlen (name) < (sizeof (file)-1))      set_menu_text_ext (menu, 1, pos, text);
85          strcpy (file, name);  }
86      else  
87          memset (file, 0, sizeof (file));  
88      if (!filter)  /* Set the state of a menu item @m_uid to @state. */
89          filter = _("All Files (*.*)\0*.*\0\0");  void
90      memset (&open, 0, sizeof (open));  set_menu_state (HMENU menu, UINT m_uid, UINT state)
91      open.lStructSize = sizeof (OPENFILENAME);  {      
92      open.hInstance = glob_hinst;      MENUITEMINFO mii;
93      open.lpstrTitle = title;  
94      open.lpstrFilter = filter;      memset (&mii, 0, sizeof (mii));
95      open.hwndOwner = hwnd;      mii.cbSize = sizeof (mii);
96      open.lpstrFile = file;      mii.fMask = MIIM_STATE;
97      open.nMaxFile = sizeof (file) - 1;      mii.fState = state;
98      if (id == FILE_OPEN)      SetMenuItemInfo (menu, m_uid, FALSE, &mii);
99          open.Flags = OFN_FILEMUSTEXIST|OFN_PATHMUSTEXIST;  }
100      else  
101          open.Flags = OFN_OVERWRITEPROMPT;  
102    /* Retrieve the state of the menu item @m_uid and return it. */
103      if (id == FILE_OPEN && GetOpenFileName (&open))  UINT
104          return open.lpstrFile;  get_menu_state (HMENU menu, UINT m_uid)
105      else if (id == FILE_SAVE && GetSaveFileName (&open))  {
106          return open.lpstrFile;      MENUITEMINFO mii;
107        
108      return NULL;      memset (&mii, 0, sizeof (mii));
109  }      mii.cbSize = sizeof (mii);
110        mii.fMask = MIIM_STATE;
111  /* Use the common dialog to allow the user to select a folder.      GetMenuItemInfo (menu, m_uid, FALSE, &mii);
112     The return value is either the folder path or NULL if cancel was chosen. */      return mii.fState;
113  const char*  }
114  get_folder_dlg (HWND hwnd, const char * title, const char * name)  
115  {  
116      static char folder[MAX_PATH+1] = "";  enum {
117      BROWSEINFO bi;      CDLG_FILE_OPEN = 0,
118      ITEMIDLIST * il;      CDLG_FILE_SAVE = 1
119    };
120      memset (&bi, 0, sizeof (bi));  
121      bi.hwndOwner = hwnd;  /* Use the common dialog to request a file from the user.
122      if (title)     id can be either FILE_OPEN or FILE_SAVE.
123          bi.lpszTitle = title;     The return value is the file name or NULL if cancel was chosen. */
124      if (name && strlen (name) < MAX_PATH-1)  const char *
125          strcpy (folder, name);  get_filename_dlg (HWND hwnd, int id, const char *title,
126      else                    const char *filter, const char *name)
127          memset (folder, 0, sizeof (folder));  {
128      il = SHBrowseForFolder (&bi);      static char file[2*MAX_PATH+1] = "";
129      if (il) {      char _filter[512];
130          SHGetPathFromIDList (il, folder);      char workdir[MAX_PATH+1];
131          _SHFree (il);      char *sel_file = NULL;
132          return folder;      OPENFILENAME open;
133      }      
134      return NULL;      if (name && strlen (name) < (DIM (file)-1))
135  }          strcpy (file, name);
136        else
137            memset (file, 0, sizeof (file));
138  /* Return the clipboard contents as a string or NULL      if (!filter) {      
139     if the clipboard does not contain text. */          strcpy (_filter, _("All Files (*.*)"));
140  char*          memcpy (_filter+strlen (_filter)+1, "*.*\0\0", 5);
141  get_clip_text (HWND hwnd)          filter = _filter;
142  {      }
143      HANDLE clipmem;  
144      char *cliptxt, *p;        GetCurrentDirectory (MAX_PATH, workdir);
145      int len;      memset (&open, 0, sizeof (open));
146            open.lStructSize = sizeof (OPENFILENAME);
147      if (OpenClipboard (hwnd) == FALSE)      open.hInstance = glob_hinst;
148          return NULL;      open.lpstrTitle = title;
149      clipmem = GetClipboardData (CF_TEXT);      open.lpstrFilter = filter;
150      if (clipmem == NULL) {      open.hwndOwner = hwnd;
151          p = NULL;      open.lpstrFile = file;
152          goto leave;      open.nMaxFile = DIM (file) - 1;
153      }      if (id == CDLG_FILE_OPEN)
154      cliptxt = (char *) GlobalLock (clipmem);          open.Flags = OFN_FILEMUSTEXIST|OFN_PATHMUSTEXIST;
155      if (cliptxt == NULL) {      else
156          p = NULL;          open.Flags = OFN_OVERWRITEPROMPT;
157          goto leave;  
158      }      if (id == CDLG_FILE_OPEN && GetOpenFileName (&open))
159                sel_file = open.lpstrFile;
160      len =  strlen (cliptxt);      else if (id == CDLG_FILE_SAVE && GetSaveFileName (&open))
161      p = new char[len + 1];          sel_file = open.lpstrFile;
162      if (!p)      SetCurrentDirectory (workdir);
163          BUG (NULL);      
164      memcpy (p, cliptxt, len);      return sel_file;
165      p[len] = '\0';  }
166      GlobalUnlock (clipmem);  
167        const char*
168  leave:  get_filesave_dlg (HWND hwnd, const char *title,
169      CloseClipboard ();                    const char *filter, const char *name)
170      return p;  {
171  }      return get_filename_dlg (hwnd, CDLG_FILE_SAVE, title, filter, name);
172    }
173    
174  /* Set the the given text to the clipboard. */  const char*
175  int  get_fileopen_dlg (HWND hwnd, const char *title, const char *filter,
176  set_clip_text (HWND hwnd, const char *text, int nbytes)                    const char *name)
177  {      {
178      HANDLE clipmem;      return get_filename_dlg (hwnd, CDLG_FILE_OPEN, title, filter, name);
179      int rc = 0;  }
180      char *p;  
181        
182      if (OpenClipboard (hwnd) == FALSE)    /* Use the common dialog to allow the user to select a folder.
183          return WPTERR_CLIP_OPEN;     The return value is either the folder path or NULL if cancel was chosen. */
184      EmptyClipboard ();  const char*
185    get_folder_dlg (HWND hwnd, const char *title, const char *name)
186      clipmem = GlobalAlloc (GHND, nbytes + 1);  {
187      if (clipmem == NULL)      static char folder[2*MAX_PATH+1] = "";
188          BUG (NULL);      BROWSEINFO bi;
189      p = (char *) GlobalLock (clipmem);      ITEMIDLIST *il;
190      if (p == NULL) {  
191          rc = WPTERR_GENERAL;;      memset (&bi, 0, sizeof (bi));
192          goto leave;          bi.hwndOwner = hwnd;
193      }      if (title)
194      memcpy (p, text, nbytes);          bi.lpszTitle = title;
195      p[nbytes] = '\0';      if (name && strlen (name) < MAX_PATH-1)
196                strcpy (folder, name);
197      GlobalUnlock (clipmem);      else
198      SetClipboardData (CF_TEXT, clipmem);          memset (folder, 0, sizeof (folder));
199            il = SHBrowseForFolder (&bi);
200  leave:      if (il != NULL) {
201      CloseClipboard ();          SHGetPathFromIDList (il, folder);
202      return rc;          _SHFree (il);
203  } /* set_clip_text */          return folder;
204        }
205        return NULL;
206  /* Append or prepend some text to the clipboard contents.  }
207     If as_footer = 1, append the text otherwise prepend. */  
208  int  
209  set_clip_text2 (HWND hwnd, const char *text, int nbytes, int as_footer)  /* Return the clipboard contents as a string or NULL
210  {     if the clipboard does not contain text. */
211      char *p, *new_text;  char*
212    get_clip_text (HWND hwnd)
213      p = get_clip_text (hwnd);  {
214      if (!p)      HANDLE clipmem;
215          return WPTERR_CLIP_GET;      char *cliptxt, *p;  
216      new_text = new char [strlen (p)+strlen (text)+8];      int len;
217      if (!new_text)      
218          BUG (0);      if (OpenClipboard (hwnd) == FALSE)
219      if (as_footer == 0)          return NULL;
220          sprintf (new_text, "%s\r\n%s\r\n\r\n", text, p);      clipmem = GetClipboardData (CF_TEXT);
221      else      if (clipmem == NULL) {
222          sprintf (new_text, "%s\n%s\n\n", p, text);          p = NULL;
223      set_clip_text (hwnd, new_text, strlen (new_text)+1);          goto leave;
224      free_if_alloc (p);      }
225      free_if_alloc (new_text);      cliptxt = (char *) GlobalLock (clipmem);
226      return 0;      if (cliptxt == NULL) {
227  }          p = NULL;
228            goto leave;
229        }
230  /* Make a file name out of the path, the file and an extension. */      
231  char*      len =  strlen (cliptxt);
232  make_filename (const char *path, const char *file, const char *ext)      p = new char[len + 1];
233  {      if (!p)
234      char *p;          BUG (NULL);
235      size_t size = 0;      memcpy (p, cliptxt, len);
236        p[len] = '\0';
237      if( path && *path )      GlobalUnlock (clipmem);
238          size += strlen( path );      
239      if( file && *file )  leave:
240          size += strlen( file );      CloseClipboard ();
241      if( ext && *ext )      return p;
242          size += strlen( ext );  }
243      p = new char[size + 4];  
244      memset( p, 0, size );  
245      if( path ) {  /* Set @text as the new clipboard content. */
246          strcat( p, path );  int
247          if( path[strlen( path ) -1] != '\\' )  set_clip_text (HWND hwnd, const char *text, int nbytes)
248              strcat( p, "\\" );  {    
249      }      HANDLE clipmem;
250      if( file )      int rc = 0;
251          strcat( p, file );      char *p;
252      if( ext ) {      
253          strcat( p, "." );      if (OpenClipboard (hwnd) == FALSE)  
254          strcat( p, ext );          return WPTERR_CLIP_OPEN;
255      }      EmptyClipboard ();
256      return p;  
257  } /* make_filename */      clipmem = GlobalAlloc (GHND, nbytes + 1);
258        if (clipmem == NULL)
259            BUG (NULL);
260  /* return 0 if it exists, otherwise >0. */      p = (char *) GlobalLock (clipmem);
261  int      if (p == NULL) {
262  file_exist_check (const char * fname)          CloseClipboard ();
263  {          GlobalFree (clipmem);
264      struct stat st;          return WPTERR_GENERAL;
265      if (stat (fname, &st) == -1)      }
266          return WPTERR_FILE_EXIST;      memcpy (p, text, nbytes);
267      return 0;      p[nbytes] = '\0';
268  }      
269        SetClipboardData (CF_TEXT, clipmem);
270        GlobalUnlock (clipmem);
271  /* Check if the current folder exists.      CloseClipboard ();
272     Return 0 for success. */      GlobalFree (clipmem);
273  int      
274  dir_exist_check (const char *dir)      return rc;
275  {  }
276      struct stat statbuf;      
277        
278      if( stat( dir, &statbuf ) == -1 )  /* Append or prepend some text to the clipboard contents.
279          return WPTERR_GENERAL;     If as_footer = 1, append the text otherwise prepend. */
280      if( statbuf.st_mode & _S_IFDIR )  int
281          return 0;  set_clip_text2 (HWND hwnd, const char *text, int nbytes, int as_footer)
282      return WPTERR_GENERAL;  {
283  }      const char *fmt;
284        char *p, *new_text;
285    
286  /* Return the file size of the given file. */      p = get_clip_text (hwnd);
287  size_t      if (!p)
288  get_file_size (const char *fname)          return WPTERR_CLIP_GET;
289  {      if (as_footer == 0)
290      size_t fsize;          fmt = "%s\r\n%s\r\n\r\n";
291      HANDLE fh;      else
292            fmt = "%s\n%s\n\n";
293      fh = CreateFile( fname, GENERIC_READ, FILE_SHARE_READ,      new_text = new char [strlen (p)+strlen (text)+strlen (fmt)+2];
294                      NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );      if (!new_text)
295      if( fh == INVALID_HANDLE_VALUE )          BUG (0);
296          return 0;      if (as_footer == 0)
297      fsize = GetFileSize( fh, NULL );          sprintf (new_text, fmt, text, p);
298      if( fsize == 0xFFFFFFFF )      else
299          fsize = 0;          sprintf (new_text, fmt, p, text);
300      CloseHandle( fh );      set_clip_text (hwnd, new_text, strlen (new_text)+1);
301      return fsize;      free_if_alloc (p);
302  } /* get_file_size */      free_if_alloc (new_text);
303        return 0;
304    }
305  int  
306  init_file_lock( LOCK *ctx, const char *file )  
307  {  /* Make a file name out of the path @path, the file @file and
308           an extension. @ext.
309      ctx->size = get_file_size( file );     Return value: the full file name on success. */
310      ctx->file = m_strdup( file );  char*
311      ctx->fh = CreateFile( file, GENERIC_READ, FILE_SHARE_READ, NULL,  make_filename (const char *path, const char *file, const char *ext)
312                           OPEN_ALWAYS, 0, NULL );  {
313      if( ctx->fh == INVALID_HANDLE_VALUE )      char *p;
314          return WPTERR_GENERAL;      size_t size = 0;
315      if( LockFile( ctx->fh, 0, 0, ctx->size, 0 ) == FALSE ) {  
316          CloseHandle( ctx->fh );      if (path && *path)
317          ctx->fh = INVALID_HANDLE_VALUE;          size += strlen (path);
318          ctx->size = 0;      if (file && *file)
319          free( ctx->file );          size += strlen (file);
320          return WPTERR_GENERAL;      if (ext && *ext)
321      }          size += strlen (ext);
322      return 0;      p = new char[size + 4];
323  } /* init_file_lock */      if (!p)
324            BUG (0);
325        memset (p, 0, size);
326  void      if (path) {
327  release_file_lock( LOCK *ctx )          strcat (p, path);
328  {          if (path[strlen (path) -1] != '\\')
329      free_if_alloc( ctx->file );              strcat (p, "\\");
330      ctx->file = NULL;      }
331      ctx->size = 0;      if (file != NULL)
332      CloseHandle( ctx->fh );          strcat (p, file);
333  } /* release_file_lock */      if (ext != NULL) {
334            strcat (p, ".");
335            strcat (p, ext);
336  /* Start a dialog with the exception that before it is checked that the      }
337     dialog is not already openened. */      return p;
338  int  }
339  dialog_box_param( HINSTANCE hinst, LPCTSTR name, HWND parent, DLGPROC fnc,  
340                                    LPARAM param, LPCTSTR title, int title_id )  
341  {  /* Generates a file name from a special dirctory. */
342      #ifndef LANG_DE  char*
343      if( FindWindowEx( GetDesktopWindow(), NULL, NULL, title ) )  make_special_filename (int folder, const char *file, const char *ext)
344          return -1;        {
345      #else      BOOL ec;
346      char strdesc[256];      char path[MAX_PATH+1], *p;
347      LoadString( glob_hinst, title_id, strdesc, sizeof (strdesc) -1 );      size_t n=0;
348      if( FindWindowEx( GetDesktopWindow(), NULL, NULL, strdesc ) )  
349          return -1;      /* MSDN: buf must be at least MAX_PATH=256 bytes */
350      #endif      ec = SHGetSpecialFolderPath (HWND_DESKTOP, path, folder, TRUE);
351            if (ec != 1) {
352      return DialogBoxParam( hinst, name, parent, fnc, param );          log_debug ("SHGetSpecialFolderPath() failed\r\n", (int)GetLastError ());
353  } /* dialog_box_param */          return NULL;
354        }
355    
356  /* Wrapper for message box which forces the message box into the      n = strlen (path)+1;
357     foreground and it is displayed always on top. */      if (file)
358  int          n += strlen (file)+1;
359  msg_box (HWND hwnd, const char *text, const char *title, int mode)      if (ext)
360  {          n += strlen (ext)+1;
361      mode |= MB_SETFOREGROUND;      p = new char[n+2];
362      mode |= MB_TASKMODAL;      if (!p)
363      mode |= MB_TOPMOST;          BUG (0);
364      return MessageBox(hwnd, text, title, mode);      memset (p, 0, n+2);
365  }      strcpy (p, path);    
366        if (file) {
367            strcat (p, "\\");
368  void          strcat (p, file);
369  set_active_window( HWND dlg)      }
370  {            if (ext)
371      activ_hwnd = dlg;          strcat (p, ext);
372  } /* set_active_window */      return p;
373    }
374  void  
375  reset_active_window( void )  
376  {        /* return 0 if the file @fname exists, otherwise >0. */
377      activ_hwnd = NULL;  int
378  } /* reset_active_window */  file_exist_check (const char *fname)
379    {
380        struct stat st;
381  static DWORD CALLBACK      if (stat (fname, &st) == -1)
382  reminder_thread (void *ctx)          return WPTERR_FILE_EXIST;
383  {      return 0;
384      reminder_ctx_s *c = (reminder_ctx_s *)ctx;  }
385    
386      Sleep( c->msecs );  
387      SetForegroundWindow( activ_hwnd );  /* Check if the current folder exists.
388       Return 0 for success. */
389      return 0;  int
390  } /* reminder_thread */  dir_exist_check (const char *dir)
391    {
392        struct stat statbuf;    
393  HANDLE      
394  window_reminder( struct reminder_ctx_s *ctx )      if (stat (dir, &statbuf) == -1)
395  {          return WPTERR_GENERAL;
396      DWORD tid = 0;      if (statbuf.st_mode & _S_IFDIR)
397                return 0;
398      return CreateThread( NULL, 0, reminder_thread, ctx, 0, &tid );      return WPTERR_GENERAL;
399  } /* window_reminder */  }
400    
401    
402  char*  /* Return the file size of the given file @fname. */
403  m_strdup (const char *str)  DWORD
404  {  get_file_size (const char *fname)
405      char * p = new char[strlen (str) + 1];  {
406      if (p)      DWORD fsize;
407          strcpy (p, str);      HANDLE fh;
408      return p;  
409  } /* m_strdup */      fh = CreateFile (fname, GENERIC_READ, FILE_SHARE_READ,
410                         NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
411        if (fh == INVALID_HANDLE_VALUE)
412  /* Center the hwndChild relative to parent.          return 0;
413     The style param allows to specificy additional styles (like topmost). */      fsize = GetFileSize (fh, NULL);
414  void      if (fsize == 0xFFFFFFFF)
415  center_window2 (HWND hwndChild, HWND parent, HWND style)          fsize = 0;
416  {          CloseHandle (fh);
417      HWND hwndParent;      return fsize;
418      RECT rChild, rParent;      }
419      HDC hdc;  
420      int wChild, hChild, wParent, hParent;      
421      int wScreen, hScreen, xNew, yNew;  /* Start a dialog with the exception that before it is checked that the
422      int flags = SWP_NOSIZE | SWP_NOZORDER;     dialog is not already openened. */
423    int
424      hwndParent = parent;  dialog_box_param (HINSTANCE hinst, LPCTSTR name, HWND parent, DLGPROC fnc,
425      if (hwndParent == NULL)                    LPARAM param, LPCTSTR title, int title_id)
426          hwndParent = GetDesktopWindow ();  {
427      GetWindowRect (hwndChild, &rChild);          if (FindWindowEx (GetDesktopWindow (), NULL, NULL, title))
428      wChild = rChild.right - rChild.left;              return -1;
429      hChild = rChild.bottom - rChild.top;      return DialogBoxParam (hinst, name, parent, fnc, param);
430    }
431      GetWindowRect (hwndParent, &rParent);      
432      wParent = rParent.right - rParent.left;      
433      hParent = rParent.bottom - rParent.top;        /* Wrapper for message box which forces the message box into the
434           foreground and it is displayed always on top. */
435      hdc = GetDC (hwndChild);      int
436      wScreen = GetDeviceCaps (hdc, HORZRES);      msg_box (HWND hwnd, const char *text, const char *title, int mode)
437      hScreen = GetDeviceCaps (hdc, VERTRES);      {
438      ReleaseDC (hwndChild, hdc);            mode |= MB_SETFOREGROUND;
439      xNew = rParent.left + ((wParent - wChild) /2);          mode |= MB_TASKMODAL;
440      if (xNew < 0)      mode |= MB_TOPMOST;
441          xNew = 0;      return MessageBox(hwnd, text, title, mode);
442      else if ((xNew+wChild) > wScreen)  }
443          xNew = wScreen - wChild;  
444      yNew = rParent.top  + ((hParent - hChild) /2);  
445      if (yNew < 0)  /* Center the hwndChild relative to parent.
446          yNew = 0;     The style param allows to specificy additional styles (like topmost). */
447      else if ((yNew+hChild) > hScreen)  void
448          yNew = hScreen - hChild;  center_window2 (HWND hwndChild, HWND parent, HWND style)
449      if (style == HWND_TOPMOST || style == HWND_NOTOPMOST)  {    
450          flags = SWP_NOMOVE | SWP_NOSIZE;      HWND hwndParent;
451      SetWindowPos (hwndChild, style? style : NULL, xNew, yNew, 0, 0, flags);      RECT rChild, rParent;    
452  }      HDC hdc;
453        int wChild, hChild, wParent, hParent;    
454        int wScreen, hScreen, xNew, yNew;
455  /* Center the given hwndChild window with no special style. */      int flags = SWP_NOSIZE | SWP_NOZORDER;
456  void  
457  center_window (HWND hwndChild, HWND hwndParent)      hwndParent = parent;
458  {      if (hwndParent == NULL)
459      center_window2 (hwndChild, hwndParent, NULL);          hwndParent = GetDesktopWindow ();
460  }      GetWindowRect (hwndChild, &rChild);    
461        wChild = rChild.right - rChild.left;    
462        hChild = rChild.bottom - rChild.top;
463    
464        GetWindowRect (hwndParent, &rParent);    
465        wParent = rParent.right - rParent.left;    
466        hParent = rParent.bottom - rParent.top;      
467        
468        hdc = GetDC (hwndChild);    
469        wScreen = GetDeviceCaps (hdc, HORZRES);    
470        hScreen = GetDeviceCaps (hdc, VERTRES);    
471        ReleaseDC (hwndChild, hdc);      
472        xNew = rParent.left + ((wParent - wChild) /2);    
473        if (xNew < 0)
474            xNew = 0;
475        else if ((xNew+wChild) > wScreen)
476            xNew = wScreen - wChild;
477        yNew = rParent.top  + ((hParent - hChild) /2);
478        if (yNew < 0)
479            yNew = 0;
480        else if ((yNew+hChild) > hScreen)
481            yNew = hScreen - hChild;
482        if (style == HWND_TOPMOST || style == HWND_NOTOPMOST)
483            flags = SWP_NOMOVE | SWP_NOSIZE;
484        SetWindowPos (hwndChild, style? style : NULL, xNew, yNew, 0, 0, flags);
485    }
486    
487    
488    /* Center the given hwndChild window with no special style. */
489    void
490    center_window (HWND child, HWND parent)
491    {
492        center_window2 (child, parent, NULL);
493    }
494    
495    
496    /* Retrieve the product verion of the given file @fname.
497       Format: MAJOR.MINOR.PATCH1.PATCH2
498       Return value: 0 on success. */
499    int
500    get_file_version (const char *fname,
501                      WORD *major, WORD *minor, WORD *patch1, WORD *patch2)
502    {
503        VS_FIXEDFILEINFO *inf;
504        char file[MAX_PATH+1] = {0};
505        LPVOID buf, data;
506        DWORD arg;
507        DWORD size;
508        UINT qlen;
509    
510        strncpy (file, fname, MAX_PATH);
511        size = GetFileVersionInfoSize (file, &arg);
512        if (!size)
513            return -1;
514        buf = (LPVOID)new char[size];
515        if (!buf)
516            BUG (NULL);
517        GetFileVersionInfo (file, 0, size, buf);
518    
519        qlen=0;
520        VerQueryValue (buf, (char*)"\\", &data, &qlen);
521        if (!qlen) {
522            delete [](char*)buf;
523            return -1;
524        }
525        inf = (VS_FIXEDFILEINFO*)data;
526    
527        if (major)
528            *major = HIWORD (inf->dwProductVersionMS);
529        if (minor)
530            *minor = LOWORD (inf->dwProductVersionMS);
531        if (patch1)
532            *patch1 = HIWORD (inf->dwProductVersionLS);    
533        if (patch2)
534            *patch2 = LOWORD (inf->dwProductVersionLS);
535    
536        delete [](char*)buf;
537        return 0;
538    }
539    
540    
541    /* Return date in a format which complies with the
542       locale user settings. */
543    const char*
544    get_locale_date (long tm_t, char *buf, DWORD buflen)
545    {
546        SYSTEMTIME st;
547        struct tm *ptm;
548    
549        ptm = localtime (&tm_t);
550        memset (&st, 0, sizeof (st));
551        st.wYear = (WORD)ptm->tm_year+1900;
552        st.wMonth = (WORD)ptm->tm_mon+1;
553        st.wDay = (WORD)ptm->tm_mday;
554        if (!GetDateFormat (LOCALE_USER_DEFAULT, DATE_SHORTDATE, &st,
555                            NULL, buf, buflen))
556            return NULL;
557        return buf;
558    }
559    
560    /* Return the time in a format which complies with the locale user
561       settings. */
562    const char*
563    get_locale_time (long tm_t, char *buf, DWORD buflen)
564    {
565        SYSTEMTIME st;
566        struct tm *ptm;
567    
568        ptm = localtime (&tm_t);
569        memset (&st, 0, sizeof (st));
570        st.wMinute = (WORD)ptm->tm_min;
571        st.wHour = (WORD)ptm->tm_hour;
572        st.wSecond = (WORD)ptm->tm_sec;
573    
574        if (!GetTimeFormat (LOCALE_USER_DEFAULT, TIME_FORCE24HOURFORMAT, &st,
575                            NULL, buf, buflen))
576            return NULL;
577        return buf;
578    }
579    
580    
581    /* Return a combination of date+time which complies to the
582       local user settings. */
583    const char*
584    get_locale_timedate (long tm_t, char *buf, DWORD buflen)
585    {
586        DWORD nleft = buflen;
587    
588        if (!get_locale_date (tm_t, buf, buflen))
589            return NULL;
590        nleft -= strlen (buf)+1;
591        if (nleft < 1)
592            return NULL;
593        strcat (buf, " ");
594        nleft--;
595        if (!get_locale_time (tm_t, buf+strlen (buf), nleft))
596            return NULL;
597        return buf;
598    }
599    
600    
601    /* Generate a temporary file name by using the users
602       temp path and optionally a name @name provided by the caller.
603       Return value: 0 on success. */
604    int
605    get_temp_name (char *buf, DWORD buflen, const char *name)
606    {
607        char tmp[32];
608    
609        
610        if (!name) {
611            _snprintf (tmp, DIM (tmp)-1, "%08lX", GetTickCount ());
612            name = tmp;
613        }
614    
615        if (!GetTempPath (buflen - strlen (name) -2, buf)) {
616            log_debug ("GetTempPath() failed ec=%d\n", (int)GetLastError ());
617            return -1;
618        }
619    
620        strcat (buf, name);
621        return 0;
622    }
623    
624    
625    void
626    ListBox_AddString_utf8 (HWND lb, const char *txt)
627    {
628        char *utf8_txt;
629    
630        utf8_txt = utf8_to_native (txt);
631        SendMessage (lb, LB_ADDSTRING, 0, (LPARAM)(LPCSTR)(utf8_txt));
632        safe_free (utf8_txt);
633    }
634    
635    
636    void
637    ComboBox_AddString_utf8 (HWND cb, const char *txt)
638    {
639        char *utf8_txt;
640    
641        utf8_txt = utf8_to_native (txt);
642        SendMessage ((cb), CB_ADDSTRING, 0, (LPARAM)(LPCSTR)(utf8_txt));
643        safe_free (utf8_txt);
644    }
645    
646    
647    /* GetDlgItemText replacement with UTF8 support. */
648    int
649    GetDlgItemText_utf8 (HWND dlg, int id, char **r_txt)
650    {
651        int len = GetWindowTextLength (GetDlgItem (dlg, id));
652        char *txt;
653    
654        *r_txt = NULL;
655        if (len < 1)
656            return 0;
657        txt = new char[len+2];
658        if (!txt)
659            BUG (NULL);
660        GetDlgItemText (dlg, id, txt, len+1);
661        *r_txt = native_to_utf8 (txt);
662        free_if_alloc (txt);
663        return len;
664    }
665    
666    int
667    html_help_show (int map_id)
668    {
669        STARTUPINFO si;
670        PROCESS_INFORMATION pi;
671        SECURITY_ATTRIBUTES sec_attr;
672        char path[2*MAX_PATH+1];
673        
674        memset (&sec_attr, 0, sizeof (sec_attr));
675        memset (&si, 0, sizeof (si));
676        si.cb = sizeof (STARTUPINFO);
677        memset (&pi, 0, sizeof (pi));
678        //hh.exe -mapid 40 "winpt.$lang.chm"
679        
680        _snprintf (path, 2*MAX_PATH, "hh.exe -mapid %d winpt.%s.chm",
681                   map_id, gettext_get_langid ());
682        CreateProcess (NULL, path, &sec_attr, &sec_attr,
683                       FALSE, 0, NULL, NULL, &si, &pi);
684        CloseHandle (pi.hProcess);
685        CloseHandle (pi.hThread);
686        return 0;
687    }
688                      
689      
690    /* Return TRUE if the current user has admin privileges. */
691    BOOL
692    user_is_admin (void)
693    {
694        SID_IDENTIFIER_AUTHORITY SystemSidAuthority = SECURITY_NT_AUTHORITY;
695        HANDLE hd;
696        TOKEN_GROUPS  *ptg = NULL;
697        DWORD ngtoken;
698        DWORD i;
699        BOOL admin = FALSE;
700        PSID psid = 0;
701    
702        if (GetVersion () & 0x80000000) /* Win9X */
703            return TRUE;
704    
705        if (!OpenThreadToken (GetCurrentThread (), TOKEN_QUERY, FALSE, &hd) &&
706            !OpenProcessToken (GetCurrentProcess (), TOKEN_QUERY, &hd))
707            return FALSE;
708        
709        if (!GetTokenInformation (hd, TokenGroups, NULL, 0, &ngtoken) &&
710            GetLastError() == ERROR_INSUFFICIENT_BUFFER) {
711            ptg = (TOKEN_GROUPS*)GlobalAlloc (GPTR, ngtoken);
712            if (!ptg)
713                return FALSE;
714    
715            if (!GetTokenInformation (hd, TokenGroups,
716                                      ptg, ngtoken, &ngtoken)) {
717                GlobalFree (ptg);
718                return FALSE;
719            }
720            AllocateAndInitializeSid (&SystemSidAuthority,
721                                      2, SECURITY_BUILTIN_DOMAIN_RID,
722                                      DOMAIN_ALIAS_RID_ADMINS,
723                                      0, 0, 0, 0, 0, 0,
724                                      &psid);
725            for (i = 0; i < ptg->GroupCount; i++) {
726                if (EqualSid (ptg->Groups[i].Sid, psid)) {
727                    admin = TRUE;
728                    break;
729                }
730            }
731            FreeSid (psid);
732            GlobalFree (ptg);
733        }
734    
735        CloseHandle (hd);
736        return admin;
737    }
Legend:
Removed from v.24  
changed lines
  Added in v.328
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.26