strepsirrhini/office-gobmx
9
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
office-gobmx/desktop/unx/source/splashx.c
Michael Weghorn e8d59edf9d desktop: Fix '--enable-gui --without-x' build 
The code in this block is X11-specific, so
make it conditional on `USING_X11`, not
`HAVE_FEATURE_UI`.

This fixes an `--enable-gui --without-x` build
that previously failed like this

    ld.lld: error: undefined symbol: XineramaQueryScreens
    >>> referenced by splashx.c:441 (desktop/unx/source/splashx.c:441)
    >>>               .../libreoffice/workdir/CObject/desktop/unx/source/splashx.o:(splash_init_display)
    [AIN] draw_brand
    clang: error: linker command failed with exit code 1 (use -v to see invocation)
    make[1]: *** [.../libreoffice/desktop/Executable_oosplash.mk:10: .../libreoffice/instdir/program/oosplash] Error 1
    make[1]: *** Waiting for unfinished jobs....
    make: *** [Makefile:296: build] Error 2

Change-Id: If02395d2461de4b6aac340898ce99583653d45c4
Reviewed-on: https://gerrit.libreoffice.org/c/core/+/171894
Tested-by: Jenkins
Reviewed-by: Michael Weghorn <m.weghorn@posteo.de>
2024-08-15 18:51:17 +02:00

