LCOV - code coverage report
Current view: top level - vcl/unx/generic/app - saldata.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 276 0.0 %
Date: 2014-04-14 Functions: 0 33 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             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : #include <unistd.h>
      21             : #include <fcntl.h>
      22             : 
      23             : #include <cstdio>
      24             : #include <cstring>
      25             : #include <cstdlib>
      26             : #include <stdio.h>
      27             : #include <limits.h>
      28             : #include <errno.h>
      29             : #include <pthread.h>
      30             : #include <sys/resource.h>
      31             : #ifdef SUN
      32             : #include <sys/systeminfo.h>
      33             : #endif
      34             : #ifdef AIX
      35             : #include <strings.h>
      36             : #endif
      37             : #ifdef FREEBSD
      38             : #include <sys/types.h>
      39             : #include <sys/time.h>
      40             : #endif
      41             : 
      42             : #include <prex.h>
      43             : #include <X11/Xproto.h>
      44             : #include <postx.h>
      45             : 
      46             : #include <osl/process.h>
      47             : #include <osl/mutex.hxx>
      48             : 
      49             : #include "unx/saldisp.hxx"
      50             : #include "unx/saldata.hxx"
      51             : #include "unx/salframe.h"
      52             : #include "unx/sm.hxx"
      53             : #include "unx/i18n_im.hxx"
      54             : #include "unx/i18n_xkb.hxx"
      55             : #include "salinst.hxx"
      56             : 
      57             : #include <osl/signal.h>
      58             : #include <osl/thread.h>
      59             : #include <rtl/strbuf.hxx>
      60             : #include <rtl/bootstrap.hxx>
      61             : 
      62             : #include <tools/debug.hxx>
      63             : #include <vcl/svapp.hxx>
      64             : 
      65             : #ifndef UNX
      66             : #ifndef SIGBUS
      67             : #define SIGBUS 10
      68             : #endif
      69             : #ifndef SIGSEGV
      70             : #define SIGSEGV 11
      71             : #endif
      72             : #ifndef SIGIOT
      73             : #define SIGIOT SIGABRT
      74             : #endif
      75             : #endif
      76             : 
      77           0 : X11SalData* GetX11SalData()
      78             : {
      79           0 :     SalData * p1 = ImplGetSVData()->mpSalData;
      80             :     OSL_ASSERT(p1 != 0);
      81           0 :     X11SalData * p2 = dynamic_cast< X11SalData * >(p1);
      82             :     OSL_ASSERT(p2 != 0);
      83           0 :     return p2;
      84             : }
      85             : 
      86             : extern "C" {
      87             : 
      88           0 : static int XErrorHdl( Display *pDisplay, XErrorEvent *pEvent )
      89             : {
      90           0 :     GetX11SalData()->XError( pDisplay, pEvent );
      91           0 :     return 0;
      92             : }
      93             : 
      94           0 : static int XIOErrorHdl( Display * )
      95             : {
      96           0 :     if (::osl::Thread::getCurrentIdentifier() == Application::GetMainThreadIdentifier())
      97             :     {
      98             :         /*  #106197# hack: until a real shutdown procedure exists
      99             :          *  _exit ASAP
     100             :          */
     101           0 :         if( ImplGetSVData()->maAppData.mbAppQuit )
     102           0 :             _exit(1);
     103             : 
     104             :         // really bad hack
     105           0 :         if( ! SessionManagerClient::checkDocumentsSaved() )
     106           0 :             /* oslSignalAction eToDo = */ osl_raiseSignal (OSL_SIGNAL_USER_X11SUBSYSTEMERROR, NULL);
     107             :     }
     108             : 
     109           0 :     std::fprintf( stderr, "X IO Error\n" );
     110           0 :     std::fflush( stdout );
     111           0 :     std::fflush( stderr );
     112             : 
     113             :     /*  #106197# the same reasons to use _exit instead of exit in salmain
     114             :      *  do apply here. Since there is nothing to be done after an XIO
     115             :      *  error we have to _exit immediately.
     116             :      */
     117           0 :     _exit(1);
     118             :     return 0;
     119             : }
     120             : 
     121             : }
     122             : 
     123             : static const struct timeval noyield__ = { 0, 0 };
     124             : static const struct timeval yield__   = { 0, 10000 };
     125             : 
     126             : static const char* XRequest[] = {
     127             :     // see /usr/lib/X11/XErrorDB, /usr/openwin/lib/XErrorDB ...
     128             :     NULL,
     129             :     "X_CreateWindow",
     130             :     "X_ChangeWindowAttributes",
     131             :     "X_GetWindowAttributes",
     132             :     "X_DestroyWindow",
     133             :     "X_DestroySubwindows",
     134             :     "X_ChangeSaveSet",
     135             :     "X_ReparentWindow",
     136             :     "X_MapWindow",
     137             :     "X_MapSubwindows",
     138             :     "X_UnmapWindow",
     139             :     "X_UnmapSubwindows",
     140             :     "X_ConfigureWindow",
     141             :     "X_CirculateWindow",
     142             :     "X_GetGeometry",
     143             :     "X_QueryTree",
     144             :     "X_InternAtom",
     145             :     "X_GetAtomName",
     146             :     "X_ChangeProperty",
     147             :     "X_DeleteProperty",
     148             :     "X_GetProperty",
     149             :     "X_ListProperties",
     150             :     "X_SetSelectionOwner",
     151             :     "X_GetSelectionOwner",
     152             :     "X_ConvertSelection",
     153             :     "X_SendEvent",
     154             :     "X_GrabPointer",
     155             :     "X_UngrabPointer",
     156             :     "X_GrabButton",
     157             :     "X_UngrabButton",
     158             :     "X_ChangeActivePointerGrab",
     159             :     "X_GrabKeyboard",
     160             :     "X_UngrabKeyboard",
     161             :     "X_GrabKey",
     162             :     "X_UngrabKey",
     163             :     "X_AllowEvents",
     164             :     "X_GrabServer",
     165             :     "X_UngrabServer",
     166             :     "X_QueryPointer",
     167             :     "X_GetMotionEvents",
     168             :     "X_TranslateCoords",
     169             :     "X_WarpPointer",
     170             :     "X_SetInputFocus",
     171             :     "X_GetInputFocus",
     172             :     "X_QueryKeymap",
     173             :     "X_OpenFont",
     174             :     "X_CloseFont",
     175             :     "X_QueryFont",
     176             :     "X_QueryTextExtents",
     177             :     "X_ListFonts",
     178             :     "X_ListFontsWithInfo",
     179             :     "X_SetFontPath",
     180             :     "X_GetFontPath",
     181             :     "X_CreatePixmap",
     182             :     "X_FreePixmap",
     183             :     "X_CreateGC",
     184             :     "X_ChangeGC",
     185             :     "X_CopyGC",
     186             :     "X_SetDashes",
     187             :     "X_SetClipRectangles",
     188             :     "X_FreeGC",
     189             :     "X_ClearArea",
     190             :     "X_CopyArea",
     191             :     "X_CopyPlane",
     192             :     "X_PolyPoint",
     193             :     "X_PolyLine",
     194             :     "X_PolySegment",
     195             :     "X_PolyRectangle",
     196             :     "X_PolyArc",
     197             :     "X_FillPoly",
     198             :     "X_PolyFillRectangle",
     199             :     "X_PolyFillArc",
     200             :     "X_PutImage",
     201             :     "X_GetImage",
     202             :     "X_PolyText8",
     203             :     "X_PolyText16",
     204             :     "X_ImageText8",
     205             :     "X_ImageText16",
     206             :     "X_CreateColormap",
     207             :     "X_FreeColormap",
     208             :     "X_CopyColormapAndFree",
     209             :     "X_InstallColormap",
     210             :     "X_UninstallColormap",
     211             :     "X_ListInstalledColormaps",
     212             :     "X_AllocColor",
     213             :     "X_AllocNamedColor",
     214             :     "X_AllocColorCells",
     215             :     "X_AllocColorPlanes",
     216             :     "X_FreeColors",
     217             :     "X_StoreColors",
     218             :     "X_StoreNamedColor",
     219             :     "X_QueryColors",
     220             :     "X_LookupColor",
     221             :     "X_CreateCursor",
     222             :     "X_CreateGlyphCursor",
     223             :     "X_FreeCursor",
     224             :     "X_RecolorCursor",
     225             :     "X_QueryBestSize",
     226             :     "X_QueryExtension",
     227             :     "X_ListExtensions",
     228             :     "X_ChangeKeyboardMapping",
     229             :     "X_GetKeyboardMapping",
     230             :     "X_ChangeKeyboardControl",
     231             :     "X_GetKeyboardControl",
     232             :     "X_Bell",
     233             :     "X_ChangePointerControl",
     234             :     "X_GetPointerControl",
     235             :     "X_SetScreenSaver",
     236             :     "X_GetScreenSaver",
     237             :     "X_ChangeHosts",
     238             :     "X_ListHosts",
     239             :     "X_SetAccessControl",
     240             :     "X_SetCloseDownMode",
     241             :     "X_KillClient",
     242             :     "X_RotateProperties",
     243             :     "X_ForceScreenSaver",
     244             :     "X_SetPointerMapping",
     245             :     "X_GetPointerMapping",
     246             :     "X_SetModifierMapping",
     247             :     "X_GetModifierMapping",
     248             :     NULL,
     249             :     NULL,
     250             :     NULL,
     251             :     NULL,
     252             :     NULL,
     253             :     NULL,
     254             :     NULL,
     255             :     "X_NoOperation"
     256             : };
     257             : 
     258           0 : X11SalData::X11SalData( SalGenericDataType t, SalInstance *pInstance )
     259           0 :     : SalGenericData( t, pInstance )
     260             : {
     261           0 :     pXLib_          = NULL;
     262           0 :     m_pPlugin       = NULL;
     263             : 
     264           0 :     m_aOrigXIOErrorHandler = XSetIOErrorHandler ( XIOErrorHdl );
     265           0 :     PushXErrorLevel( !!getenv( "SAL_IGNOREXERRORS" ) );
     266           0 : }
     267             : 
     268           0 : X11SalData::~X11SalData()
     269             : {
     270           0 :     DeleteDisplay();
     271           0 :     PopXErrorLevel();
     272           0 :     XSetIOErrorHandler (m_aOrigXIOErrorHandler);
     273           0 : }
     274             : 
     275           0 : void X11SalData::Dispose()
     276             : {
     277           0 :     deInitNWF();
     278           0 :     delete GetDisplay();
     279           0 :     SetSalData( NULL );
     280           0 : }
     281             : 
     282           0 : void X11SalData::DeleteDisplay()
     283             : {
     284           0 :     delete GetDisplay();
     285           0 :     SetDisplay( NULL );
     286           0 :     delete pXLib_;
     287           0 :     pXLib_ = NULL;
     288           0 : }
     289             : 
     290           0 : void X11SalData::Init()
     291             : {
     292           0 :     pXLib_ = new SalXLib();
     293           0 :     pXLib_->Init();
     294           0 : }
     295             : 
     296           0 : void X11SalData::initNWF( void )
     297             : {
     298           0 : }
     299             : 
     300           0 : void X11SalData::deInitNWF( void )
     301             : {
     302           0 : }
     303             : 
     304           0 : void X11SalData::ErrorTrapPush()
     305             : {
     306           0 :     PushXErrorLevel( true );
     307           0 : }
     308             : 
     309           0 : bool X11SalData::ErrorTrapPop( bool bIgnoreError )
     310             : {
     311           0 :     bool err = false;
     312           0 :     if( !bIgnoreError )
     313           0 :         err = HasXErrorOccurred();
     314           0 :     ResetXErrorOccurred();
     315           0 :     PopXErrorLevel();
     316           0 :     return err;
     317             : }
     318             : 
     319           0 : void X11SalData::PushXErrorLevel( bool bIgnore )
     320             : {
     321           0 :     m_aXErrorHandlerStack.push_back( XErrorStackEntry() );
     322           0 :     XErrorStackEntry& rEnt = m_aXErrorHandlerStack.back();
     323           0 :     rEnt.m_bWas = false;
     324           0 :     rEnt.m_bIgnore = bIgnore;
     325           0 :     rEnt.m_nLastErrorRequest = 0;
     326           0 :     rEnt.m_aHandler = XSetErrorHandler( XErrorHdl );
     327           0 : }
     328             : 
     329           0 : void X11SalData::PopXErrorLevel()
     330             : {
     331           0 :     if( m_aXErrorHandlerStack.size() )
     332             :     {
     333           0 :         XSetErrorHandler( m_aXErrorHandlerStack.back().m_aHandler );
     334           0 :         m_aXErrorHandlerStack.pop_back();
     335             :     }
     336           0 : }
     337             : 
     338           0 : SalXLib::SalXLib()
     339             : {
     340           0 :     m_aTimeout.tv_sec       = 0;
     341           0 :     m_aTimeout.tv_usec      = 0;
     342           0 :     m_nTimeoutMS            = 0;
     343             : 
     344           0 :     nFDs_                   = 0;
     345           0 :     FD_ZERO( &aReadFDS_ );
     346           0 :     FD_ZERO( &aExceptionFDS_ );
     347             : 
     348           0 :     m_pTimeoutFDS[0] = m_pTimeoutFDS[1] = -1;
     349           0 :     if (pipe (m_pTimeoutFDS) != -1)
     350             :     {
     351             :         // initialize 'wakeup' pipe.
     352             :         int flags;
     353             : 
     354             :         // set close-on-exec descriptor flag.
     355           0 :         if ((flags = fcntl (m_pTimeoutFDS[0], F_GETFD)) != -1)
     356             :         {
     357           0 :             flags |= FD_CLOEXEC;
     358           0 :             fcntl (m_pTimeoutFDS[0], F_SETFD, flags);
     359             :         }
     360           0 :         if ((flags = fcntl (m_pTimeoutFDS[1], F_GETFD)) != -1)
     361             :         {
     362           0 :             flags |= FD_CLOEXEC;
     363           0 :             fcntl (m_pTimeoutFDS[1], F_SETFD, flags);
     364             :         }
     365             : 
     366             :         // set non-blocking I/O flag.
     367           0 :         if ((flags = fcntl (m_pTimeoutFDS[0], F_GETFL)) != -1)
     368             :         {
     369           0 :             flags |= O_NONBLOCK;
     370           0 :             fcntl (m_pTimeoutFDS[0], F_SETFL, flags);
     371             :         }
     372           0 :         if ((flags = fcntl (m_pTimeoutFDS[1], F_GETFL)) != -1)
     373             :         {
     374           0 :             flags |= O_NONBLOCK;
     375           0 :             fcntl (m_pTimeoutFDS[1], F_SETFL, flags);
     376             :         }
     377             : 
     378             :         // insert [0] into read descriptor set.
     379           0 :         FD_SET( m_pTimeoutFDS[0], &aReadFDS_ );
     380           0 :         nFDs_ = m_pTimeoutFDS[0] + 1;
     381             :     }
     382           0 : }
     383             : 
     384           0 : SalXLib::~SalXLib()
     385             : {
     386             :     // close 'wakeup' pipe.
     387           0 :     close (m_pTimeoutFDS[0]);
     388           0 :     close (m_pTimeoutFDS[1]);
     389           0 : }
     390             : 
     391           0 : void SalXLib::Init()
     392             : {
     393           0 :     SalI18N_InputMethod* pInputMethod = new SalI18N_InputMethod;
     394           0 :     pInputMethod->SetLocale();
     395           0 :     XrmInitialize();
     396             : 
     397             :     /*
     398             :      * open connection to X11 Display
     399             :      * try in this order:
     400             :      *  o  -display command line parameter,
     401             :      *  o  $DISPLAY environment variable
     402             :      *  o  default display
     403             :      */
     404             : 
     405           0 :     Display *pDisp = NULL;
     406             : 
     407             :     // is there a -display command line parameter?
     408             : 
     409           0 :     sal_uInt32 nParams = osl_getCommandArgCount();
     410           0 :     OUString aParam;
     411           0 :     OString aDisplay;
     412           0 :     for (sal_uInt16 i=0; i<nParams; i++)
     413             :     {
     414           0 :         osl_getCommandArg(i, &aParam.pData);
     415           0 :         if ( aParam == "-display" )
     416             :         {
     417           0 :             osl_getCommandArg(i+1, &aParam.pData);
     418           0 :             aDisplay = OUStringToOString(
     419           0 :                    aParam, osl_getThreadTextEncoding());
     420             : 
     421           0 :             if ((pDisp = XOpenDisplay(aDisplay.getStr()))!=NULL)
     422             :             {
     423             :                 /*
     424             :                  * if a -display switch was used, we need
     425             :                  * to set the environment accoringly since
     426             :                  * the clipboard build another connection
     427             :                  * to the xserver using $DISPLAY
     428             :                  */
     429           0 :                 OUString envVar("DISPLAY");
     430           0 :                 osl_setEnvironment(envVar.pData, aParam.pData);
     431             :             }
     432           0 :             break;
     433             :         }
     434             :     }
     435             : 
     436           0 :     if (!pDisp && aDisplay.isEmpty())
     437             :     {
     438             :         // Open $DISPLAY or default...
     439           0 :         char *pDisplay = getenv("DISPLAY");
     440           0 :         if (pDisplay != NULL)
     441           0 :             aDisplay = OString(pDisplay);
     442           0 :         pDisp  = XOpenDisplay(pDisplay);
     443             :     }
     444             : 
     445           0 :     if ( !pDisp )
     446             :     {
     447           0 :         OUString aProgramFileURL;
     448           0 :         osl_getExecutableFile( &aProgramFileURL.pData );
     449           0 :         OUString aProgramSystemPath;
     450           0 :         osl_getSystemPathFromFileURL (aProgramFileURL.pData, &aProgramSystemPath.pData);
     451             :         OString  aProgramName = OUStringToOString(
     452             :                                             aProgramSystemPath,
     453           0 :                                             osl_getThreadTextEncoding() );
     454             :         std::fprintf( stderr, "%s X11 error: Can't open display: %s\n",
     455           0 :                 aProgramName.getStr(), aDisplay.getStr());
     456           0 :         std::fprintf( stderr, "   Set DISPLAY environment variable, use -display option\n");
     457           0 :         std::fprintf( stderr, "   or check permissions of your X-Server\n");
     458           0 :         std::fprintf( stderr, "   (See \"man X\" resp. \"man xhost\" for details)\n");
     459           0 :         std::fflush( stderr );
     460           0 :         exit(0);
     461             :     }
     462             : 
     463           0 :     SalX11Display *pSalDisplay = new SalX11Display( pDisp );
     464             : 
     465           0 :     pInputMethod->CreateMethod( pDisp );
     466           0 :     pSalDisplay->SetupInput( pInputMethod );
     467           0 : }
     468             : 
     469             : extern "C" {
     470           0 : void EmitFontpathWarning( void )
     471             : {
     472             :     static Bool bOnce = False;
     473           0 :     if ( !bOnce )
     474             :     {
     475           0 :         bOnce = True;
     476             :         std::fprintf( stderr, "Please verify your fontpath settings\n"
     477             :                 "\t(See \"man xset\" for details"
     478           0 :                 " or ask your system administrator)\n" );
     479             :     }
     480           0 : }
     481             : 
     482             : } /* extern "C" */
     483             : 
     484           0 : static void PrintXError( Display *pDisplay, XErrorEvent *pEvent )
     485             : {
     486           0 :     char msg[ 120 ] = "";
     487             : #if ! ( defined LINUX && defined PPC )
     488           0 :     XGetErrorText( pDisplay, pEvent->error_code, msg, sizeof( msg ) );
     489             : #endif
     490           0 :     std::fprintf( stderr, "X-Error: %s\n", msg );
     491           0 :     if( pEvent->request_code < SAL_N_ELEMENTS( XRequest ) )
     492             :     {
     493           0 :         const char* pName = XRequest[pEvent->request_code];
     494           0 :         if( !pName )
     495           0 :             pName = "BadRequest?";
     496           0 :         std::fprintf( stderr, "\tMajor opcode: %d (%s)\n", pEvent->request_code, pName );
     497             :     }
     498             :     else
     499             :     {
     500           0 :         std::fprintf( stderr, "\tMajor opcode: %d\n", pEvent->request_code );
     501             :         // TODO: also display extension name?
     502           0 :         std::fprintf( stderr, "\tMinor opcode: %d\n", pEvent->minor_code );
     503             :     }
     504             : 
     505             :     std::fprintf( stderr, "\tResource ID:  0x%lx\n",
     506           0 :              pEvent->resourceid );
     507             :     std::fprintf( stderr, "\tSerial No:    %ld (%ld)\n",
     508           0 :              pEvent->serial, LastKnownRequestProcessed(pDisplay) );
     509             : 
     510           0 :     if( !getenv( "SAL_SYNCHRONIZE" ) )
     511             :     {
     512           0 :         std::fprintf( stderr, "These errors are reported asynchronously,\n");
     513           0 :         std::fprintf( stderr, "set environment variable SAL_SYNCHRONIZE to 1 to help debugging\n");
     514             :     }
     515             : 
     516           0 :     std::fflush( stdout );
     517           0 :     std::fflush( stderr );
     518           0 : }
     519             : 
     520           0 : void X11SalData::XError( Display *pDisplay, XErrorEvent *pEvent )
     521             : {
     522           0 :     if( ! m_aXErrorHandlerStack.back().m_bIgnore )
     523             :     {
     524           0 :         if (   (pEvent->error_code   == BadAlloc)
     525           0 :             && (pEvent->request_code == X_OpenFont) )
     526             :         {
     527             :             static Bool bOnce = False;
     528           0 :             if ( !bOnce )
     529             :             {
     530           0 :                 std::fprintf(stderr, "X-Error occurred in a request for X_OpenFont\n");
     531           0 :                 EmitFontpathWarning();
     532             : 
     533           0 :                 bOnce = True ;
     534             :             }
     535           0 :             return;
     536             :         }
     537             :         /* ignore
     538             :         * X_SetInputFocus: it's a hint only anyway
     539             :         * X_GetProperty: this is part of the XGetWindowProperty call and will
     540             :         *                be handled by the return value of that function
     541             :         */
     542           0 :         else if( pEvent->request_code == X_SetInputFocus ||
     543           0 :                  pEvent->request_code == X_GetProperty
     544             :             )
     545           0 :             return;
     546             : 
     547           0 :         if( pDisplay != GetGenericData()->GetSalDisplay()->GetDisplay() )
     548           0 :             return;
     549             : 
     550           0 :         PrintXError( pDisplay, pEvent );
     551             : 
     552           0 :         oslSignalAction eToDo = osl_raiseSignal (OSL_SIGNAL_USER_X11SUBSYSTEMERROR, NULL);
     553           0 :         switch (eToDo)
     554             :         {
     555             :             case osl_Signal_ActIgnore       :
     556           0 :                 return;
     557             :             case osl_Signal_ActAbortApp     :
     558           0 :                 abort();
     559             :             case osl_Signal_ActKillApp      :
     560           0 :                 exit(0);
     561             :             case osl_Signal_ActCallNextHdl  :
     562           0 :                 break;
     563             :             default :
     564           0 :                 break;
     565             :         }
     566             : 
     567             :     }
     568             : 
     569           0 :     m_aXErrorHandlerStack.back().m_bWas = true;
     570             : }
     571             : 
     572             : struct YieldEntry
     573             : {
     574             :     YieldEntry* next;       // pointer to next entry
     575             :     int         fd;         // file descriptor for reading
     576             :     void*           data;       // data for predicate and callback
     577             :     YieldFunc       pending;    // predicate (determins pending events)
     578             :     YieldFunc       queued;     // read and queue up events
     579             :     YieldFunc       handle;     // handle pending events
     580             : 
     581           0 :     inline int  HasPendingEvent()   const { return pending( fd, data ); }
     582           0 :     inline int  IsEventQueued()     const { return queued( fd, data ); }
     583           0 :     inline void HandleNextEvent()   const { handle( fd, data ); }
     584             : };
     585             : 
     586             : #define MAX_NUM_DESCRIPTORS 128
     587             : 
     588             : static YieldEntry yieldTable[ MAX_NUM_DESCRIPTORS ];
     589             : 
     590           0 : void SalXLib::Insert( int nFD, void* data,
     591             :                       YieldFunc     pending,
     592             :                       YieldFunc     queued,
     593             :                       YieldFunc     handle )
     594             : {
     595             :     DBG_ASSERT( nFD, "can not insert stdin descriptor" );
     596             :     DBG_ASSERT( !yieldTable[nFD].fd, "SalXLib::Insert fd twice" );
     597             : 
     598           0 :     yieldTable[nFD].fd      = nFD;
     599           0 :     yieldTable[nFD].data    = data;
     600           0 :     yieldTable[nFD].pending = pending;
     601           0 :     yieldTable[nFD].queued  = queued;
     602           0 :     yieldTable[nFD].handle  = handle;
     603             : 
     604           0 :     FD_SET( nFD, &aReadFDS_ );
     605           0 :     FD_SET( nFD, &aExceptionFDS_ );
     606             : 
     607           0 :     if( nFD >= nFDs_ )
     608           0 :         nFDs_ = nFD + 1;
     609           0 : }
     610             : 
     611           0 : void SalXLib::Remove( int nFD )
     612             : {
     613           0 :     FD_CLR( nFD, &aReadFDS_ );
     614           0 :     FD_CLR( nFD, &aExceptionFDS_ );
     615             : 
     616           0 :     yieldTable[nFD].fd = 0;
     617             : 
     618           0 :     if ( nFD == nFDs_ )
     619             :     {
     620           0 :         for ( nFD = nFDs_ - 1;
     621           0 :               nFD >= 0 && !yieldTable[nFD].fd;
     622             :               nFD-- ) ;
     623             : 
     624           0 :         nFDs_ = nFD + 1;
     625             :     }
     626           0 : }
     627             : 
     628           0 : bool SalXLib::CheckTimeout( bool bExecuteTimers )
     629             : {
     630           0 :     bool bRet = false;
     631           0 :     if( m_aTimeout.tv_sec ) // timer is started
     632             :     {
     633             :         timeval aTimeOfDay;
     634           0 :         gettimeofday( &aTimeOfDay, 0 );
     635           0 :         if( aTimeOfDay >= m_aTimeout )
     636             :         {
     637           0 :             bRet = true;
     638           0 :             if( bExecuteTimers )
     639             :             {
     640             :                 // timed out, update timeout
     641           0 :                 m_aTimeout = aTimeOfDay;
     642             :                 /*
     643             :                 *  #107827# autorestart immediately, will be stopped (or set
     644             :                 *  to different value in notify hdl if necessary;
     645             :                 *  CheckTimeout should return false while
     646             :                 *  timers are being dispatched.
     647             :                 */
     648           0 :                 m_aTimeout += m_nTimeoutMS;
     649             :                 // notify
     650           0 :                 GetX11SalData()->Timeout();
     651             :             }
     652             :         }
     653             :     }
     654           0 :     return bRet;
     655             : }
     656             : 
     657           0 : void SalXLib::Yield( bool bWait, bool bHandleAllCurrentEvents )
     658             : {
     659             :     // check for timeouts here if you want to make screenshots
     660           0 :     static char* p_prioritize_timer = getenv ("SAL_HIGHPRIORITY_REPAINT");
     661           0 :     if (p_prioritize_timer != NULL)
     662           0 :         CheckTimeout();
     663             : 
     664           0 :     const int nMaxEvents = bHandleAllCurrentEvents ? 100 : 1;
     665             : 
     666             :     // first, check for already queued events.
     667           0 :     for ( int nFD = 0; nFD < nFDs_; nFD++ )
     668             :     {
     669           0 :         YieldEntry* pEntry = &(yieldTable[nFD]);
     670           0 :         if ( pEntry->fd )
     671             :         {
     672             :             DBG_ASSERT( nFD == pEntry->fd, "wrong fd in Yield()" );
     673           0 :             for( int i = 0; i < nMaxEvents && pEntry->HasPendingEvent(); i++ )
     674             :             {
     675           0 :                 pEntry->HandleNextEvent();
     676           0 :                 if( ! bHandleAllCurrentEvents )
     677           0 :                     return;
     678             :             }
     679             :         }
     680             :     }
     681             : 
     682             :     // next, select with or without timeout according to bWait.
     683           0 :     int      nFDs         = nFDs_;
     684           0 :     fd_set   ReadFDS      = aReadFDS_;
     685           0 :     fd_set   ExceptionFDS = aExceptionFDS_;
     686           0 :     int      nFound       = 0;
     687             : 
     688           0 :     timeval  Timeout      = noyield__;
     689           0 :     timeval *pTimeout     = &Timeout;
     690             : 
     691           0 :     if (bWait)
     692             :     {
     693           0 :         pTimeout = 0;
     694           0 :         if (m_aTimeout.tv_sec) // Timer is started.
     695             :         {
     696             :             // determine remaining timeout.
     697           0 :             gettimeofday (&Timeout, 0);
     698           0 :             Timeout = m_aTimeout - Timeout;
     699           0 :             if (yield__ >= Timeout)
     700             :             {
     701             :                 // guard against micro timeout.
     702           0 :                 Timeout = yield__;
     703             :             }
     704           0 :             pTimeout = &Timeout;
     705             :         }
     706             :     }
     707             : 
     708             :     {
     709             :         // release YieldMutex (and re-acquire at block end)
     710           0 :         SalYieldMutexReleaser aReleaser;
     711           0 :         nFound = select( nFDs, &ReadFDS, NULL, &ExceptionFDS, pTimeout );
     712             :     }
     713           0 :     if( nFound < 0 ) // error
     714             :     {
     715             : #ifdef DBG_UTIL
     716             :         std::fprintf( stderr, "SalXLib::Yield e=%d f=%d\n", errno, nFound );
     717             : #endif
     718           0 :         if( EINTR == errno )
     719             :         {
     720           0 :             errno = 0;
     721             :         }
     722             :     }
     723             : 
     724             :     // usually handle timeouts here (as in 5.2)
     725           0 :     if (p_prioritize_timer == NULL)
     726           0 :         CheckTimeout();
     727             : 
     728             :     // handle wakeup events.
     729           0 :     if ((nFound > 0) && (FD_ISSET(m_pTimeoutFDS[0], &ReadFDS)))
     730             :     {
     731             :         int buffer;
     732           0 :         while (read (m_pTimeoutFDS[0], &buffer, sizeof(buffer)) > 0)
     733           0 :             continue;
     734           0 :         nFound -= 1;
     735             :     }
     736             : 
     737             :     // handle other events.
     738           0 :     if( nFound > 0 )
     739             :     {
     740             :         // now we are in the protected section !
     741             :         // recall select if we have acquired fd's, ready for reading,
     742             : 
     743           0 :         struct timeval noTimeout = { 0, 0 };
     744             :         nFound = select( nFDs_, &ReadFDS, NULL,
     745           0 :                          &ExceptionFDS, &noTimeout );
     746             : 
     747             :         // someone-else has done the job for us
     748           0 :         if (nFound == 0)
     749           0 :             return;
     750             : 
     751           0 :         for ( int nFD = 0; nFD < nFDs_; nFD++ )
     752             :         {
     753           0 :             YieldEntry* pEntry = &(yieldTable[nFD]);
     754           0 :             if ( pEntry->fd )
     755             :             {
     756           0 :                 if ( FD_ISSET( nFD, &ExceptionFDS ) ) {
     757             : #if OSL_DEBUG_LEVEL > 1
     758             :                     std::fprintf( stderr, "SalXLib::Yield exception\n" );
     759             : #endif
     760           0 :                     nFound--;
     761             :                 }
     762           0 :                 if ( FD_ISSET( nFD, &ReadFDS ) )
     763             :                 {
     764           0 :                     for( int i = 0; pEntry->IsEventQueued() && i < nMaxEvents; i++ )
     765             :                     {
     766           0 :                         pEntry->HandleNextEvent();
     767             :                         // if a recursive call has done the job
     768             :                         // so abort here
     769             :                     }
     770           0 :                     nFound--;
     771             :                 }
     772             :             }
     773             :         }
     774             :     }
     775             : }
     776             : 
     777           0 : void SalXLib::Wakeup()
     778             : {
     779           0 :     OSL_VERIFY(write (m_pTimeoutFDS[1], "", 1) == 1);
     780           0 : }
     781             : 
     782           0 : void SalXLib::PostUserEvent()
     783             : {
     784           0 :     Wakeup();
     785           0 : }
     786             : 
     787             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10