]>
Commit | Line | Data |
---|---|---|
31860082 | 1 | --- svtools/util/makefile.mk.orig 2003-06-05 22:18:51.000000000 -0500 |
2 | +++ svtools/util/makefile.mk 2003-06-05 22:19:38.000000000 -0500 | |
3 | @@ -233,6 +233,10 @@ | |
4 | $(VOSLIB) \ | |
5 | $(SALLIB) | |
6 | ||
7 | +.IF "$(GUI)"=="UNX" | |
8 | +SHL2STDLIBS+= $(EXPATASCII3RDLIB) `pkg-config --libs glib-2.0` | |
9 | +.ENDIF | |
10 | + | |
11 | .IF "$(GUI)"=="WNT" | |
12 | SHL2STDLIBS+= \ | |
13 | uwinapi.lib \ | |
14 | --- svtools/source/config/makefile.mk.orig 2003-06-05 22:19:59.000000000 -0500 | |
15 | +++ svtools/source/config/makefile.mk 2003-06-05 22:21:02.000000000 -0500 | |
16 | @@ -107,7 +107,13 @@ | |
17 | $(SLO)$/accessibilityoptions.obj \ | |
18 | $(SLO)$/cmdoptions.obj \ | |
19 | $(SLO)$/extendedsecurityoptions.obj \ | |
20 | - $(SLO)$/sourceviewconfig.obj | |
21 | + $(SLO)$/sourceviewconfig.obj \ | |
22 | + $(SLO)$/recent-files.obj | |
23 | + | |
24 | +.IF "$(GUI)"=="UNX" | |
25 | +CFLAGS+=-Wall | |
26 | +CFLAGS+=`pkg-config --cflags glib-2.0` | |
27 | +.ENDIF | |
28 | ||
29 | EXCEPTIONSFILES = \ | |
30 | $(SLO)$/accelcfg.obj \ | |
31 | --- svtools/prj/build.lst.orig 2003-06-05 22:23:34.000000000 -0500 | |
32 | +++ svtools/prj/build.lst 2003-06-05 22:23:42.000000000 -0500 | |
33 | @@ -1,4 +1,4 @@ | |
34 | -st svtools : offuh toolkit ucbhelper unotools jpeg NULL | |
35 | +st svtools : offuh toolkit ucbhelper unotools jpeg expat NULL | |
36 | st svtools usr1 - all st_mkout NULL | |
37 | st svtools\inc get - all st_inc NULL | |
38 | st svtools\inc\sane get - all st_incsa NULL | |
39 | --- svtools/inc/historyoptions.hxx.orig 2003-06-05 22:25:11.000000000 -0500 | |
40 | +++ svtools/inc/historyoptions.hxx 2003-06-05 22:26:05.000000000 -0500 | |
41 | @@ -239,6 +239,7 @@ | |
42 | @param "eHistory" select right history. | |
43 | @param "sURL" URL to save in history | |
44 | @param "sFilter" filter name to save in history | |
45 | + @param "sMimeType" MIME type of the URL; used only for ePICKLIST. | |
46 | @param "sTitle" document title to save in history | |
47 | @param "sPassword" password to save in history | |
48 | @return - | |
49 | @@ -249,6 +250,7 @@ | |
50 | void AppendItem( EHistoryType eHistory , | |
51 | const ::rtl::OUString& sURL , | |
52 | const ::rtl::OUString& sFilter , | |
53 | + const ::rtl::OUString& sMimeType , | |
54 | const ::rtl::OUString& sTitle , | |
55 | const ::rtl::OUString& sPassword ); | |
56 | ||
57 | --- svtools/source/config/historyoptions.cxx.orig 2003-06-05 22:26:20.000000000 -0500 | |
58 | +++ svtools/source/config/historyoptions.cxx 2003-06-05 23:12:47.000000000 -0500 | |
59 | @@ -95,6 +95,8 @@ | |
60 | #include <algorithm> | |
61 | #endif | |
62 | ||
63 | +#include "recent-files.hxx" | |
64 | + | |
65 | //_________________________________________________________________________________________________________________ | |
66 | // namespaces | |
67 | //_________________________________________________________________________________________________________________ | |
68 | @@ -403,8 +405,10 @@ | |
69 | sal_uInt32 nPosition = FIXPROPERTYCOUNT; // step over first three readed size values! but count begins at 0! | |
70 | // Get names/values for picklist. | |
71 | // 4 subkeys for every item! | |
72 | + sal_uInt32 nItem; | |
73 | +#if 0 | |
74 | OUString sName; | |
75 | - for( sal_uInt32 nItem=0; nItem<nPicklistCount; ++nItem ) | |
76 | + for( nItem=0; nItem<nPicklistCount; ++nItem ) | |
77 | { | |
78 | seqValues[nPosition] >>= aItem.sURL ; | |
79 | ++nPosition; | |
80 | @@ -416,6 +420,26 @@ | |
81 | ++nPosition; | |
82 | m_aPicklist.push_back( aItem ); | |
83 | } | |
84 | +#endif | |
85 | + /* The user may already have a pick list from OOo, so we have to skip over it --- we now fetch the list from GNOME */ | |
86 | + nPosition += nPicklistCount * 4; | |
87 | + | |
88 | + ::svt::RecentFileItem *items; | |
89 | + int nItems; | |
90 | + int i; | |
91 | + | |
92 | + ::svt::recentFilesGetList (&items, &nItems); | |
93 | + | |
94 | + aItem.sFilter = OUString ("", 0, RTL_TEXTENCODING_ASCII_US); | |
95 | + aItem.sPassword = OUString ("", 0, RTL_TEXTENCODING_ASCII_US); | |
96 | + | |
97 | + for (i = 0; i < nItems; i++) { | |
98 | + aItem.sURL = OUString(items[i].uri); | |
99 | + aItem.sTitle = OUString (items[i].uri); /* We don't have a title, so just use the filename */ | |
100 | + m_aPicklist.push_back (aItem); | |
101 | + } | |
102 | + | |
103 | + ::svt::recentFilesFree (items, nItems); | |
104 | ||
105 | // Attention: Don't reset nPosition here! | |
106 | ||
107 | @@ -506,9 +530,11 @@ | |
108 | OUString sNode ; | |
109 | Sequence< PropertyValue > seqPropertyValues( 4 ) ; | |
110 | ||
111 | + sal_uInt32 nItem; | |
112 | +#if 0 | |
113 | // Copy picklist entries to save-list! | |
114 | sal_uInt32 nPicklistCount = m_aPicklist.size(); | |
115 | - for( sal_uInt32 nItem=0; nItem<nPicklistCount; ++nItem ) | |
116 | + for( nItem=0; nItem<nPicklistCount; ++nItem ) | |
117 | { | |
118 | aItem = m_aPicklist[nItem]; | |
119 | sNode = PROPERTYNAME_PICKLIST + PATHDELIMITER + FIXP + OUString::valueOf( (sal_Int32)nItem ) + PATHDELIMITER; | |
120 | @@ -523,7 +549,7 @@ | |
121 | ||
122 | SetSetProperties( PROPERTYNAME_PICKLIST, seqPropertyValues ); | |
123 | } | |
124 | - | |
125 | +#endif | |
126 | // Copy URL-list entries to save-list! | |
127 | sal_uInt32 nHistoryCount = m_aHistory.size(); | |
128 | for( nItem=0; nItem<nHistoryCount; ++nItem ) | |
129 | @@ -909,11 +935,16 @@ | |
130 | void SvtHistoryOptions::AppendItem( EHistoryType eHistory , | |
131 | const OUString& sURL , | |
132 | const OUString& sFilter , | |
133 | + const OUString& sMimeType , | |
134 | const OUString& sTitle , | |
135 | const OUString& sPassword ) | |
136 | { | |
137 | MutexGuard aGuard( GetOwnStaticMutex() ); | |
138 | - m_pDataContainer->AppendItem( eHistory, sURL, sFilter, sTitle, sPassword ); | |
139 | + | |
140 | + if (eHistory == ePICKLIST) | |
141 | + ::svt::recentFilesAddItem (sURL.pData, sMimeType.pData); | |
142 | + else | |
143 | + m_pDataContainer->AppendItem( eHistory, sURL, sFilter, sTitle, sPassword ); | |
144 | } | |
145 | ||
146 | //***************************************************************************************************************** | |
147 | --- sfx2/source/appl/newhelp.cxx.orig 2003-06-05 22:34:06.000000000 -0500 | |
148 | +++ sfx2/source/appl/newhelp.cxx 2003-06-05 22:35:03.000000000 -0500 | |
149 | @@ -1383,7 +1383,7 @@ | |
150 | { | |
151 | String aTitle = GetEntry(i); | |
152 | String* pURL = (String*)(ULONG)GetEntryData(i); | |
153 | - aHistOpt.AppendItem( eHELPBOOKMARKS, rtl::OUString( *pURL ), sEmpty, rtl::OUString( aTitle ), sEmpty ); | |
154 | + aHistOpt.AppendItem( eHELPBOOKMARKS, rtl::OUString( *pURL ), sEmpty, sEmpty, rtl::OUString( aTitle ), sEmpty ); | |
155 | delete pURL; | |
156 | } | |
157 | } | |
158 | --- sfx2/source/appl/sfxpicklist.cxx.orig 2003-04-11 10:54:18.000000000 -0500 | |
159 | +++ sfx2/source/appl/sfxpicklist.cxx 2003-06-05 22:46:10.000000000 -0500 | |
160 | @@ -461,6 +461,7 @@ | |
161 | SvtHistoryOptions().AppendItem( eHISTORY, | |
162 | aURL.GetURLNoPass( INetURLObject::NO_DECODE ), | |
163 | aFilter, | |
164 | + ::rtl::OUString(), | |
165 | aTitle, | |
166 | SfxStringEncode( aURL.GetPass() ) ); | |
167 | } | |
168 | @@ -497,17 +498,21 @@ | |
169 | ||
170 | ::rtl::OUString aTitle = pDocSh->GetTitle(SFX_TITLE_PICKLIST); | |
171 | ::rtl::OUString aFilter; | |
172 | + ::rtl::OUString aMimeType; | |
173 | ||
174 | INetURLObject aURL( pMed->GetOrigURL() ); | |
175 | const SfxFilter* pFilter = pMed->GetOrigFilter(); | |
176 | ||
177 | - if ( pFilter ) | |
178 | + if ( pFilter ) { | |
179 | aFilter = pFilter->GetFilterName(); | |
180 | + aMimeType = pFilter->GetMimeType(); | |
181 | + } | |
182 | ||
183 | // add to svtool history options | |
184 | SvtHistoryOptions().AppendItem( ePICKLIST, | |
185 | aURL.GetURLNoPass( INetURLObject::NO_DECODE ), | |
186 | aFilter, | |
187 | + aMimeType, | |
188 | aTitle, | |
189 | SfxStringEncode( aURL.GetPass() ) ); | |
190 | ||
191 | --- sd/source/ui/dlg/dlgass.cxx.orig 2003-06-05 23:00:04.000000000 -0500 | |
192 | +++ sd/source/ui/dlg/dlgass.cxx 2003-06-05 23:05:19.000000000 -0500 | |
193 | @@ -186,6 +186,12 @@ | |
194 | #include <sfx2/filedlghelper.hxx> | |
195 | #endif | |
196 | ||
197 | +#include <com/sun/star/system/XSystemShellExecute.hpp> | |
198 | +#include <com/sun/star/document/XTypeDetection.hpp> | |
199 | +#include <com/sun/star/util/URL.hpp> | |
200 | +#include <com/sun/star/util/XURLTransformer.hpp> | |
201 | +#include <sfx2/fcontnr.hxx> | |
202 | + | |
203 | #include "sdpage.hxx" | |
204 | #include "helpids.h" | |
205 | #include "assclass.hxx" | |
206 | @@ -198,6 +204,8 @@ | |
207 | ||
208 | using namespace ::com::sun::star; | |
209 | using namespace ::sd; | |
210 | +using namespace ::com::sun::star::uno; | |
211 | +using namespace ::com::sun::star::system; | |
212 | ||
213 | ||
214 | void InterpolateFixedBitmap( FixedBitmap * pBitmap ) | |
215 | @@ -774,7 +782,38 @@ | |
216 | m_pWindow = NULL; | |
217 | } | |
218 | ||
219 | +/* Queries the name of the filter that we can use to open a file */ | |
220 | +static const String & | |
221 | +getFilterNameForFile (rtl_uString *uri) | |
222 | +{ | |
223 | + Reference< ::com::sun::star::document::XTypeDetection > type_detection ( | |
224 | + ::comphelper::getProcessServiceFactory ()->createInstance ( | |
225 | + ::rtl::OUString::createFromAscii ("com.sun.star.comp.framework.TypeDetection" )), | |
226 | + UNO_QUERY ); | |
227 | ||
228 | + if (!type_detection.is()) | |
229 | + return; | |
230 | + | |
231 | + ::com::sun::star::util::URL url; | |
232 | + ::rtl::OUString type_name; | |
233 | + | |
234 | + url.Complete = uri; | |
235 | + | |
236 | + Reference < ::com::sun::star::util::XURLTransformer > trans ( | |
237 | + ::comphelper::getProcessServiceFactory ()->createInstance ( | |
238 | + ::rtl::OUString::createFromAscii ("com.sun.star.util.URLTransformer" )), | |
239 | + UNO_QUERY); | |
240 | + | |
241 | + trans->parseStrict (url); | |
242 | + | |
243 | + type_name = type_detection->queryTypeByURL (url.Main); | |
244 | + SfxFilterMatcher &filter_matcher = SFX_APP ()->GetFilterMatcher (); | |
245 | + const SfxFilter *filter = filter_matcher.GetFilter4EA (type_name); | |
246 | + if (!filter) | |
247 | + return String (); | |
248 | + | |
249 | + return filter->GetFilterName (); | |
250 | +} | |
251 | ||
252 | ||
253 | void AssistentDlgImpl::ScanDocmenu (void) | |
254 | @@ -808,6 +847,10 @@ | |
255 | else if (aPropertySet[nProperty].Name == HISTORY_PROPERTYNAME_PASSWORD) | |
256 | aPropertySet[nProperty].Value >>= sPassword; | |
257 | ||
258 | + sFilter = rtl::OUString (getFilterNameForFile (sURL.pData).GetBuffer ()); | |
259 | + if (sFilter.getLength () == 0) | |
260 | + continue; | |
261 | + | |
262 | // If the entry is an impress file then insert it into the | |
263 | // history list and the list box. | |
264 | uno::Any aFilterPropSet = xFilterFactory->getByName( sFilter ); | |
265 | --- svtools/source/config/recent-files.hxx 2003-01-30 04:24:37.000000000 -0600 | |
266 | +++ svtools/source/config/recent-files.hxx 2003-06-05 23:10:17.000000000 -0500 | |
267 | @@ -0,0 +1,30 @@ | |
268 | +#ifndef RECENT_FILES_HXX | |
269 | +#define RECENT_FILES_HXX | |
270 | + | |
271 | +#ifndef _RTL_USTRING_ | |
272 | +#include <rtl/ustring.h> | |
273 | +#endif | |
274 | + | |
275 | +#include <time.h> | |
276 | + | |
277 | +namespace svt { | |
278 | + | |
279 | +/* A recent file item */ | |
280 | +struct RecentFileItem { | |
281 | + rtl_uString *uri; /* URI of the file */ | |
282 | + rtl_uString *mimeType; /* MIME type */ | |
283 | + time_t timestamp; /* Timestamp for when the item was added */ | |
284 | +}; | |
285 | + | |
286 | +/* Queries the list of recent file items for OpenOffice.org */ | |
287 | +void recentFilesGetList (RecentFileItem **items, int *nItems); | |
288 | + | |
289 | +/* Frees an array of RecentFileItem structures */ | |
290 | +void recentFilesFree (RecentFileItem *items, int nItems); | |
291 | + | |
292 | +/* Adds an item to the list of recent file items */ | |
293 | +void recentFilesAddItem (rtl_uString *uri, const rtl_uString *mimeType); | |
294 | + | |
295 | +}; | |
296 | + | |
297 | +#endif | |
298 | --- svtools/source/config/recent-files.cxx 2003-01-30 04:24:37.000000000 -0600 | |
299 | +++ svtools/source/config/recent-files.cxx 2003-06-05 23:28:52.000000000 -0500 | |
300 | @@ -0,0 +1,802 @@ | |
301 | +#include <stdio.h> | |
302 | +#include <string.h> | |
303 | +#include <time.h> | |
304 | +#include <unistd.h> | |
305 | +#include <sys/file.h> | |
306 | +#include <glib.h> | |
307 | +#include <tools/string.hxx> | |
308 | +#include "expat/xmlparse.h" | |
309 | +#include "recent-files.hxx" | |
310 | + | |
311 | +namespace svt { | |
312 | + | |
313 | +/* | |
314 | + example: | |
315 | +<?xml version="1.0"?> | |
316 | +<RecentFiles> | |
317 | + <RecentItem> | |
318 | + <URI>file:///home/federico/gedit.txt</URI> | |
319 | + <Mime-Type>text/plain</Mime-Type> | |
320 | + <Timestamp>1046485966</Timestamp> | |
321 | + <Groups> | |
322 | + <Group>gedit</Group> | |
323 | + </Groups> | |
324 | + </RecentItem> | |
325 | + <RecentItem> | |
326 | + <URI>file:///home/federico/gedit-2.2.0.tar.bz2</URI> | |
327 | + <Mime-Type>application/x-bzip</Mime-Type> | |
328 | + <Timestamp>1046209851</Timestamp> | |
329 | + <Private/> | |
330 | + <Groups> | |
331 | + </Groups> | |
332 | + </RecentItem> | |
333 | +</RecentFiles> | |
334 | +*/ | |
335 | + | |
336 | +/* Name of the standard ~/.recently-used file */ | |
337 | +#define RECENT_FILE_NAME ".recently-used" | |
338 | + | |
339 | +/* Items without a MIME type get assigned this by default */ | |
340 | +#define APPLICATION_OCTET_STREAM "application/octet-stream" | |
341 | + | |
342 | +/* Buffer size for reading ~/.recently-used */ | |
343 | +#define BUFFER_SIZE 16384 | |
344 | + | |
345 | +/* Maximum number of entries to keep before pruning */ | |
346 | +#define MAX_ITEMS 20 | |
347 | + | |
348 | +/* The group we use for OO.o files */ | |
349 | +#define GROUP_OPENOFFICE_ORG "OpenOffice.org" | |
350 | + | |
351 | +/* Tags we understand in the ~/.recently-used XML */ | |
352 | +#define TAG_RECENT_FILES "RecentFiles" | |
353 | +#define TAG_RECENT_ITEM "RecentItem" | |
354 | +#define TAG_URI "URI" | |
355 | +#define TAG_MIME_TYPE "Mime-Type" | |
356 | +#define TAG_TIMESTAMP "Timestamp" | |
357 | +#define TAG_PRIVATE "Private" | |
358 | +#define TAG_GROUPS "Groups" | |
359 | +#define TAG_GROUP "Group" | |
360 | + | |
361 | +/* Recent item as parsed from the file */ | |
362 | +struct Item { | |
363 | + char *uri; | |
364 | + char *mimeType; | |
365 | + time_t timestamp; | |
366 | + gboolean isPrivate; | |
367 | + GSList *groups; | |
368 | +}; | |
369 | + | |
370 | +/* Parser state */ | |
371 | +enum State { | |
372 | + STATE_BEGIN, /* No elements read yet */ | |
373 | + STATE_RECENT_FILES, /* Inside the toplevel RecentFiles element */ | |
374 | + STATE_RECENT_ITEM, /* Inside RecentItem */ | |
375 | + STATE_URI, /* Inside URI */ | |
376 | + STATE_MIME_TYPE, /* Inside Mime-Type */ | |
377 | + STATE_TIMESTAMP, /* Inside Timestamp */ | |
378 | + STATE_PRIVATE, /* Inside Private */ | |
379 | + STATE_GROUPS, /* Inside Groups */ | |
380 | + STATE_GROUP, /* Inside Group */ | |
381 | + STATE_END, /* Finished parsing the toplevel element */ | |
382 | + STATE_ERROR /* Bad XML */ | |
383 | +}; | |
384 | + | |
385 | +/* XML parsing context */ | |
386 | +struct ParseContext { | |
387 | + GSList *items; | |
388 | + | |
389 | + State state; | |
390 | +}; | |
391 | + | |
392 | +/* Computes the name of the ~/.recent-files file */ | |
393 | +static char * | |
394 | +getRecentFilename (void) | |
395 | +{ | |
396 | + return g_strdup_printf ("%s/" RECENT_FILE_NAME, g_get_home_dir ()); | |
397 | +} | |
398 | + | |
399 | +/* Returns whether a string is null or empty */ | |
400 | +static gboolean | |
401 | +stringIsEmpty (const char *s) | |
402 | +{ | |
403 | + return (s == NULL || strlen (s) == 0); | |
404 | +} | |
405 | + | |
406 | +/* Frees the contents of str, if any, and g_strdup()s the newStr into it */ | |
407 | +static void | |
408 | +replaceString (char **str, const char *newStr, int newStrLen) | |
409 | +{ | |
410 | + g_free (*str); | |
411 | + *str = g_strndup (newStr, newStrLen); | |
412 | +} | |
413 | + | |
414 | +/* Creates a new item in the context as a result of entering a RecentItem element */ | |
415 | +static void | |
416 | +startRecentItem (ParseContext *context) | |
417 | +{ | |
418 | + Item *item; | |
419 | + | |
420 | + item = g_new (Item, 1); | |
421 | + | |
422 | + item->uri = NULL; | |
423 | + item->mimeType = NULL; | |
424 | + item->timestamp = -1; | |
425 | + item->isPrivate = FALSE; | |
426 | + item->groups = NULL; | |
427 | + | |
428 | + context->items = g_slist_prepend (context->items, item); | |
429 | +} | |
430 | + | |
431 | +/* Frees an Item */ | |
432 | +static void | |
433 | +freeItem (Item *item) | |
434 | +{ | |
435 | + GSList *l; | |
436 | + | |
437 | + g_free (item->uri); | |
438 | + g_free (item->mimeType); | |
439 | + | |
440 | + for (l = item->groups; l; l = l->next) { | |
441 | + char *group; | |
442 | + | |
443 | + group = l->data; | |
444 | + g_free (group); | |
445 | + } | |
446 | + g_slist_free (item->groups); | |
447 | + | |
448 | + g_free (item); | |
449 | +} | |
450 | + | |
451 | +/* Terminates a RecentItem element by ensuring that the basic properties of the | |
452 | + * current are fulfilled. If the URI is empty, removes the item from the | |
453 | + * context. | |
454 | + */ | |
455 | +static void | |
456 | +endRecentItem (ParseContext *context) | |
457 | +{ | |
458 | + Item *item; | |
459 | + GSList *listItem; | |
460 | + | |
461 | + g_assert (context->items != NULL); | |
462 | + item = context->items->data; | |
463 | + | |
464 | + if (stringIsEmpty (item->uri)) { | |
465 | + freeItem (item); | |
466 | + context->items = g_slist_delete_link (context->items, context->items); | |
467 | + return; | |
468 | + } | |
469 | + | |
470 | + if (stringIsEmpty (item->mimeType)) | |
471 | + replaceString (&item->mimeType, APPLICATION_OCTET_STREAM, strlen (APPLICATION_OCTET_STREAM)); | |
472 | + | |
473 | + if (item->timestamp == -1) | |
474 | + item->timestamp = time (NULL); | |
475 | +} | |
476 | + | |
477 | +/* Handles entering a Private element */ | |
478 | +static void | |
479 | +startPrivate (ParseContext *context) | |
480 | +{ | |
481 | + Item *item; | |
482 | + | |
483 | + g_assert (context->items != NULL); | |
484 | + item = context->items->data; | |
485 | + | |
486 | + item->isPrivate = TRUE; | |
487 | +} | |
488 | + | |
489 | +/* Start element handler for the parser */ | |
490 | +static void | |
491 | +startElementCb (void *data, const XML_Char *name, const XML_Char **attributes) | |
492 | +{ | |
493 | + ParseContext *context; | |
494 | + | |
495 | + context = data; | |
496 | + | |
497 | + if (context->state == STATE_ERROR || context->state == STATE_END) | |
498 | + return; | |
499 | + | |
500 | + switch (context->state) { | |
501 | + case STATE_BEGIN: | |
502 | + if (strcmp (name, TAG_RECENT_FILES) == 0) | |
503 | + context->state = STATE_RECENT_FILES; | |
504 | + else | |
505 | + context->state = STATE_ERROR; | |
506 | + break; | |
507 | + | |
508 | + case STATE_RECENT_FILES: | |
509 | + if (strcmp (name, TAG_RECENT_ITEM) == 0) { | |
510 | + startRecentItem (context); | |
511 | + context->state = STATE_RECENT_ITEM; | |
512 | + } else | |
513 | + context->state = STATE_ERROR; | |
514 | + break; | |
515 | + | |
516 | + case STATE_RECENT_ITEM: | |
517 | + if (strcmp (name, TAG_URI) == 0) | |
518 | + context->state = STATE_URI; | |
519 | + else if (strcmp (name, TAG_MIME_TYPE) == 0) | |
520 | + context->state = STATE_MIME_TYPE; | |
521 | + else if (strcmp (name, TAG_TIMESTAMP) == 0) | |
522 | + context->state = STATE_TIMESTAMP; | |
523 | + else if (strcmp (name, TAG_PRIVATE) == 0) { | |
524 | + startPrivate (context); | |
525 | + context->state = STATE_PRIVATE; | |
526 | + } else if (strcmp (name, TAG_GROUPS) == 0) | |
527 | + context->state = STATE_GROUPS; | |
528 | + else | |
529 | + context->state = STATE_ERROR; | |
530 | + break; | |
531 | + | |
532 | + case STATE_URI: | |
533 | + case STATE_MIME_TYPE: | |
534 | + case STATE_TIMESTAMP: | |
535 | + case STATE_PRIVATE: | |
536 | + case STATE_GROUP: | |
537 | + case STATE_END: | |
538 | + case STATE_ERROR: | |
539 | + context->state = STATE_ERROR; | |
540 | + break; | |
541 | + | |
542 | + case STATE_GROUPS: | |
543 | + if (strcmp (name, TAG_GROUP) == 0) | |
544 | + context->state = STATE_GROUP; | |
545 | + else | |
546 | + context->state = STATE_ERROR; | |
547 | + break; | |
548 | + | |
549 | + default: | |
550 | + g_assert_not_reached (); | |
551 | + } | |
552 | +} | |
553 | + | |
554 | +/* End element handler for the parser */ | |
555 | +static void | |
556 | +endElementCb (void *data, const XML_Char *name) | |
557 | +{ | |
558 | + ParseContext *context; | |
559 | + | |
560 | + context = data; | |
561 | + | |
562 | + switch (context->state) { | |
563 | + case STATE_RECENT_FILES: | |
564 | + if (strcmp (name, TAG_RECENT_FILES) == 0) | |
565 | + context->state = STATE_END; | |
566 | + else | |
567 | + context->state = STATE_ERROR; | |
568 | + break; | |
569 | + | |
570 | + case STATE_RECENT_ITEM: | |
571 | + if (strcmp (name, TAG_RECENT_ITEM) == 0) { | |
572 | + endRecentItem (context); | |
573 | + context->state = STATE_RECENT_FILES; | |
574 | + } else | |
575 | + context->state = STATE_ERROR; | |
576 | + break; | |
577 | + | |
578 | + case STATE_URI: | |
579 | + if (strcmp (name, TAG_URI) == 0) | |
580 | + context->state = STATE_RECENT_ITEM; | |
581 | + else | |
582 | + context->state = STATE_ERROR; | |
583 | + break; | |
584 | + | |
585 | + case STATE_MIME_TYPE: | |
586 | + if (strcmp (name, TAG_MIME_TYPE) == 0) | |
587 | + context->state = STATE_RECENT_ITEM; | |
588 | + else | |
589 | + context->state = STATE_ERROR; | |
590 | + break; | |
591 | + | |
592 | + case STATE_TIMESTAMP: | |
593 | + if (strcmp (name, TAG_TIMESTAMP) == 0) | |
594 | + context->state = STATE_RECENT_ITEM; | |
595 | + else | |
596 | + context->state = STATE_ERROR; | |
597 | + break; | |
598 | + | |
599 | + case STATE_PRIVATE: | |
600 | + if (strcmp (name, TAG_PRIVATE) == 0) { | |
601 | + startPrivate (context); /* I don't know if expat calls the start or end element handler for <foo/> */ | |
602 | + context->state = STATE_RECENT_ITEM; | |
603 | + } else | |
604 | + context->state = STATE_ERROR; | |
605 | + break; | |
606 | + | |
607 | + case STATE_GROUPS: | |
608 | + if (strcmp (name, TAG_GROUPS) == 0) | |
609 | + context->state = STATE_RECENT_ITEM; | |
610 | + else | |
611 | + context->state = STATE_ERROR; | |
612 | + break; | |
613 | + | |
614 | + case STATE_GROUP: | |
615 | + if (strcmp (name, TAG_GROUP) == 0) | |
616 | + context->state = STATE_GROUPS; | |
617 | + else | |
618 | + context->state = STATE_ERROR; | |
619 | + break; | |
620 | + | |
621 | + case STATE_BEGIN: | |
622 | + case STATE_END: | |
623 | + case STATE_ERROR: | |
624 | + context->state = STATE_ERROR; | |
625 | + break; | |
626 | + | |
627 | + default: | |
628 | + g_assert_not_reached (); | |
629 | + } | |
630 | +} | |
631 | + | |
632 | +/* Sets the timestamp field of an Item */ | |
633 | +static void | |
634 | +setTimestamp (Item *item, const char *s, int len) | |
635 | +{ | |
636 | + char *dup; | |
637 | + long t; | |
638 | + | |
639 | + dup = g_strndup (s, len); | |
640 | + if (sscanf (dup, "%ld", &t) != 1) | |
641 | + item->timestamp = -1; | |
642 | + else | |
643 | + item->timestamp = t; | |
644 | + | |
645 | + g_free (dup); | |
646 | +} | |
647 | + | |
648 | +/* Adds a group to an item */ | |
649 | +static void | |
650 | +addGroup (Item *item, const char *s, int len) | |
651 | +{ | |
652 | + GSList *l; | |
653 | + | |
654 | + for (l = item->groups; l; l = l->next) { | |
655 | + const char *group; | |
656 | + | |
657 | + group = l->data; | |
658 | + if (strncmp (group, s, len) == 0) | |
659 | + return; | |
660 | + } | |
661 | + | |
662 | + item->groups = g_slist_prepend (item->groups, g_strndup (s, len)); | |
663 | +} | |
664 | + | |
665 | +/* Handler for character data between tags */ | |
666 | +static void | |
667 | +characterDataCb (void *data, const XML_Char *s, int len) | |
668 | +{ | |
669 | + ParseContext *context; | |
670 | + Item *item; | |
671 | + | |
672 | + context = data; | |
673 | + item = context->items ? context->items->data : NULL; | |
674 | + | |
675 | + switch (context->state) { | |
676 | + case STATE_URI: | |
677 | + replaceString (&item->uri, s, len); | |
678 | + break; | |
679 | + | |
680 | + case STATE_MIME_TYPE: | |
681 | + replaceString (&item->mimeType, s, len); | |
682 | + break; | |
683 | + | |
684 | + case STATE_TIMESTAMP: | |
685 | + setTimestamp (item, s, len); | |
686 | + break; | |
687 | + | |
688 | + case STATE_GROUP: | |
689 | + addGroup (item, s, len); | |
690 | + break; | |
691 | + | |
692 | + case STATE_BEGIN: | |
693 | + case STATE_RECENT_FILES: | |
694 | + case STATE_RECENT_ITEM: | |
695 | + case STATE_PRIVATE: | |
696 | + case STATE_GROUPS: | |
697 | + case STATE_END: | |
698 | + case STATE_ERROR: | |
699 | + /* Ignore character data that may appear elsewhere */ | |
700 | + break; | |
701 | + | |
702 | + default: | |
703 | + g_assert_not_reached (); | |
704 | + } | |
705 | +} | |
706 | + | |
707 | +/* Creates an XML parser for .recent-files */ | |
708 | +static XML_Parser | |
709 | +createParser (ParseContext *context) | |
710 | +{ | |
711 | + XML_Parser parser; | |
712 | + | |
713 | + parser = XML_ParserCreate (NULL); | |
714 | + if (!parser) | |
715 | + return NULL; | |
716 | + | |
717 | + XML_SetUserData (parser, context); | |
718 | + XML_SetElementHandler (parser, startElementCb, endElementCb); | |
719 | + XML_SetCharacterDataHandler (parser, characterDataCb); | |
720 | + | |
721 | + return parser; | |
722 | +} | |
723 | + | |
724 | +/* Compares items by timestamps so as to sort them in DECREASING order */ | |
725 | +static gint | |
726 | +compareTimestampsCb (gconstpointer a, gconstpointer b, gpointer data) | |
727 | +{ | |
728 | + Item *ia, *ib; | |
729 | + time_t ta, tb; | |
730 | + | |
731 | + ia = a; | |
732 | + ta = ia->timestamp; | |
733 | + | |
734 | + ib = b; | |
735 | + tb = ib->timestamp; | |
736 | + | |
737 | + return (ta < tb) ? 1 : (ta > tb) ? -1 : 0; | |
738 | +} | |
739 | + | |
740 | +/* Returns whether an item has a certain group */ | |
741 | +static gboolean | |
742 | +hasGroup (Item *item, const char *group) | |
743 | +{ | |
744 | + GSList *l; | |
745 | + | |
746 | + for (l = item->groups; l; l = l->next) { | |
747 | + const char *g; | |
748 | + | |
749 | + g = l->data; | |
750 | + if (strcmp (g, group) == 0) | |
751 | + return TRUE; | |
752 | + } | |
753 | + | |
754 | + return FALSE; | |
755 | +} | |
756 | + | |
757 | +/* Removes the oldest items from the context */ | |
758 | +static void | |
759 | +trimOldItems (ParseContext *context) | |
760 | +{ | |
761 | + GSList *l, *next; | |
762 | + int i; | |
763 | + | |
764 | + i = 0; | |
765 | + l = context->items; | |
766 | + | |
767 | + while (l) { | |
768 | + Item *item; | |
769 | + | |
770 | + item = l->data; | |
771 | + next = l->next; | |
772 | + | |
773 | + if (hasGroup (item, GROUP_OPENOFFICE_ORG)) { | |
774 | + i++; | |
775 | + | |
776 | + if (i > MAX_ITEMS) { | |
777 | + freeItem (item); | |
778 | + context->items = g_slist_remove_link (context->items, l); | |
779 | + g_slist_free_1 (l); | |
780 | + } | |
781 | + } | |
782 | + | |
783 | + l = next; | |
784 | + } | |
785 | +} | |
786 | + | |
787 | +/* Parses the file and fills in the context */ | |
788 | +static void | |
789 | +parse (FILE *file, ParseContext *context) | |
790 | +{ | |
791 | + XML_Parser parser; | |
792 | + char buf[BUFFER_SIZE]; | |
793 | + | |
794 | + context->items = NULL; | |
795 | + context->state = STATE_BEGIN; | |
796 | + | |
797 | + parser = createParser (context); | |
798 | + | |
799 | + if (!parser) | |
800 | + return FALSE; | |
801 | + | |
802 | + while (1) { | |
803 | + int len; | |
804 | + gboolean eof; | |
805 | + | |
806 | + len = fread (buf, 1, sizeof (buf), file); | |
807 | + if (ferror (file)) | |
808 | + break; | |
809 | + | |
810 | + eof = feof (file); | |
811 | + | |
812 | + if (!XML_Parse (parser, buf, len, eof)) { | |
813 | + context->state = STATE_ERROR; | |
814 | + break; | |
815 | + } | |
816 | + | |
817 | + if (eof) | |
818 | + break; | |
819 | + } | |
820 | + | |
821 | + if (context->items) | |
822 | + endRecentItem (context); /* Finish it off for if we terminated prematurely on error */ | |
823 | + | |
824 | + XML_ParserFree (parser); | |
825 | + | |
826 | + context->items = g_slist_sort (context->items, compareTimestampsCb); | |
827 | + trimOldItems (context); | |
828 | +} | |
829 | + | |
830 | +/* Frees the contents of a parse context */ | |
831 | +static void | |
832 | +freeContext(ParseContext *context) | |
833 | +{ | |
834 | + GSList *l; | |
835 | + | |
836 | + for (l = context->items; l; l = l->next) { | |
837 | + Item *item; | |
838 | + | |
839 | + item = l->data; | |
840 | + freeItem (item); | |
841 | + } | |
842 | + | |
843 | + g_slist_free (context->items); | |
844 | +} | |
845 | + | |
846 | +/* Converts our items into exported structures */ | |
847 | +static void | |
848 | +convertItems (ParseContext *context, RecentFileItem **items, int *nItems) | |
849 | +{ | |
850 | + GSList *l; | |
851 | + int i; | |
852 | + | |
853 | + /* Count items with the OpenOffice.org group */ | |
854 | + | |
855 | + *nItems = 0; | |
856 | + for (l = context->items; l; l = l->next) { | |
857 | + Item *item; | |
858 | + | |
859 | + item = l->data; | |
860 | + if (hasGroup (item, GROUP_OPENOFFICE_ORG)) | |
861 | + (*nItems)++; | |
862 | + } | |
863 | + | |
864 | + if (*nItems == 0) | |
865 | + return; | |
866 | + | |
867 | + /* Add only the items we want */ | |
868 | + | |
869 | + *items = g_new (RecentFileItem, *nItems); | |
870 | + | |
871 | + i = 0; | |
872 | + | |
873 | + for (l = context->items; l; l = l->next) { | |
874 | + Item *item; | |
875 | + | |
876 | + item = l->data; | |
877 | + | |
878 | + if (hasGroup (item, GROUP_OPENOFFICE_ORG)) { | |
879 | + RecentFileItem *rfi; | |
880 | + | |
881 | + rfi = (*items) + i; | |
882 | + | |
883 | + rfi->uri = NULL; | |
884 | + rtl_string2UString (&rfi->uri, item->uri, strlen (item->uri), RTL_TEXTENCODING_UTF8, 0); | |
885 | + rfi->mimeType = NULL; | |
886 | + rtl_string2UString (&rfi->mimeType, item->mimeType, strlen (item->mimeType), RTL_TEXTENCODING_UTF8, 0); | |
887 | + | |
888 | + rfi->timestamp = item->timestamp; | |
889 | + | |
890 | + i++; | |
891 | + } | |
892 | + } | |
893 | +} | |
894 | + | |
895 | +/* Opens ~/.recent-files and locks it. If something fails, returns NULL. */ | |
896 | +static FILE * | |
897 | +openAndLock (void) | |
898 | +{ | |
899 | + char *filename; | |
900 | + FILE *file; | |
901 | + int fd; | |
902 | + ParseContext context; | |
903 | + | |
904 | + filename = getRecentFilename (); | |
905 | + | |
906 | + file = fopen (filename, "r+"); | |
907 | + g_free (filename); | |
908 | + | |
909 | + if (!file) | |
910 | + return NULL; | |
911 | + | |
912 | + fd = fileno (file); | |
913 | + if (lockf (fd, F_LOCK, 0) != 0) { | |
914 | + fclose (file); | |
915 | + return NULL; | |
916 | + } | |
917 | + | |
918 | + return file; | |
919 | +} | |
920 | + | |
921 | +/* Unlocks ~/.recent-files and closes it. */ | |
922 | +static void | |
923 | +unlockAndClose (FILE *file) | |
924 | +{ | |
925 | + int fd; | |
926 | + | |
927 | + fd = fileno (file); | |
928 | + lockf (fd, F_ULOCK, 0); | |
929 | + fclose (file); | |
930 | +} | |
931 | + | |
932 | + | |
933 | +/** | |
934 | + * recentFilesGetList: | |
935 | + * @items: Return value; pointer to an array of items. Should be freed with recentFilesFree(). | |
936 | + * @nItems: Return value; number of items returned. | |
937 | + * | |
938 | + * Queries the list of GNOME recent file items. | |
939 | + **/ | |
940 | +void | |
941 | +recentFilesGetList (RecentFileItem **items, int *nItems) | |
942 | +{ | |
943 | + FILE *file; | |
944 | + ParseContext context; | |
945 | + | |
946 | + *items = NULL; | |
947 | + *nItems = 0; | |
948 | + | |
949 | + file = openAndLock (); | |
950 | + if (!file) | |
951 | + return; | |
952 | + | |
953 | + parse (file, &context); | |
954 | + | |
955 | + unlockAndClose (file); | |
956 | + | |
957 | + convertItems (&context, items, nItems); | |
958 | + freeContext (&context); | |
959 | +} | |
960 | + | |
961 | +/* Writes the ~/.recent-files file */ | |
962 | +static void | |
963 | +writeXml (FILE *file, ParseContext *context) | |
964 | +{ | |
965 | + GSList *l; | |
966 | + | |
967 | + fputs ("<?xml version=\"1.0\"?>\n" | |
968 | + "<" TAG_RECENT_FILES ">\n", | |
969 | + file); | |
970 | + | |
971 | + for (l = context->items; l; l = l->next) { | |
972 | + Item *item; | |
973 | + GSList *gl; | |
974 | + | |
975 | + item = l->data; | |
976 | + | |
977 | + fputs (" <" TAG_RECENT_ITEM ">\n", file); | |
978 | + fprintf (file, | |
979 | + " <" TAG_URI ">%s</" TAG_URI ">\n" | |
980 | + " <" TAG_MIME_TYPE ">%s</" TAG_MIME_TYPE ">\n" | |
981 | + " <" TAG_TIMESTAMP ">%ld</" TAG_TIMESTAMP ">\n" | |
982 | + "%s" | |
983 | + " <" TAG_GROUPS ">\n", | |
984 | + item->uri, | |
985 | + item->mimeType, | |
986 | + (long) item->timestamp, | |
987 | + item->isPrivate ? " <" TAG_PRIVATE "/>\n" : ""); | |
988 | + | |
989 | + for (gl = item->groups; gl; gl = gl->next) { | |
990 | + const char *group; | |
991 | + | |
992 | + group = gl->data; | |
993 | + fprintf (file, | |
994 | + " <" TAG_GROUP ">%s</" TAG_GROUP ">\n", | |
995 | + group); | |
996 | + } | |
997 | + | |
998 | + fputs (" </" TAG_GROUPS ">\n" | |
999 | + " </" TAG_RECENT_ITEM ">\n", | |
1000 | + file); | |
1001 | + } | |
1002 | + | |
1003 | + fputs ("</" TAG_RECENT_FILES ">\n", file); | |
1004 | +} | |
1005 | + | |
1006 | +/** | |
1007 | + * recentFilesFree: | |
1008 | + * @items: Array of items. | |
1009 | + * @nItems: Number of items in the array. | |
1010 | + * | |
1011 | + * Frees an array of #RecentFileItem structures as returned by recentFilesGetList(). | |
1012 | + **/ | |
1013 | +void | |
1014 | +recentFilesFree (RecentFileItem *items, int nItems) | |
1015 | +{ | |
1016 | + int i; | |
1017 | + | |
1018 | + for (i = 0; i < nItems; i++) { | |
1019 | + rtl_uString_release (items[i].uri); | |
1020 | + rtl_uString_release (items[i].mimeType); | |
1021 | + } | |
1022 | + | |
1023 | + g_free (items); | |
1024 | +} | |
1025 | + | |
1026 | +/** | |
1027 | + * recentFilesAddItem: | |
1028 | + * @uri: URI to add. | |
1029 | + * @mimeType: MIME type of the item. | |
1030 | + * | |
1031 | + * Adds an item to GNOME's recent files list. Automatically adds the "OpenOffice.org" group. | |
1032 | + **/ | |
1033 | +void | |
1034 | +recentFilesAddItem (rtl_uString *uri, const rtl_uString *mimeType) | |
1035 | +{ | |
1036 | + FILE *file; | |
1037 | + ParseContext context; | |
1038 | + GSList *l; | |
1039 | + gboolean alreadyExists; | |
1040 | + int fd; | |
1041 | + rtl_String *uriString; | |
1042 | + rtl_String *mimeTypeString; | |
1043 | + | |
1044 | + file = openAndLock (); | |
1045 | + if (!file) | |
1046 | + return; | |
1047 | + | |
1048 | + parse (file, &context); | |
1049 | + | |
1050 | + alreadyExists = FALSE; | |
1051 | + | |
1052 | + uriString = NULL; | |
1053 | + mimeTypeString = NULL; | |
1054 | + rtl_uString2String (&uriString, uri->buffer, uri->length, RTL_TEXTENCODING_UTF8, 0); | |
1055 | + rtl_uString2String (&mimeTypeString, mimeType->buffer, mimeType->length, RTL_TEXTENCODING_UTF8, 0); | |
1056 | + | |
1057 | + for (l = context.items; l; l = l->next) { | |
1058 | + Item *item; | |
1059 | + | |
1060 | + item = l->data; | |
1061 | + if (strcmp (item->uri, uriString->buffer) == 0) { | |
1062 | + g_free (item->mimeType); | |
1063 | + item->mimeType = g_strdup (mimeTypeString->buffer); | |
1064 | + item->timestamp = time (NULL); | |
1065 | + alreadyExists = TRUE; | |
1066 | + break; | |
1067 | + } | |
1068 | + } | |
1069 | + | |
1070 | + if (!alreadyExists) { | |
1071 | + Item *item; | |
1072 | + | |
1073 | + item = g_new (Item, 1); | |
1074 | + item->uri = g_strdup (uriString->buffer); | |
1075 | + item->mimeType = g_strdup (mimeTypeString->buffer); | |
1076 | + item->timestamp = time (NULL); | |
1077 | + item->isPrivate = FALSE; | |
1078 | + item->groups = g_slist_prepend (NULL, g_strdup (GROUP_OPENOFFICE_ORG)); | |
1079 | + | |
1080 | + context.items = g_slist_prepend (context.items, item); | |
1081 | + } | |
1082 | + | |
1083 | + rtl_string_release (uriString); | |
1084 | + rtl_string_release (mimeTypeString); | |
1085 | + | |
1086 | + fd = fileno (file); | |
1087 | + | |
1088 | + /* FIXME: perhaps we should do a write to a temporary file, then do an atomic rename() */ | |
1089 | + | |
1090 | + rewind (file); | |
1091 | + if (ftruncate (fd, 0) != 0) | |
1092 | + goto out; | |
1093 | + | |
1094 | + writeXml (file, &context); | |
1095 | + | |
1096 | +out: | |
1097 | + | |
1098 | + unlockAndClose (file); | |
1099 | + freeContext (&context); | |
1100 | +} | |
1101 | + | |
1102 | +}; |