Attachment #7554 for issue #16621

View | Details | Raw Unified | Return to issue 16621
Collapse All | Expand All




 
#ifdef UNX
#ifdef MACOSX
#if ( __GNUC__ < 3 )
#ifdef BOOTSTRAPPER
#include <glibc/posix/getopt.h>
#else
#include <glibc/getopt.h>
#endif
#endif
#endif
#include <unistd.h>




					Time();
					Time( const ResId & rResId );
					Time( long _nTime ) { Time::nTime = _nTime; }
					Time( const Time& rTime );
						{ nTime = rTime.nTime; }
					Time( ULONG nHour, ULONG nMin,
						  ULONG nSec = 0, ULONG n100Sec = 0 );


	void			ConvertToUTC()		 { *this -= Time::GetUTCOffset(); }
	void			ConvertToLocalTime() { *this += Time::GetUTCOffset(); }

	Time&			operator =( const Time& rTime );
						{ nTime = rTime.nTime; return *this; }
	Time			operator -() const
						{ return Time( nTime * -1 ); }
	Time&			operator +=( const Time& rTime );

Lines 208-213 Link Here

(-)source/datetime/ttime.cxx (+15 lines)
208		208
209	// -----------------------------------------------------------------------	209	// -----------------------------------------------------------------------
210		210
		211	Time::Time( const Time& rTime )
		212	{
		213	nTime = rTime.nTime;
		214	}
		215
		216	// -----------------------------------------------------------------------
		217
211	Time::Time( ULONG nHour, ULONG nMin, ULONG nSec, ULONG n100Sec )	218	Time::Time( ULONG nHour, ULONG nMin, ULONG nSec, ULONG n100Sec )
212	{	219	{
213	// Zeit normalisieren	220	// Zeit normalisieren
Lines 324-329 Link Here
324	double n100Sec = Get100Sec();	331	double n100Sec = Get100Sec();
325		332
326	return (nHour+(nMin/60)+(nSec/(6060))+(n100Sec/(6060100))) / 24 nSign;	333	return (nHour+(nMin/60)+(nSec/(6060))+(n100Sec/(6060100))) / 24 nSign;
		334	}
		335
		336	// -----------------------------------------------------------------------
		337
		338	Time& Time::operator =( const Time& rTime )
		339	{
		340	nTime = rTime.nTime;
		341	return *this;
327	}	342	}
328		343
329	// -----------------------------------------------------------------------	344	// -----------------------------------------------------------------------

Lines 72-77 Link Here

(-)source/intntl/intnunx.cxx (-1 / +42 lines)
72	#include <isolang.hxx>	72	#include <isolang.hxx>
73	#endif	73	#endif
74		74
		75	#ifdef MACOSX
		76	#ifndef _OSL_PROCESS_H_
		77	#include <osl/process.h>
		78	#endif
		79	#ifndef _RTL_LOCALE_H_
		80	#include <rtl/locale.h>
		81	#endif
		82	#endif
		83
