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