updated .c files to include:
[blender.git] / source / blender / blenlib / intern / winstuff.c
1 /**
2  * $Id$
3  *
4  * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
5  *
6  * This program is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU General Public License
8  * as published by the Free Software Foundation; either version 2
9  * of the License, or (at your option) any later version. The Blender
10  * Foundation also sells licenses for use in proprietary software under
11  * the Blender License.  See http://www.blender.org/BL/ for information
12  * about this.
13  *
14  * This program is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  * GNU General Public License for more details.
18  *
19  * You should have received a copy of the GNU General Public License
20  * along with this program; if not, write to the Free Software Foundation,
21  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22  *
23  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
24  * All rights reserved.
25  *
26  * The Original Code is: all of this file.
27  *
28  * Contributor(s): none yet.
29  *
30  * ***** END GPL/BL DUAL LICENSE BLOCK *****
31  * Windows-posix compatibility layer, windows-specific functions.
32  */
33
34 #ifdef HAVE_CONFIG_H
35 #include <config.h>
36 #endif
37
38 #ifdef WIN32
39
40 #include <stdlib.h>
41 #include <stdio.h>
42
43 #include "MEM_guardedalloc.h"
44
45 #include "BLI_blenlib.h"
46 #include "BLI_util.h"
47 #include "BLI_winstuff.h"
48
49
50 void RegisterBlendExtension(char * str) {
51         LONG lresult;
52         HKEY hkey = 0;
53         DWORD dwd = 0;
54         char buffer[128];
55
56         lresult = RegCreateKeyEx(HKEY_CLASSES_ROOT, "blendfile\\shell\\open\\command", 0,
57                 "", REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &dwd);
58
59         if (lresult == ERROR_SUCCESS) {
60                 sprintf(buffer, "\"%s\" \"%%1\"", str);
61                 lresult = RegSetValueEx(hkey, NULL, 0, REG_SZ, buffer, strlen(buffer) + 1);
62                 RegCloseKey(hkey);
63         }
64
65         lresult = RegCreateKeyEx(HKEY_CLASSES_ROOT, "blendfile\\DefaultIcon", 0,
66                 "", REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &dwd);
67
68         if (lresult == ERROR_SUCCESS) {
69                 sprintf(buffer, "\"%s\",1", str);
70                 lresult = RegSetValueEx(hkey, NULL, 0, REG_SZ, buffer, strlen(buffer) + 1);
71                 RegCloseKey(hkey);
72         }
73
74         lresult = RegCreateKeyEx(HKEY_CLASSES_ROOT, ".blend", 0,
75                 "", REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, &dwd);
76
77         if (lresult == ERROR_SUCCESS) {
78                 sprintf(buffer, "%s", "blendfile");
79                 lresult = RegSetValueEx(hkey, NULL, 0, REG_SZ, buffer, strlen(buffer) + 1);
80                 RegCloseKey(hkey);
81         }
82 }
83
84 static void strlower (char *str) {
85         while (*str) {
86                 *str= tolower(*str);
87                 str++;
88         }
89 }
90
91 static void strnlower (char *str, int n) {
92         while (n>0 && *str) {
93                 *str= tolower(*str);
94                 str++;
95                 n--;
96         }
97 }
98
99 int strcasecmp (char *s1, char *s2) {
100         char *st1, *st2;
101         int r;
102         
103         st1= MEM_mallocN(strlen(s1)+1, "temp string");
104         strcpy(st1, s1);
105
106         st2= MEM_mallocN(strlen(s2)+1, "temp string");
107         strcpy(st2, s2);
108
109         strlower(st1);
110         strlower(st2);
111         r= strcmp (st1, st2);
112         
113         MEM_freeN(st1);
114         MEM_freeN(st2);
115
116         return r;
117 }
118
119 int strncasecmp (char *s1, char *s2, int n) {
120         char *st1, *st2;
121         int r;
122         
123         st1= MEM_mallocN(n, "temp string");
124         memcpy(st1, s1, n);
125
126         st2= MEM_mallocN(n, "temp string");
127         memcpy(st2, s2, n);
128
129         strnlower(st1, n);
130         strnlower(st2, n);
131
132         r= strncmp (st1, st2, n);
133         
134         MEM_freeN(st1);
135         MEM_freeN(st2);
136
137         return r;       
138 }
139
140 DIR *opendir (const char *path) {
141         if (GetFileAttributes(path) & FILE_ATTRIBUTE_DIRECTORY) {
142                 DIR *newd= MEM_mallocN(sizeof(DIR), "opendir");
143
144                 newd->handle = INVALID_HANDLE_VALUE;
145                 sprintf(newd->path, "%s/*.*",path);
146                 
147                 newd->direntry.d_ino= 0;
148                 newd->direntry.d_off= 0;
149                 newd->direntry.d_reclen= 0;
150                 newd->direntry.d_name= NULL;
151                 
152                 return newd;
153         } else {
154                 return NULL;
155         }
156 }
157
158 struct dirent *readdir(DIR *dp) {
159         if (dp->direntry.d_name) {
160                 MEM_freeN(dp->direntry.d_name);
161                 dp->direntry.d_name= NULL;
162         }
163                 
164         if (dp->handle==INVALID_HANDLE_VALUE) {
165                 dp->handle= FindFirstFile(dp->path, &(dp->data));
166                 if (dp->handle==INVALID_HANDLE_VALUE)
167                         return NULL;
168                         
169                 dp->direntry.d_name= BLI_strdup(dp->data.cFileName);
170
171                 return &dp->direntry;
172         } else if (FindNextFile (dp->handle, &(dp->data))) {
173                 dp->direntry.d_name= BLI_strdup(dp->data.cFileName);
174
175                 return &dp->direntry;
176         } else {
177                 return NULL;
178         }
179 }
180
181 int closedir (DIR *dp) {
182         if (dp->direntry.d_name) MEM_freeN(dp->direntry.d_name);
183         if (dp->handle!=INVALID_HANDLE_VALUE) FindClose(dp->handle);
184
185         MEM_freeN(dp);
186         
187         return 0;
188 }
189
190 #else
191
192 void BLI_WINSTUFF_C_IS_EMPTY_FOR_UNIX(void) 
193 {
194   /*intentionally empty*/
195 }
196
197 #endif