Line data Source code
1 : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 : /*
3 : * This file is part of the LibreOffice project.
4 : *
5 : * This Source Code Form is subject to the terms of the Mozilla Public
6 : * License, v. 2.0. If a copy of the MPL was not distributed with this
7 : * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 : */
9 :
10 : #ifdef ENABLE_QUICKSTART_LIBPNG
11 :
12 : #include <X11/Xlib.h>
13 : #include <X11/Xatom.h>
14 : #include <X11/Xutil.h>
15 :
16 : #ifdef USE_XINERAMA
17 : #include <X11/extensions/Xinerama.h>
18 : #endif
19 :
20 : #include "osl/endian.h"
21 : #include <fcntl.h>
22 : #include <stdint.h>
23 : #include <stdio.h>
24 : #include <stdlib.h>
25 : #include <string.h>
26 : #include <unistd.h>
27 :
28 : #include <png.h>
29 :
30 : #include <osl/process.h>
31 : #include <osl/thread.h>
32 : #include <rtl/bootstrap.h>
33 : #include <rtl/ustrbuf.h>
34 :
35 : #include "splashx.h"
36 :
37 : typedef struct {
38 : unsigned char b, g, r;
39 : } color_t;
40 :
41 : struct splash
42 : {
43 : Display* display;
44 : int screen;
45 : int depth;
46 : Visual* visual;
47 :
48 : int width;
49 : int height;
50 :
51 : Colormap color_map;
52 : Window win;
53 : GC gc;
54 :
55 : // Progress bar values
56 : // taken from desktop/source/splash/splash.cxx
57 : int tlx;
58 : int tly;
59 : int barwidth;
60 : int barheight;
61 : int barspace;
62 : color_t barcol;
63 : color_t framecol;
64 :
65 : XColor barcolor;
66 : XColor framecolor;
67 :
68 : unsigned char** bitmap_rows;
69 : png_structp png_ptr;
70 : png_infop info_ptr;
71 :
72 : };
73 :
74 : #define WINDOW_WIDTH 440
75 : #define WINDOW_HEIGHT 299
76 :
77 : #define PROGRESS_XOFFSET 12
78 : #define PROGRESS_YOFFSET 18
79 : #define PROGRESS_BARSPACE 2
80 :
81 : /* libpng-1.2.41 */
82 : #ifndef PNG_TRANSFORM_GRAY_TO_RGB
83 : # define PNG_TRANSFORM_GRAY_TO_RGB 0x2000
84 : #endif
85 :
86 0 : static int splash_load_bmp( struct splash* splash, const char *filename )
87 : {
88 : FILE *file;
89 :
90 0 : if ( !(file = fopen( filename, "r" ) ) )
91 0 : return 0;
92 :
93 0 : splash->png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, 0, 0, 0 );
94 0 : splash->info_ptr = png_create_info_struct(splash->png_ptr);
95 0 : png_init_io( splash->png_ptr, file );
96 :
97 0 : if( setjmp( png_jmpbuf( splash->png_ptr ) ) )
98 : {
99 0 : png_destroy_read_struct( &(splash->png_ptr), &(splash->info_ptr), NULL );
100 0 : fclose( file );
101 0 : return 0;
102 : }
103 :
104 0 : png_read_png( splash->png_ptr, splash->info_ptr,
105 : PNG_TRANSFORM_EXPAND | PNG_TRANSFORM_STRIP_ALPHA |
106 : PNG_TRANSFORM_GRAY_TO_RGB | PNG_TRANSFORM_BGR, NULL);
107 :
108 0 : splash->bitmap_rows = png_get_rows( splash->png_ptr, splash->info_ptr );
109 0 : splash->width = png_get_image_width( splash->png_ptr, splash->info_ptr );
110 0 : splash->height = png_get_image_height( splash->png_ptr, splash->info_ptr );
111 :
112 0 : fclose( file );
113 0 : return 1;
114 : }
115 :
116 0 : static void setup_color( int val[3], color_t *col )
117 : {
118 0 : if ( val[0] < 0 || val[1] < 0 || val[2] < 0 )
119 0 : return;
120 :
121 : #define CONVERT_COLOR( from,to ) if ( from < 0 ) to = 0; else if ( from > 255 ) to = 255; else to = from;
122 0 : CONVERT_COLOR( val[0], col->r );
123 0 : CONVERT_COLOR( val[1], col->g );
124 0 : CONVERT_COLOR( val[2], col->b );
125 : #undef CONVERT_COLOR
126 : }
127 :
128 : /* Fill 'array' with values of the key 'name'.
129 : Its value is a comma delimited list of integers */
130 0 : static void get_bootstrap_value( int *array, int size, rtlBootstrapHandle handle, const char *name )
131 : {
132 0 : rtl_uString *pKey = NULL, *pValue = NULL;
133 :
134 : /* get the value from the ini file */
135 0 : rtl_uString_newFromAscii( &pKey, name );
136 0 : rtl_bootstrap_get_from_handle( handle, pKey, &pValue, NULL );
137 :
138 : /* the value is several numbers delimited by ',' - parse it */
139 0 : if ( rtl_uString_getLength( pValue ) > 0 )
140 : {
141 0 : rtl_uString *pToken = NULL;
142 0 : int i = 0;
143 0 : sal_Int32 nIndex = 0;
144 0 : for ( ; ( nIndex >= 0 ) && ( i < size ); ++i )
145 : {
146 0 : nIndex = rtl_uString_getToken( &pToken, pValue, 0, ',', nIndex );
147 0 : array[i] = rtl_ustr_toInt32( rtl_uString_getStr( pToken ), 10 );
148 : }
149 :
150 0 : rtl_uString_release( pToken );
151 : }
152 :
153 : /* cleanup */
154 0 : rtl_uString_release( pKey );
155 0 : rtl_uString_release( pValue );
156 0 : }
157 :
158 : // setup
159 0 : static void splash_setup( struct splash* splash, int barc[3], int framec[3], int posx, int posy, int w, int h )
160 : {
161 0 : if ( splash->width <= 500 )
162 : {
163 0 : splash->barwidth = splash->width - ( 2 * PROGRESS_XOFFSET );
164 0 : splash->barheight = 6;
165 0 : splash->tlx = PROGRESS_XOFFSET;
166 0 : splash->tly = splash->height - PROGRESS_YOFFSET;
167 :
168 0 : splash->barcol.r = 0;
169 0 : splash->barcol.g = 0;
170 0 : splash->barcol.b = 128;
171 : }
172 :
173 0 : if ( posx >= 0 )
174 0 : splash->tlx = posx;
175 0 : if ( posy >= 0 )
176 0 : splash->tly = posy;
177 0 : if ( w >= 0 )
178 0 : splash->barwidth = w;
179 0 : if ( h >= 0 )
180 0 : splash->barheight = h;
181 :
182 0 : setup_color( barc, &(splash->barcol) );
183 0 : setup_color( framec, &(splash->framecol) );
184 0 : }
185 :
186 : // Universal shift: bits >= 0 - left, otherwise right
187 : #define SHIFT( x, bits ) ( ( (bits) >= 0 )? ( (x) << (bits) ): ( (x) >> -(bits) ) )
188 :
189 : // Position of the highest bit (more or less integer log2)
190 0 : static inline int HIGHEST_BIT( unsigned long x )
191 : {
192 0 : int i = 0;
193 0 : for ( ; x; ++i )
194 0 : x >>= 1;
195 :
196 0 : return i;
197 : }
198 :
199 : // Number of bits set to 1
200 0 : static inline int BITS( unsigned long x )
201 : {
202 0 : int i = 0;
203 0 : for ( ; x; x >>= 1 )
204 0 : if ( x & 1UL )
205 0 : ++i;
206 :
207 0 : return i;
208 : }
209 :
210 : // Set 'bitmap' as the background of our 'win' window
211 0 : static void create_pixmap(struct splash* splash)
212 : {
213 : Pixmap pixmap;
214 : GC pixmap_gc;
215 0 : unsigned long value_mask = 0;
216 : XGCValues values;
217 :
218 0 : if ( !splash->bitmap_rows )
219 : {
220 0 : return;
221 : }
222 0 : pixmap = XCreatePixmap( splash->display, splash->win, splash->width, splash->height, splash->depth );
223 :
224 0 : pixmap_gc = XCreateGC( splash->display, pixmap, value_mask, &values );
225 :
226 0 : if ( splash->visual->class == TrueColor )
227 : {
228 0 : unsigned long red_mask = splash->visual->red_mask;
229 0 : unsigned long green_mask = splash->visual->green_mask;
230 0 : unsigned long blue_mask = splash->visual->blue_mask;
231 :
232 0 : unsigned long red_delta_mask = ( 1UL << ( 8 - BITS( red_mask ) ) ) - 1;
233 0 : unsigned long green_delta_mask = ( 1UL << ( 8 - BITS( green_mask ) ) ) - 1;
234 0 : unsigned long blue_delta_mask = ( 1UL << ( 8 - BITS( blue_mask ) ) ) - 1;
235 :
236 0 : int red_shift = HIGHEST_BIT( red_mask ) - 8;
237 0 : int green_shift = HIGHEST_BIT( green_mask ) - 8;
238 0 : int blue_shift = HIGHEST_BIT( blue_mask ) - 8;
239 :
240 0 : XImage* image = XCreateImage( splash->display, splash->visual, splash->depth, ZPixmap,
241 0 : 0, NULL, splash->width, splash->height, 32, 0 );
242 :
243 0 : int bytes_per_line = image->bytes_per_line;
244 0 : int bpp = image->bits_per_pixel;
245 0 : int byte_order = image->byte_order;
246 : #if defined( _LITTLE_ENDIAN )
247 0 : int machine_byte_order = LSBFirst;
248 : #elif defined( _BIG_ENDIAN )
249 : int machine_byte_order = MSBFirst;
250 : #else
251 : {
252 : fprintf( stderr, "Unsupported machine endianity.\n" );
253 : XFreeGC( splash->display, pixmap_gc );
254 : XFreePixmap( splash->display, pixmap );
255 : XDestroyImage( image );
256 : return;
257 : }
258 : #endif
259 :
260 0 : char *data = malloc( splash->height * bytes_per_line );
261 0 : char *out = data;
262 0 : image->data = data;
263 :
264 : // The following dithers & converts the color_t color to one
265 : // acceptable for the visual
266 : #define COPY_IN_OUT( pix_size, code ) \
267 : { \
268 : int x, y; \
269 : for ( y = 0; y < splash->height; ++y ) \
270 : { \
271 : unsigned long red_delta = 0, green_delta = 0, blue_delta = 0; \
272 : color_t *in = (color_t *)(splash->bitmap_rows[y]); \
273 : out = data + y * bytes_per_line; \
274 : for ( x = 0; x < splash->width; ++x, ++in ) \
275 : { \
276 : unsigned long red = in->r + red_delta; \
277 : unsigned long green = in->g + green_delta; \
278 : unsigned long blue = in->b + blue_delta; \
279 : unsigned long pixel = 0; \
280 : uint32_t tmp = 0; \
281 : (void) tmp; \
282 : red_delta = red & red_delta_mask; \
283 : green_delta = green & green_delta_mask; \
284 : blue_delta = blue & blue_delta_mask; \
285 : if ( red > 255 ) \
286 : red = 255; \
287 : if ( green > 255 ) \
288 : green = 255; \
289 : if ( blue > 255 ) \
290 : blue = 255; \
291 : pixel = \
292 : ( SHIFT( red, red_shift ) & red_mask ) | \
293 : ( SHIFT( green, green_shift ) & green_mask ) | \
294 : ( SHIFT( blue, blue_shift ) & blue_mask ); \
295 : code \
296 : } \
297 : } \
298 : }
299 :
300 0 : if ( bpp == 32 )
301 : {
302 0 : if ( machine_byte_order == byte_order )
303 0 : COPY_IN_OUT( 4, *( (uint32_t *)out ) = (uint32_t)pixel; out += 4; )
304 : else
305 0 : COPY_IN_OUT( 4, tmp = pixel;
306 : *( (uint8_t *)out ) = *( (uint8_t *)(&tmp) + 3 );
307 : *( (uint8_t *)out + 1 ) = *( (uint8_t *)(&tmp) + 2 );
308 : *( (uint8_t *)out + 2 ) = *( (uint8_t *)(&tmp) + 1 );
309 : *( (uint8_t *)out + 3 ) = *( (uint8_t *)(&tmp) );
310 : out += 4; )
311 : }
312 0 : else if ( bpp == 24 )
313 : {
314 0 : if ( machine_byte_order == byte_order && byte_order == LSBFirst )
315 0 : COPY_IN_OUT( 3, *( (color_t *)out ) = *( (color_t *)( &pixel ) ); out += 3; )
316 0 : else if ( machine_byte_order == byte_order && byte_order == MSBFirst )
317 0 : COPY_IN_OUT( 3, tmp = pixel;
318 : *( (uint8_t *)out ) = *( (uint8_t *)(&tmp) + 1 );
319 : *( (uint8_t *)out + 1 ) = *( (uint8_t *)(&tmp) + 2 );
320 : *( (uint8_t *)out + 2 ) = *( (uint8_t *)(&tmp) + 3 );
321 : out += 3; )
322 : else
323 0 : COPY_IN_OUT( 3, tmp = pixel;
324 : *( (uint8_t *)out ) = *( (uint8_t *)(&tmp) + 3 );
325 : *( (uint8_t *)out + 1 ) = *( (uint8_t *)(&tmp) + 2 );
326 : *( (uint8_t *)out + 2 ) = *( (uint8_t *)(&tmp) + 1 );
327 : out += 3; )
328 : }
329 0 : else if ( bpp == 16 )
330 : {
331 0 : if ( machine_byte_order == byte_order )
332 0 : COPY_IN_OUT( 2, *( (uint16_t *)out ) = (uint16_t)pixel; out += 2; )
333 : else
334 0 : COPY_IN_OUT( 2, tmp = pixel;
335 : *( (uint8_t *)out ) = *( (uint8_t *)(&tmp) + 1 );
336 : *( (uint8_t *)out + 1 ) = *( (uint8_t *)(&tmp) );
337 : out += 2; );
338 : }
339 0 : else if ( bpp == 8 )
340 : {
341 0 : COPY_IN_OUT( 1, *( (uint8_t *)out ) = (uint8_t)pixel; ++out; )
342 : }
343 : else
344 : {
345 0 : fprintf( stderr, "Unsupported depth: %d bits per pixel.\n", bpp );
346 0 : XFreeGC( splash->display, pixmap_gc );
347 0 : XFreePixmap( splash->display, pixmap );
348 0 : XDestroyImage( image );
349 0 : return;
350 : }
351 :
352 : #undef COPY_IN_OUT
353 :
354 0 : XPutImage( splash->display, pixmap, pixmap_gc, image, 0, 0, 0, 0, splash->width, splash->height );
355 0 : XDestroyImage( image );
356 : }
357 : else //if ( depth == 1 || visual->class == DirectColor )
358 : {
359 : // FIXME Something like the following, but faster ;-) - XDrawPoint is not
360 : // a good idea...
361 : int x, y;
362 0 : for ( y = 0; y < splash->height; ++y )
363 : {
364 0 : color_t* color = (color_t *)&(splash->bitmap_rows[y]);
365 :
366 0 : int delta = 0;
367 0 : for ( x = 0; x < splash->width; ++x, ++color )
368 : {
369 0 : int rnd = (int)( ( (long)( random() - RAND_MAX/2 ) * 32000 )/RAND_MAX );
370 0 : int luminance = delta + rnd + 299 * (int)color->r + 587 * (int)color->g + 114 * (int)color->b;
371 :
372 0 : if ( luminance < 128000 )
373 : {
374 0 : XSetForeground( splash->display, pixmap_gc, BlackPixel( splash->display, splash->screen ) );
375 0 : delta = luminance;
376 : }
377 : else
378 : {
379 0 : XSetForeground( splash->display, pixmap_gc, WhitePixel( splash->display, splash->screen ) );
380 0 : delta = luminance - 255000;
381 : }
382 :
383 0 : XDrawPoint( splash->display, pixmap, pixmap_gc, x, y );
384 : }
385 : }
386 : }
387 :
388 0 : XSetWindowBackgroundPixmap( splash->display, splash->win, pixmap );
389 :
390 0 : XFreeGC( splash->display, pixmap_gc );
391 0 : XFreePixmap( splash->display, pixmap );
392 : }
393 :
394 : // The old method of hiding the window decorations
395 0 : static void suppress_decorations_motif(struct splash* splash)
396 : {
397 : struct
398 : {
399 : unsigned long flags, functions, decorations;
400 : long input_mode;
401 : } mwmhints;
402 :
403 0 : Atom a = XInternAtom( splash->display, "_MOTIF_WM_HINTS", False );
404 :
405 0 : mwmhints.flags = 15; // functions, decorations, input_mode, status
406 0 : mwmhints.functions = 2; // ?
407 0 : mwmhints.decorations = 0;
408 0 : mwmhints.input_mode = 0;
409 :
410 0 : XChangeProperty( splash->display, splash->win, a, a, 32,
411 : PropModeReplace, (unsigned char*)&mwmhints, 5 );
412 0 : }
413 :
414 : // This is a splash, set it as such.
415 : // If it fails, just hide the decorations...
416 0 : static void suppress_decorations(struct splash* splash)
417 : {
418 0 : Atom atom_type = XInternAtom( splash->display, "_NET_WM_WINDOW_TYPE", True );
419 0 : Atom atom_splash = XInternAtom( splash->display, "_NET_WM_WINDOW_TYPE_SPLASH", True );
420 :
421 0 : if ( atom_type != None && atom_splash != None )
422 0 : XChangeProperty( splash->display, splash->win, atom_type, XA_ATOM, 32,
423 : PropModeReplace, (unsigned char*)&atom_splash, 1 );
424 : //else
425 0 : suppress_decorations_motif(splash); // FIXME: Unconditional until Metacity/compiz's SPLASH handling is fixed
426 0 : }
427 :
428 : /**
429 : * Create the window for the splash screen
430 : *
431 : * @return Success: 1; Failure: 0
432 : */
433 0 : static int splash_create_window( struct splash* splash, int argc, char** argv )
434 : {
435 0 : char *display_name = NULL;
436 : int i;
437 : Window root_win;
438 0 : int display_width = 0;
439 0 : int display_height = 0;
440 0 : int display_x_pos = 0;
441 0 : int display_y_pos = 0;
442 0 : unsigned long value_mask = 0;
443 : XGCValues values;
444 0 : const char* name = "LibreOffice";
445 0 : const char* icon = "icon"; // FIXME
446 : XSizeHints size_hints;
447 : #ifdef USE_XINERAMA
448 0 : int n_xinerama_screens = 1;
449 0 : XineramaScreenInfo* p_screens = NULL;
450 : #endif
451 :
452 0 : for ( i = 0; i < argc; i++ )
453 : {
454 0 : if ( !strcmp( argv[i], "-display" ) || !strcmp( argv[i], "--display" ) )
455 : {
456 0 : display_name = ( i + 1 < argc )? argv[i+1]: NULL;
457 : }
458 : }
459 :
460 0 : if ( !display_name )
461 : {
462 0 : display_name = getenv( "DISPLAY" );
463 : }
464 : // init display
465 0 : splash->display = XOpenDisplay( display_name );
466 0 : if ( !splash->display )
467 : {
468 0 : fprintf( stderr, "Failed to open display\n" );
469 0 : return 0;
470 : }
471 :
472 : // create the window
473 0 : splash->screen = DefaultScreen( splash->display );
474 0 : splash->depth = DefaultDepth( splash->display, splash->screen );
475 0 : splash->color_map = DefaultColormap( splash->display, splash->screen );
476 0 : splash->visual = DefaultVisual( splash->display, splash->screen );
477 :
478 0 : root_win = RootWindow( splash->display, splash->screen );
479 0 : display_width = DisplayWidth( splash->display, splash->screen );
480 0 : display_height = DisplayHeight( splash->display, splash->screen );
481 :
482 : #ifdef USE_XINERAMA
483 0 : p_screens = XineramaQueryScreens( splash->display, &n_xinerama_screens );
484 0 : if( p_screens )
485 : {
486 0 : for( i=0; i < n_xinerama_screens; i++ )
487 : {
488 0 : if ( p_screens[i].screen_number == splash->screen )
489 : {
490 0 : display_width = p_screens[i].width;
491 0 : display_height = p_screens[i].height;
492 0 : display_x_pos = p_screens[i].x_org;
493 0 : display_y_pos = p_screens[i].y_org;
494 0 : break;
495 : }
496 : }
497 0 : XFree( p_screens );
498 : }
499 : #endif
500 :
501 0 : splash->win = XCreateSimpleWindow( splash->display, root_win,
502 0 : (display_x_pos + (display_width - splash->width)/2),
503 0 : (display_y_pos + (display_height - splash->height)/2),
504 0 : splash->width, splash->height, 0,
505 0 : BlackPixel( splash->display, splash->screen ), BlackPixel( splash->display, splash->screen ) );
506 :
507 0 : XSetWindowColormap( splash->display, splash->win, splash->color_map );
508 :
509 : // setup colors
510 : #define FILL_COLOR( xcol,col ) xcol.red = 256*col.r; xcol.green = 256*col.g; xcol.blue = 256*col.b;
511 0 : FILL_COLOR( splash->barcolor, splash->barcol );
512 0 : FILL_COLOR( splash->framecolor, splash->framecol );
513 : #undef FILL_COLOR
514 :
515 0 : XAllocColor( splash->display, splash->color_map, &(splash->barcolor) );
516 0 : XAllocColor( splash->display, splash->color_map, &(splash->framecolor) );
517 :
518 : // not resizable, no decorations, etc.
519 0 : splash->gc = XCreateGC( splash->display, splash->win, value_mask, &values );
520 :
521 0 : size_hints.flags = PPosition | PSize | PMinSize | PMaxSize;
522 0 : size_hints.min_width = splash->width;
523 0 : size_hints.max_width = splash->width;
524 0 : size_hints.min_height = splash->height;
525 0 : size_hints.max_height = splash->height;
526 :
527 0 : XSetStandardProperties( splash->display, splash->win, name, icon, None,
528 : 0, 0, &size_hints );
529 :
530 : // the actual work
531 0 : suppress_decorations(splash);
532 0 : create_pixmap(splash);
533 :
534 : // show it
535 0 : XSelectInput( splash->display, splash->win, 0 );
536 0 : XMapWindow( splash->display, splash->win );
537 :
538 0 : return 1;
539 : }
540 :
541 : // Re-draw & process the events
542 : // Just throwing them away - we do not need anything more...
543 0 : static void process_events(struct splash* splash)
544 : {
545 : XEvent xev;
546 : int num_events;
547 :
548 0 : XFlush( splash->display );
549 0 : num_events = XPending( splash->display );
550 0 : while ( num_events > 0 )
551 : {
552 0 : num_events--;
553 0 : XNextEvent( splash->display, &xev );
554 : }
555 0 : }
556 :
557 :
558 0 : static rtl_String* ustr_to_str( rtl_uString* pStr )
559 : {
560 0 : rtl_String *pOut = NULL;
561 :
562 0 : rtl_uString2String( &pOut, rtl_uString_getStr( pStr ),
563 0 : rtl_uString_getLength( pStr ), osl_getThreadTextEncoding(), OUSTRING_TO_OSTRING_CVTFLAGS );
564 :
565 0 : return pOut;
566 : }
567 :
568 : #define IMG_SUFFIX ".png"
569 :
570 0 : static void splash_load_image( struct splash* splash, rtl_uString* pUAppPath )
571 : {
572 : /* FIXME-BCP47: if we wanted to support language tags here that would get
573 : * complicated, this is C-source not C++ so LanguageTag can't be used. For
574 : * now the splash screen will have to get along with language-territory. */
575 :
576 : char *pBuffer, *pSuffix, *pLocale;
577 : int nLocSize;
578 0 : rtl_Locale *pLoc = NULL;
579 : rtl_String *pLang, *pCountry, *pAppPath;
580 :
581 0 : osl_getProcessLocale (&pLoc);
582 0 : pLang = ustr_to_str (pLoc->Language);
583 0 : pCountry = ustr_to_str (pLoc->Country);
584 :
585 0 : nLocSize = strlen (pLang->buffer) + strlen (pCountry->buffer) + 8;
586 0 : pLocale = malloc (nLocSize);
587 0 : pLocale[0] = '-';
588 0 : strcpy (pLocale + 1, pLang->buffer);
589 0 : strcat (pLocale, "_");
590 0 : strcat (pLocale, pCountry->buffer);
591 :
592 0 : rtl_string_release( pCountry );
593 0 : rtl_string_release( pLang );
594 :
595 0 : pAppPath = ustr_to_str (pUAppPath);
596 0 : pBuffer = malloc (pAppPath->length + nLocSize + 256);
597 0 : strcpy (pBuffer, pAppPath->buffer);
598 0 : pSuffix = pBuffer + pAppPath->length;
599 0 : rtl_string_release( pAppPath );
600 :
601 0 : strcpy (pSuffix, "intro");
602 0 : strcat (pSuffix, pLocale);
603 0 : strcat (pSuffix, IMG_SUFFIX);
604 0 : if ( splash_load_bmp( splash, pBuffer ) )
605 0 : goto cleanup;
606 :
607 0 : strcpy (pSuffix, "intro" IMG_SUFFIX);
608 0 : if ( splash_load_bmp( splash, pBuffer ) )
609 0 : goto cleanup;
610 :
611 0 : fprintf (stderr, "Failed to find intro image\n");
612 :
613 : cleanup:
614 0 : free (pLocale);
615 0 : free (pBuffer);
616 0 : }
617 :
618 : /* Load the colors and size of the splash. */
619 0 : static void splash_load_defaults( struct splash* splash, rtl_uString* pAppPath, sal_Bool* bNoDefaults )
620 : {
621 0 : rtl_uString *pSettings = NULL, *pTmp = NULL;
622 : rtlBootstrapHandle handle;
623 0 : int logo[1] = { -1 },
624 0 : bar[3] = { -1, -1, -1 },
625 0 : frame[3] = { -1, -1, -1 },
626 0 : pos[2] = { -1, -1 },
627 0 : size[2] = { -1, -1 };
628 :
629 : /* costruct the sofficerc file location */
630 0 : rtl_uString_newFromAscii( &pSettings, "file://" );
631 0 : rtl_uString_newConcat( &pSettings, pSettings, pAppPath );
632 0 : rtl_uString_newConcat( &pSettings, pSettings, pTmp );
633 0 : rtl_uString_newFromAscii( &pTmp, SAL_CONFIGFILE( "soffice" ) );
634 0 : rtl_uString_newConcat( &pSettings, pSettings, pTmp );
635 :
636 : /* use it as the bootstrap file */
637 0 : handle = rtl_bootstrap_args_open( pSettings );
638 :
639 : /* get the values */
640 0 : get_bootstrap_value( logo, 1, handle, "Logo" );
641 0 : get_bootstrap_value( bar, 3, handle, "ProgressBarColor" );
642 0 : get_bootstrap_value( frame, 3, handle, "ProgressFrameColor" );
643 0 : get_bootstrap_value( pos, 2, handle, "ProgressPosition" );
644 0 : get_bootstrap_value( size, 2, handle, "ProgressSize" );
645 :
646 0 : if ( logo[0] == 0 )
647 : {
648 0 : *bNoDefaults = sal_True;
649 : }
650 :
651 0 : splash_setup( splash, bar, frame, pos[0], pos[1], size[0], size[1] );
652 :
653 : /* cleanup */
654 0 : rtl_bootstrap_args_close( handle );
655 0 : rtl_uString_release( pSettings );
656 0 : rtl_uString_release( pTmp );
657 0 : }
658 :
659 :
660 : // Draw the progress
661 0 : void splash_draw_progress( struct splash* splash, int progress )
662 : {
663 0 : int length = 0;
664 :
665 0 : if (!splash)
666 : {
667 0 : return;
668 : }
669 : // sanity
670 0 : if ( progress < 0 )
671 : {
672 0 : progress = 0;
673 : }
674 0 : if ( progress > 100 )
675 : {
676 0 : progress = 100;
677 : }
678 : // draw progress...
679 0 : length = ( progress * splash->barwidth / 100 ) - ( 2 * splash->barspace );
680 0 : if ( length < 0 )
681 : {
682 0 : length = 0;
683 : }
684 : // border
685 0 : XSetForeground( splash->display, splash->gc, splash->framecolor.pixel );
686 0 : XDrawRectangle( splash->display, splash->win, splash->gc, splash->tlx, splash->tly,
687 0 : splash->barwidth, splash->barheight );
688 :
689 : // progress bar
690 0 : XSetForeground( splash->display, splash->gc, splash->barcolor.pixel );
691 0 : XFillRectangle( splash->display, splash->win, splash->gc,
692 0 : splash->tlx + splash->barspace, splash->tly + splash->barspace,
693 0 : length + 1, splash->barheight - 2 * splash->barspace + 1 );
694 :
695 : // pending events
696 0 : process_events(splash);
697 : }
698 :
699 0 : void splash_destroy(struct splash* splash)
700 : {
701 0 : if(splash)
702 : {
703 0 : if(splash->display)
704 : {
705 0 : if(splash->gc)
706 : {
707 0 : XFreeGC(splash->display, splash->gc);
708 0 : splash->gc = NULL;
709 : }
710 :
711 0 : XCloseDisplay( splash->display );
712 0 : splash->display = NULL;
713 0 : png_destroy_read_struct( &(splash->png_ptr), &(splash->info_ptr), NULL );
714 : }
715 0 : free(splash);
716 : }
717 0 : }
718 :
719 0 : struct splash* splash_create(rtl_uString* pAppPath, int argc, char** argv)
720 : {
721 : struct splash* splash;
722 0 : sal_Bool bNoDefaults = sal_False;
723 :
724 0 : splash = calloc(1, sizeof(struct splash));
725 0 : if(splash)
726 : {
727 0 : splash->width = WINDOW_WIDTH;
728 0 : splash->height = WINDOW_HEIGHT;
729 :
730 0 : splash->tlx = 212;
731 0 : splash->tly = 216;
732 0 : splash->barwidth = 263;
733 0 : splash->barheight = 8;
734 0 : splash->barspace = PROGRESS_BARSPACE;
735 0 : splash->barcol.b = 18;
736 0 : splash->barcol.g = 202;
737 0 : splash->barcol.r = 157;
738 0 : splash->framecol.b = 0xD3;
739 0 : splash->framecol.g = 0xD3;
740 0 : splash->framecol.r = 0xD3;
741 :
742 0 : splash_load_image( splash, pAppPath );
743 0 : splash_load_defaults( splash, pAppPath, &bNoDefaults );
744 :
745 0 : if (!bNoDefaults && splash_create_window( splash, argc, argv ) )
746 : {
747 0 : splash_draw_progress( splash, 0 );
748 : }
749 : else
750 : {
751 0 : splash_destroy(splash);
752 0 : splash = NULL;
753 : }
754 : }
755 0 : return splash;
756 : }
757 :
758 : #else /* not ENABLE_QUICKSTART_LIBPNG */
759 :
760 : #include <rtl/ustrbuf.h>
761 :
762 : struct splash
763 : {
764 : };
765 :
766 : /* Stubs that will never be called in this case */
767 : void splash_draw_progress( struct splash* splash, int progress )
768 : {
769 : (void)splash; (void)progress;
770 : }
771 :
772 : void splash_destroy(struct splash* splash)
773 : {
774 : (void)splash;
775 : }
776 :
777 : struct splash* splash_create(rtl_uString* pAppPath, int argc, char** argv)
778 : {
779 : (void)pAppPath; (void)argc; (void)argv;
780 : return NULL;
781 : }
782 :
783 :
784 : #endif // ENABLE_QUICKSTART_LIBPNG
785 :
786 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