75	// =======================================================================	84	// =======================================================================
76		85
77	static LanguageType eImplSystemLanguage = LANGUAGE_DONTKNOW;	86	static LanguageType eImplSystemLanguage = LANGUAGE_DONTKNOW;
Lines 139-146 Link Here
139	{	148	{
140	if ( eImplSystemLanguage == LANGUAGE_DONTKNOW )	149	if ( eImplSystemLanguage == LANGUAGE_DONTKNOW )
141	{	150	{
		151	#ifdef MACOSX
		152	rtl_Locale *procLocale;
		153
		154	if ( osl_getProcessLocale(&procLocale) == osl_Process_E_None )
		155	{
		156	UniString rLang( procLocale->Language->buffer );
		157	UniString rCountry( procLocale->Country->buffer );
		158
		159	eImplSystemLanguage = ConvertIsoNamesToLanguage( rLang, rCountry );
		160	#ifdef DEBUG
		161	if ( eImplSystemLanguage == LANGUAGE_DONTKNOW )
		162	fprintf( stderr, "intnunx.cxx: failed to convert osl_getProcessLocale() language to system language.\n" );
		163	#endif
		164	}
		165	#else /* MACOSX */
142	ByteString aUnxLang (GetLangFromEnvironment());	166	ByteString aUnxLang (GetLangFromEnvironment());
143	eImplSystemLanguage = ConvertUnxByteStringToLanguage( aUnxLang );	167	eImplSystemLanguage = ConvertUnxByteStringToLanguage( aUnxLang );
		168	#endif /* MACOSX */
144	}	169	}
145	return eImplSystemLanguage;	170	return eImplSystemLanguage;
146	}	171	}
Lines 157-164 Link Here
157	{	182	{
158	if ( eImplSystemLanguage == LANGUAGE_DONTKNOW )	183	if ( eImplSystemLanguage == LANGUAGE_DONTKNOW )
159	{	184	{
160	ByteString aUnxLang (GetUILangFromEnvironment());	185	#ifdef MACOSX
		186	rtl_Locale *procLocale;
		187
		188	if ( osl_getProcessLocale(&procLocale) == osl_Process_E_None )
		189	{
		190	UniString rLang( procLocale->Language->buffer );
		191	UniString rCountry( procLocale->Country->buffer );
		192
		193	eImplSystemLanguage = ConvertIsoNamesToLanguage( rLang, rCountry );
		194	#ifdef DEBUG
		195	if ( eImplSystemLanguage == LANGUAGE_DONTKNOW )
		196	fprintf( stderr, "intnunx.cxx: failed to convert osl_getProcessLocale() language to system language.\n" );
		197	#endif
		198	}
		199	#else /* MACOSX */
		200	ByteString aUnxLang (GetLangFromEnvironment());
161	eImplSystemLanguage = ConvertUnxByteStringToLanguage( aUnxLang );	201	eImplSystemLanguage = ConvertUnxByteStringToLanguage( aUnxLang );
		202	#endif /* MACOSX */
162	}	203	}
163	return eImplSystemLanguage;	204	return eImplSystemLanguage;
164	}	205	}

Return to issue 16621

Lines 72-81 Link Here

(-)bootstrp/cppdep.cxx (+2 lines)
72		72
73	#ifdef UNX	73	#ifdef UNX
74	#ifdef MACOSX	74	#ifdef MACOSX
		75	#if ( __GNUC__ < 3 )
75	#ifdef BOOTSTRAPPER	76	#ifdef BOOTSTRAPPER
76	#include <glibc/posix/getopt.h>	77	#include <glibc/posix/getopt.h>
77	#else	78	#else
78	#include <glibc/getopt.h>	79	#include <glibc/getopt.h>
		80	#endif
79	#endif	81	#endif
80	#endif	82	#endif
81	#include <unistd.h>	83	#include <unistd.h>

Lines 81-88 Link Here

(-)inc/time.hxx (-4 / +2 lines)
81	Time();	81	Time();
82	Time( const ResId & rResId );	82	Time( const ResId & rResId );
83	Time( long _nTime ) { Time::nTime = _nTime; }	83	Time( long _nTime ) { Time::nTime = _nTime; }
84	Time( const Time& rTime )	84	Time( const Time& rTime );
85	{ nTime = rTime.nTime; }
86	Time( ULONG nHour, ULONG nMin,	85	Time( ULONG nHour, ULONG nMin,
87	ULONG nSec = 0, ULONG n100Sec = 0 );	86	ULONG nSec = 0, ULONG n100Sec = 0 );
88		87
Lines 137-144 Link Here
137	void ConvertToUTC() { *this -= Time::GetUTCOffset(); }	136	void ConvertToUTC() { *this -= Time::GetUTCOffset(); }
138	void ConvertToLocalTime() { *this += Time::GetUTCOffset(); }	137	void ConvertToLocalTime() { *this += Time::GetUTCOffset(); }
139		138
140	Time& operator =( const Time& rTime )	139	Time& operator =( const Time& rTime );
141	{ nTime = rTime.nTime; return *this; }
142	Time operator -() const	140	Time operator -() const
143	{ return Time( nTime * -1 ); }	141	{ return Time( nTime * -1 ); }
144	Time& operator +=( const Time& rTime );	142	Time& operator +=( const Time& rTime );