811 lines
24 KiB
C
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This file is part of the LibreOffice project.
*
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/.
*/
#include <config_vclplug.h>
#include "splashx.h"
#if defined(ENABLE_QUICKSTART_LIBPNG) && USING_X11
#include <X11/Xlib.h>
#include <X11/Xatom.h>
#include <X11/Xutil.h>
#include <X11/extensions/Xinerama.h>
#include <osl/endian.h>
#include <fcntl.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <png.h>
#include <osl/process.h>
#include <osl/thread.h>
#include <rtl/bootstrap.h>
#include <rtl/ustrbuf.h>
typedef struct {
unsigned char b, g, r;
} color_t;
struct splash
{
Display* display;
int screen;
int depth;
int display_width;
int display_height;
int display_x_pos;
int display_y_pos;
Visual* visual;
int width;
int height;
Colormap color_map;
Window win;
GC gc;
//true when intro-highres loaded successfully
sal_Bool bHasHiDpiImage;
// Progress bar values
// taken from desktop/source/splash/splash.cxx
int tlx;
int tly;
int barwidth;
int barheight;
int barspace;
color_t barcol;
color_t framecol;
XColor barcolor;
XColor framecolor;
unsigned char** bitmap_rows;
png_structp png_ptr;
png_infop info_ptr;
};
#define WINDOW_WIDTH 440
#define WINDOW_HEIGHT 299
#define PROGRESS_XOFFSET 12
#define PROGRESS_YOFFSET 18
#define PROGRESS_BARSPACE 2
/* libpng-1.2.41 */
#ifndef PNG_TRANSFORM_GRAY_TO_RGB
# define PNG_TRANSFORM_GRAY_TO_RGB 0x2000
#endif
static int splash_load_bmp( struct splash* splash, const char *filename )
{
FILE *file;
if ( !(file = fopen( filename, "r" ) ) )
return 0;
splash->png_ptr = png_create_read_struct( PNG_LIBPNG_VER_STRING, NULL, NULL, NULL );
splash->info_ptr = png_create_info_struct(splash->png_ptr);
png_init_io( splash->png_ptr, file );
if( setjmp( png_jmpbuf( splash->png_ptr ) ) )
{
png_destroy_read_struct( &(splash->png_ptr), &(splash->info_ptr), NULL );
fclose( file );
return 0;
}
png_read_png( splash->png_ptr, splash->info_ptr,
PNG_TRANSFORM_EXPAND | PNG_TRANSFORM_STRIP_ALPHA |
PNG_TRANSFORM_GRAY_TO_RGB | PNG_TRANSFORM_BGR, NULL);
splash->bitmap_rows = png_get_rows( splash->png_ptr, splash->info_ptr );
splash->width = png_get_image_width( splash->png_ptr, splash->info_ptr );
splash->height = png_get_image_height( splash->png_ptr, splash->info_ptr );
fclose( file );
return 1;
}
static void setup_color( int const val[3], color_t *col )
{
if ( val[0] < 0 || val[1] < 0 || val[2] < 0 )
return;
#define CONVERT_COLOR( from,to ) if ( from < 0 ) to = 0; else if ( from > 255 ) to = 255; else to = from;
CONVERT_COLOR( val[0], col->r );
CONVERT_COLOR( val[1], col->g );
CONVERT_COLOR( val[2], col->b );
#undef CONVERT_COLOR
}
/* Fill 'array' with values of the key 'name'.
Its value is a comma delimited list of integers */
static void get_bootstrap_value( int *array, int size, rtlBootstrapHandle handle, const char *name )
{
rtl_uString *pKey = NULL, *pValue = NULL;
/* get the value from the ini file */
rtl_uString_newFromAscii( &pKey, name );
rtl_bootstrap_get_from_handle( handle, pKey, &pValue, NULL );
/* the value is several numbers delimited by ',' - parse it */
if ( rtl_uString_getLength( pValue ) > 0 )
{
rtl_uString *pToken = NULL;
int i = 0;
sal_Int32 nIndex = 0;
for ( ; ( nIndex >= 0 ) && ( i < size ); ++i )
{
nIndex = rtl_uString_getToken( &pToken, pValue, 0, ',', nIndex );
array[i] = rtl_ustr_toInt32( rtl_uString_getStr( pToken ), 10 );
}
rtl_uString_release( pToken );
}
/* cleanup */
rtl_uString_release( pKey );
rtl_uString_release( pValue );
}
// setup
static void splash_setup( struct splash* splash, int const barc[3], int const framec[3], int posx, int posy, int w, int h )
{
if ( splash->width <= 500 )
{
splash->barwidth = splash->width - ( 2 * PROGRESS_XOFFSET );
splash->barheight = 6;
splash->tlx = PROGRESS_XOFFSET;
splash->tly = splash->height - PROGRESS_YOFFSET;
splash->barcol.r = 0;
splash->barcol.g = 0;
splash->barcol.b = 128;
}
if ( posx >= 0 )
splash->tlx = posx;
if ( posy >= 0 )
splash->tly = posy;
if ( w >= 0 )
splash->barwidth = w;
if ( h >= 0 )
splash->barheight = h;
setup_color( barc, &(splash->barcol) );
setup_color( framec, &(splash->framecol) );
}
// Universal shift: bits >= 0 - left, otherwise right
#define SHIFT( x, bits ) ( ( (bits) >= 0 )? ( (x) << (bits) ): ( (x) >> -(bits) ) )
// Position of the highest bit (more or less integer log2)
static int HIGHEST_BIT( unsigned long x )
{
int i = 0;
for ( ; x; ++i )
x >>= 1;
return i;
}
// Number of bits set to 1
static int BITS( unsigned long x )
{
int i = 0;
for ( ; x; x >>= 1 )
if ( x & 1UL )
++i;
return i;
}
// Set 'bitmap' as the background of our 'win' window
static void create_pixmap(struct splash* splash)
{
Pixmap pixmap;
GC pixmap_gc;
XGCValues values;
if ( !splash->bitmap_rows )
{
return;
}
pixmap = XCreatePixmap( splash->display, splash->win, splash->width, splash->height, splash->depth );
pixmap_gc = XCreateGC( splash->display, pixmap, 0/*value_mask*/, &values );
if ( splash->visual->class == TrueColor )
{
const unsigned long red_mask = splash->visual->red_mask;
const unsigned long green_mask = splash->visual->green_mask;
const unsigned long blue_mask = splash->visual->blue_mask;
const unsigned long red_delta_mask = ( 1UL << ( 8 - BITS( red_mask ) ) ) - 1;
const unsigned long green_delta_mask = ( 1UL << ( 8 - BITS( green_mask ) ) ) - 1;
const unsigned long blue_delta_mask = ( 1UL << ( 8 - BITS( blue_mask ) ) ) - 1;
const int red_shift = HIGHEST_BIT( red_mask ) - 8;
const int green_shift = HIGHEST_BIT( green_mask ) - 8;
const int blue_shift = HIGHEST_BIT( blue_mask ) - 8;
XImage* image = XCreateImage( splash->display, splash->visual, splash->depth, ZPixmap,
0, NULL, splash->width, splash->height, 32, 0 );
const int bytes_per_line = image->bytes_per_line;
const int bpp = image->bits_per_pixel;
const int byte_order = image->byte_order;
#if defined OSL_LITENDIAN
const int machine_byte_order = LSBFirst;
#else /* OSL_BIGENDIAN */
const int machine_byte_order = MSBFirst;
#endif
char *data = malloc( splash->height * bytes_per_line );
char *out = data;
image->data = data;
// The following dithers & converts the color_t color to one
// acceptable for the visual
#define COPY_IN_OUT( pix_size, code ) \
{ \
int x, y; \
for ( y = 0; y < splash->height; ++y ) \
{ \
unsigned long red_delta = 0, green_delta = 0, blue_delta = 0; \
color_t *in = (color_t *)(splash->bitmap_rows[y]); \
out = data + y * bytes_per_line; \
for ( x = 0; x < splash->width; ++x, ++in ) \
{ \
unsigned long red = in->r + red_delta; \
unsigned long green = in->g + green_delta; \
unsigned long blue = in->b + blue_delta; \
unsigned long pixel = 0; \
uint32_t tmp = 0; \
(void) tmp; \
red_delta = red & red_delta_mask; \
green_delta = green & green_delta_mask; \
blue_delta = blue & blue_delta_mask; \
if ( red > 255 ) \
red = 255; \
if ( green > 255 ) \
green = 255; \
if ( blue > 255 ) \
blue = 255; \
pixel = \
( SHIFT( red, red_shift ) & red_mask ) | \
( SHIFT( green, green_shift ) & green_mask ) | \
( SHIFT( blue, blue_shift ) & blue_mask ); \
code \
} \
} \
}
if ( bpp == 32 )
{
if ( machine_byte_order == byte_order )
COPY_IN_OUT( 4, *( (uint32_t *)out ) = (uint32_t)pixel; out += 4; )
else
COPY_IN_OUT( 4, tmp = pixel;
*( (uint8_t *)out ) = *( (uint8_t *)(&tmp) + 3 );
*( (uint8_t *)out + 1 ) = *( (uint8_t *)(&tmp) + 2 );
*( (uint8_t *)out + 2 ) = *( (uint8_t *)(&tmp) + 1 );
*( (uint8_t *)out + 3 ) = *( (uint8_t *)(&tmp) );
out += 4; )
}
else if ( bpp == 24 )
{
if (machine_byte_order == byte_order)
{
#if defined OSL_LITENDIAN
COPY_IN_OUT( 3, memcpy(out, &pixel, sizeof (color_t)); out += 3; )
#else /* OSL_BIGENDIAN */
COPY_IN_OUT( 3, tmp = pixel;
*( (uint8_t *)out ) = *( (uint8_t *)(&tmp) + 1 );
*( (uint8_t *)out + 1 ) = *( (uint8_t *)(&tmp) + 2 );
*( (uint8_t *)out + 2 ) = *( (uint8_t *)(&tmp) + 3 );
out += 3; )
#endif
}
else
COPY_IN_OUT( 3, tmp = pixel;
*( (uint8_t *)out ) = *( (uint8_t *)(&tmp) + 3 );
*( (uint8_t *)out + 1 ) = *( (uint8_t *)(&tmp) + 2 );
*( (uint8_t *)out + 2 ) = *( (uint8_t *)(&tmp) + 1 );
out += 3; )
}
else if ( bpp == 16 )
{
if ( machine_byte_order == byte_order )
COPY_IN_OUT( 2, *( (uint16_t *)out ) = (uint16_t)pixel; out += 2; )
else
COPY_IN_OUT( 2, tmp = pixel;
*( (uint8_t *)out ) = *( (uint8_t *)(&tmp) + 1 );
*( (uint8_t *)out + 1 ) = *( (uint8_t *)(&tmp) );
out += 2; );
}
else if ( bpp == 8 )
{
COPY_IN_OUT( 1, *( (uint8_t *)out ) = (uint8_t)pixel; ++out; )
}
else
{
fprintf( stderr, "Unsupported depth: %d bits per pixel.\n", bpp );
XFreeGC( splash->display, pixmap_gc );
XFreePixmap( splash->display, pixmap );
XDestroyImage( image );
return;
}
#undef COPY_IN_OUT
XPutImage( splash->display, pixmap, pixmap_gc, image, 0, 0, 0, 0, splash->width, splash->height );
XDestroyImage( image );
}
XSetWindowBackgroundPixmap( splash->display, splash->win, pixmap );
XFreeGC( splash->display, pixmap_gc );
XFreePixmap( splash->display, pixmap );
}
// The old method of hiding the window decorations
static void suppress_decorations_motif(struct splash* splash)
{
struct
{
unsigned long flags, functions, decorations;
long input_mode;
} mwmhints;
Atom a = XInternAtom( splash->display, "_MOTIF_WM_HINTS", False );
mwmhints.flags = 15; // functions, decorations, input_mode, status
mwmhints.functions = 2; // ?
mwmhints.decorations = 0;
mwmhints.input_mode = 0;
XChangeProperty( splash->display, splash->win, a, a, 32,
PropModeReplace, (unsigned char*)&mwmhints, 5 );
}
// This is a splash, set it as such.
// If it fails, just hide the decorations...
static void suppress_decorations(struct splash* splash)
{
Atom atom_type = XInternAtom( splash->display, "_NET_WM_WINDOW_TYPE", True );
Atom atom_splash = XInternAtom( splash->display, "_NET_WM_WINDOW_TYPE_SPLASH", True );
if ( atom_type != None && atom_splash != None )
XChangeProperty( splash->display, splash->win, atom_type, XA_ATOM, 32,
PropModeReplace, (unsigned char*)&atom_splash, 1 );
//else
suppress_decorations_motif(splash); // FIXME: Unconditional until Metacity/compiz's SPLASH handling is fixed
}
/**
* Connects to the display and initializes splash with the screen details
*
* @return Success: 1; Failure: 0
*/
static int splash_init_display( struct splash* splash, int argc, char** argv )
{
char *display_name = NULL;
int i;
int n_xinerama_screens = 1;
XineramaScreenInfo* p_screens = NULL;
for ( i = 0; i < argc; i++ )
{
if ( !strcmp( argv[i], "-display" ) || !strcmp( argv[i], "--display" ) )
{
display_name = ( i + 1 < argc )? argv[i+1]: NULL;
}
}
if ( !display_name )
{
display_name = getenv( "DISPLAY" );
}
// init display
splash->display = XOpenDisplay( display_name );
if ( !splash->display )
{
fprintf( stderr, "Failed to open display\n" );
return 0;
}
// create the window
splash->screen = DefaultScreen( splash->display );
splash->depth = DefaultDepth( splash->display, splash->screen );
splash->color_map = DefaultColormap( splash->display, splash->screen );
splash->visual = DefaultVisual( splash->display, splash->screen );
splash->display_width = DisplayWidth( splash->display, splash->screen );
splash->display_height = DisplayHeight( splash->display, splash->screen );
splash->display_x_pos = 0;
splash->display_y_pos = 0;
p_screens = XineramaQueryScreens( splash->display, &n_xinerama_screens );
if( p_screens )
{
for( i=0; i < n_xinerama_screens; i++ )
{
if ( p_screens[i].screen_number == splash->screen )
{
splash->display_width = p_screens[i].width;
splash->display_height = p_screens[i].height;
splash->display_x_pos = p_screens[i].x_org;
splash->display_y_pos = p_screens[i].y_org;
break;
}
}
XFree( p_screens );
}
return 1;
}
/**
* Create the window for the splash screen
*
* @return Success: 1; Failure: 0
*/
static int splash_create_window(struct splash* splash)
{
Window root_win;
XGCValues values;
const char* name = "LibreOffice";
const char* icon = "icon"; // FIXME
XSizeHints size_hints;
root_win = RootWindow( splash->display, splash->screen );
splash->win = XCreateSimpleWindow( splash->display, root_win,
(splash->display_x_pos + (splash->display_width - splash->width)/2),
(splash->display_y_pos + (splash->display_height - splash->height)/2),
splash->width, splash->height, 0,
BlackPixel( splash->display, splash->screen ), BlackPixel( splash->display, splash->screen ) );
XSetWindowColormap( splash->display, splash->win, splash->color_map );
// setup colors
#define FILL_COLOR( xcol,col ) xcol.red = 256*col.r; xcol.green = 256*col.g; xcol.blue = 256*col.b;
FILL_COLOR( splash->barcolor, splash->barcol );
FILL_COLOR( splash->framecolor, splash->framecol );
#undef FILL_COLOR
XAllocColor( splash->display, splash->color_map, &(splash->barcolor) );
XAllocColor( splash->display, splash->color_map, &(splash->framecolor) );
// not resizable, no decorations, etc.
splash->gc = XCreateGC( splash->display, splash->win, 0/*value_mask*/, &values );
size_hints.flags = PPosition | PSize | PMinSize | PMaxSize;
size_hints.x = splash->display_x_pos;
size_hints.y = splash->display_y_pos;
size_hints.width = splash->width;
size_hints.height = splash->height;
size_hints.min_width = splash->width;
size_hints.max_width = splash->width;
size_hints.min_height = splash->height;
size_hints.max_height = splash->height;
XSetStandardProperties( splash->display, splash->win, name, icon, None,
NULL, 0, &size_hints );
// the actual work
suppress_decorations(splash);
create_pixmap(splash);
// show it
XSelectInput( splash->display, splash->win, 0 );
XMapWindow( splash->display, splash->win );
return 1;
}
// Re-draw & process the events
// Just throwing them away - we do not need anything more...
static void process_events(struct splash* splash)
{
XEvent xev;
int num_events;
XFlush( splash->display );
num_events = XPending( splash->display );
while ( num_events > 0 )
{
num_events--;
XNextEvent( splash->display, &xev );
}
}
static rtl_String* ustr_to_str( rtl_uString* pStr )
{
rtl_String *pOut = NULL;
rtl_uString2String( &pOut, rtl_uString_getStr( pStr ),
rtl_uString_getLength( pStr ), osl_getThreadTextEncoding(), OUSTRING_TO_OSTRING_CVTFLAGS );
return pOut;
}
static sal_Bool isHiDPI(struct splash* splash)
{
const char* pValStr;
double nDPI;
/*
* GNOME currently enables HiDPI support when the screen resolution is at least 192 dpi
* and the screen height (in device pixels) is at least 1200.
*/
if (splash->display_height < 1200)
return sal_False;
pValStr = XGetDefault(splash->display, "Xft", "dpi");
/* if it's too old to have this, assume it's not hidpi */
if (!pValStr)
return sal_False;
nDPI = strtod(pValStr, NULL);
if (nDPI < 192)
return sal_False;
return sal_True;
}
#define IMG_SUFFIX ".png"
static void splash_load_image( struct splash* splash, rtl_uString* pUAppPath )
{
/* FIXME-BCP47: if we wanted to support language tags here that would get
* complicated, this is C-source not C++ so LanguageTag can't be used. For
* now the splash screen will have to get along with language-territory. */
char *pBuffer, *pSuffix, *pLocale;
int nLocSize;
rtl_Locale *pLoc = NULL;
rtl_String *pLang, *pCountry, *pAppPath;
osl_getProcessLocale (&pLoc);
pLang = ustr_to_str (pLoc->Language);
pCountry = ustr_to_str (pLoc->Country);
nLocSize = strlen (pLang->buffer) + strlen (pCountry->buffer) + 3;
pLocale = malloc (nLocSize);
pLocale[0] = '-';
strcpy (pLocale + 1, pLang->buffer);
strcat (pLocale, "_");
strcat (pLocale, pCountry->buffer);
rtl_string_release( pCountry );
rtl_string_release( pLang );
pAppPath = ustr_to_str (pUAppPath);
pBuffer = malloc (pAppPath->length + nLocSize + 256);
strcpy (pBuffer, pAppPath->buffer);
pSuffix = pBuffer + pAppPath->length;
rtl_string_release( pAppPath );
strcpy (pSuffix, "intro");
strcat (pSuffix, pLocale);
strcat (pSuffix, IMG_SUFFIX);
if ( splash_load_bmp( splash, pBuffer ) )
goto cleanup; /* success */
/* load high resolution splash image */
splash->bHasHiDpiImage = sal_False;
if (isHiDPI(splash))
{
strcpy (pSuffix, "intro-highres" IMG_SUFFIX);
if ( splash_load_bmp( splash, pBuffer ) )
{
splash->bHasHiDpiImage = sal_True;
goto cleanup; /* success */
}
}
/* load standard resolution splash image */
strcpy (pSuffix, "intro" IMG_SUFFIX);
if ( splash_load_bmp( splash, pBuffer ) )
goto cleanup; /* success */
fprintf (stderr, "Failed to find intro image\n");
cleanup:
free (pLocale);
free (pBuffer);
}
/* Load the colors and size of the splash. */
static void splash_load_defaults( struct splash* splash, rtl_uString* pAppPath, sal_Bool* bNoDefaults )
{
rtl_uString *pSettings = NULL, *pTmp = NULL;
rtlBootstrapHandle handle;
int logo[1] = { -1 },
bar[3] = { -1, -1, -1 },
frame[3] = { -1, -1, -1 },
pos[2] = { -1, -1 },
size[2] = { -1, -1 };
/* construct the sofficerc file location */
rtl_uString_newFromAscii( &pSettings, "file://" );
rtl_uString_newConcat( &pSettings, pSettings, pAppPath );
rtl_uString_newConcat( &pSettings, pSettings, pTmp );
rtl_uString_newFromAscii( &pTmp, SAL_CONFIGFILE( "soffice" ) );
rtl_uString_newConcat( &pSettings, pSettings, pTmp );
/* use it as the bootstrap file */
handle = rtl_bootstrap_args_open( pSettings );
/* get the values */
get_bootstrap_value( logo, 1, handle, "Logo" );
get_bootstrap_value( bar, 3, handle, "ProgressBarColor" );
get_bootstrap_value( frame, 3, handle, "ProgressFrameColor" );
if (isHiDPI(splash) && splash->bHasHiDpiImage)
{
get_bootstrap_value( pos, 2, handle, "ProgressPositionHigh" );
get_bootstrap_value( size, 2, handle, "ProgressSizeHigh" );
}
else
{
get_bootstrap_value( pos, 2, handle, "ProgressPosition" );
get_bootstrap_value( size, 2, handle, "ProgressSize" );
}
if ( logo[0] == 0 )
{
*bNoDefaults = sal_True;
}
splash_setup( splash, bar, frame, pos[0], pos[1], size[0], size[1] );
/* cleanup */
rtl_bootstrap_args_close( handle );
rtl_uString_release( pSettings );
rtl_uString_release( pTmp );
}
// Draw the progress
void splash_draw_progress( struct splash* splash, int progress )
{
int length = 0;
if (!splash)
{
return;
}
// sanity
if ( progress < 0 )
{
progress = 0;
}
if ( progress > 100 )
{
progress = 100;
}
// draw progress...
length = ( progress * splash->barwidth / 100 ) - ( 2 * splash->barspace );
if ( length < 0 )
{
length = 0;
}
// border
XSetForeground( splash->display, splash->gc, splash->framecolor.pixel );
XDrawRectangle( splash->display, splash->win, splash->gc, splash->tlx, splash->tly,
splash->barwidth, splash->barheight );
// progress bar
XSetForeground( splash->display, splash->gc, splash->barcolor.pixel );
XFillRectangle( splash->display, splash->win, splash->gc,
splash->tlx + splash->barspace, splash->tly + splash->barspace,
length + 1, splash->barheight - 2 * splash->barspace + 1 );
// pending events
process_events(splash);
}
void splash_destroy(struct splash* splash)
{
if(!splash)
return;
if(splash->display)
{
if(splash->gc)
{
XFreeGC(splash->display, splash->gc);
splash->gc = NULL;
}
XCloseDisplay( splash->display );
splash->display = NULL;
png_destroy_read_struct( &(splash->png_ptr), &(splash->info_ptr), NULL );
}
free(splash);
}
struct splash* splash_create(rtl_uString* pAppPath, int argc, char** argv)
{
struct splash* splash;
sal_Bool bNoDefaults = sal_False;
splash = calloc(1, sizeof(struct splash));
if (splash && !splash_init_display(splash, argc, argv))
{
splash_destroy(splash);
splash = NULL;
}
if (!splash)
return NULL;
splash->width = WINDOW_WIDTH;
splash->height = WINDOW_HEIGHT;
splash->tlx = 212;
splash->tly = 216;
splash->barwidth = 263;
splash->barheight = 8;
splash->barspace = PROGRESS_BARSPACE;
splash->barcol.b = 18;
splash->barcol.g = 202;
splash->barcol.r = 157;
splash->framecol.b = 0xD3;
splash->framecol.g = 0xD3;
splash->framecol.r = 0xD3;
splash_load_image( splash, pAppPath );
splash_load_defaults( splash, pAppPath, &bNoDefaults );
if (!bNoDefaults && splash_create_window(splash))
{
splash_draw_progress( splash, 0 );
return splash;
}
splash_destroy(splash);
return NULL;
}
#else /* not ENABLE_QUICKSTART_LIBPNG */
struct splash
{
};
/* Stubs that will never be called in this case */
void splash_draw_progress( struct splash* splash, int progress )
{
(void)splash; (void)progress;
}
void splash_destroy(struct splash* splash)
{
(void)splash;
}
struct splash* splash_create(rtl_uString* pAppPath, int argc, char** argv)
{
(void)pAppPath; (void)argc; (void)argv;
return NULL;
}
#endif // defined(ENABLE_QUICKSTART_LIBPNG) && HAVE_FEATURE_UI
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */
Reference in a new issue View git blame Copy permalink