LCOV - code coverage report
Current view: top level - desktop/unx/source - splashx.c (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 326 0.0 %
Date: 2014-04-14 Functions: 0 17 0.0 %
Legend: Lines: hit not hit

          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: */

Generated by: LCOV version 1.10