Attachment #44939 for issue #75228

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

Lines 37-42 Link Here

(-)vcl/aqua/inc/saldata.hxx (+16 lines)
37	#ifndef _SV_SALDATA_HXX	37	#ifndef _SV_SALDATA_HXX
38	#define _SV_SALDATA_HXX	38	#define _SV_SALDATA_HXX
39		39
		40	#include <premac.h>
		41	#include <Carbon/Carbon.h>
		42	#include <postmac.h>
		43
		44
40	#ifndef _SV_SV_H	45	#ifndef _SV_SV_H
41	#include <sv.h>	46	#include <sv.h>
42	#endif	47	#endif
Lines 75-80 Link Here
75	SalVirtualDevice *mpFirstVD; // first VirDev	80	SalVirtualDevice *mpFirstVD; // first VirDev
76	SalPrinter *mpFirstPrinter; // first printing printer	81	SalPrinter *mpFirstPrinter; // first printing printer
77	SystemFontList* mpFontList;	82	SystemFontList* mpFontList;
		83
		84	/*
		85	* SalTimer related members
		86	*/
		87	BOOL mbInTimerProc; // timer event is currently being dispatched
		88	BOOL mbTimerInstalled; // timer is in the event loop
		89	ULONG mnTimerMS; // Current Time (in MS) of the Timer
		90	ULONG mnTimerOrgMS; // Current Original Time (in MS)
		91
		92	EventLoopTimerRef mrTimerRef;
		93	EventLoopTimerUPP mrTimerUPP;
78	};	94	};
79		95
80	inline void SetSalData( SalData* pData ) { ImplGetSVData()->mpSalData = (void*)pData; }	96	inline void SetSalData( SalData* pData ) { ImplGetSVData()->mpSalData = (void*)pData; }





#include <premac.h>
#include <CoreServices/CoreServices.h>
#include <Carbon/Carbon.h>
#include <postmac.h>

#ifndef _SV_SALTIMER_HXX


class AquaSalTimer : public SalTimer
{
  public:

	BOOL			mbInstalled;	// timer task is in queue
	long			mMS;			// current timer interval in msec
	BOOL			InstallTask();  // installs timer task and returns status
	
public:
    AquaSalTimer();
    virtual ~AquaSalTimer();

	void Start( ULONG nMS );
	void Stop();


	// restarts active tasks using the current timeout
	// optional with different timeout (when nMS is != 0)
	void			ReStart( ULONG nMS = 0 );
};

#endif





// =======================================================================


#define USEMAINTHREAD 1

void ImplSalStartTimer ( ULONG nMS, BOOL bMutex)
{
    fprintf(stderr, "ImplSalStartTimer\n");

    SalData* pSalData = GetSalData();

    // Store the new timeout
	pSalData->mnTimerMS = nMS;

    if ( !bMutex )
		pSalData->mnTimerOrgMS = nMS;

    // Cancel current timer
    if( pSalData->mbTimerInstalled )
        RemoveEventLoopTimer( pSalData->mrTimerRef );

	// Install the timer task
	if( InstallEventLoopTimer( GetMainEventLoop(),
                               kEventDurationMillisecond * nMS,
                               kEventDurationForever,
                               pSalData->mrTimerUPP,
                               NULL,
                               &pSalData->mrTimerRef) == noErr )
		pSalData->mbTimerInstalled = TRUE;
	else
    {
        fprintf(stderr, "Could not install timer task!\n");
        pSalData->mbTimerInstalled = FALSE;
    }
}

void AquaSalTimerProc ( EventLoopTimerRef theTimer, void * /* userData */)
{
    fprintf(stderr, "...AquaSalTimerProc...\n");

    SalData* pSalData = GetSalData();
	ImplSVData* pSVData = ImplGetSVData();

    AquaSalTimer *pSalTimer = (AquaSalTimer*) pSVData->mpSalTimer;

    if( pSalTimer && !pSalData->mbInTimerProc )
	{
#ifdef USEMAINTHREAD
        // Send event to the main thread
        SalData* pSalData = GetSalData();
        AquaSalFrame *pFrame = dynamic_cast<AquaSalFrame*>(pSalData->mpFirstFrame);

        if( pFrame )
            pFrame->PostTimerEvent( pSalTimer );

        // FIXME?
        // fire again using current timeout as this is a single shot timer
        ImplSalStartTimer( pSalData->mnTimerOrgMS, FALSE );
#else
        // call back directly from timer thread
		if( ImplSalYieldMutexTryToAcquire() )
		{
            pSalData->mbInTimerProc = TRUE;
			pSalTimer->CallCallback();
            pSalData->mbInTimerProc = FALSE;
			ImplSalYieldMutexRelease();

            // FIXME?
			// fire again using current timeout as this is a single shot timer
            ImplSalStartTimer( pSalData->mnTimerOrgMS, FALSE );
		}
		else
		{
			// could not acquire solar mutex, so
			// fire again with a short delay (10ms)
            fprintf(stderr, "SHOULD NOT HAPPEN! TIMER: solar mutex not free\n");
            ImplSalStartTimer( 10, TRUE );
		}

#endif


AquaSalTimer::AquaSalTimer( )
{
    fprintf(stderr, "AquaSalTimer::AquaSalTimer\n");
    SalData* pSalData = GetSalData();

	pSalData->mbTimerInstalled = FALSE;
	pSalData->mnTimerMS = 0;
	pSalData->mnTimerOrgMS = 0;
	pSalData->mrTimerUPP = NewEventLoopTimerUPP( AquaSalTimerProc );
}

AquaSalTimer::~AquaSalTimer()
{
    fprintf(stderr, "AquaSalTimer::~AquaSalTimer\n");
		RemoveTimeTask( (QElemPtr) &mTask );
	DisposeTimerUPP( mTask.tmAddr );
}

    SalData* pSalData = GetSalData();
	if( pSalData->mbTimerInstalled )
        RemoveEventLoopTimer( pSalData->mrTimerRef );

	DisposeEventLoopTimerUPP( pSalData->mrTimerUPP );
}

void AquaSalTimer::Start( ULONG nMS )
{
    fprintf(stderr, "AquaSalTimer::Start(%lu ms)\n", nMS);

    ImplSalStartTimer(nMS, FALSE);
	
	// store new timeout
	mMS = nMS;

	// install the timer task
	mbInstalled = InstallTask();
	
	// fire
	if( mbInstalled )
		PrimeTimeTask( (QElemPtr) &mTask, mMS );
}

void AquaSalTimer::ReStart( ULONG nMS )
{
	if( mbInstalled )
		// use current timeout if nMS == 0
		PrimeTimeTask( (QElemPtr) &mTask, nMS ? nMS : mMS );
}

void AquaSalTimer::Stop()
{
    fprintf(stderr, "AquaSalTimer::Stop\n");
	{
		RemoveTimeTask( (QElemPtr) &mTask );
		mbInstalled = FALSE;
	}
}

    SalData* pSalData = GetSalData();
	if( pSalData->mbTimerInstalled )
	// install the timer task
	mTask.tmWakeUp = 0;
	mTask.tmCount = 0;
	if( InstallTimeTask( (QElemPtr) &mTask ) == noErr )
		return TRUE;
	else
	{
        // FIXME
        RemoveEventLoopTimer( pSalData->mrTimerRef );
		pSalData->mbTimerInstalled = FALSE;
	}
}

// -----------------------------------------------------------------------

Return to issue 75228

Lines 48-88 Link Here

(-)vcl/aqua/source/app/saltimer.cxx (-58 / +74 lines)
48		48
49	// =======================================================================	49	// =======================================================================
50		50
51
52	#define USEMAINTHREAD 1	51	#define USEMAINTHREAD 1
53		52
54	void AquaSalTimerProc ( TMTaskPtr tmTaskPtr )	53	void ImplSalStartTimer ( ULONG nMS, BOOL bMutex)
55	{	54	{
		55	fprintf(stderr, "ImplSalStartTimer\n");
		56
		57	SalData* pSalData = GetSalData();
		58
		59	// Store the new timeout
		60	pSalData->mnTimerMS = nMS;
		61
		62	if ( !bMutex )
		63	pSalData->mnTimerOrgMS = nMS;
		64
		65	// Cancel current timer
		66	if( pSalData->mbTimerInstalled )
		67	RemoveEventLoopTimer( pSalData->mrTimerRef );
		68
		69	// Install the timer task
		70	if( InstallEventLoopTimer( GetMainEventLoop(),
		71	kEventDurationMillisecond * nMS,
		72	kEventDurationForever,
		73	pSalData->mrTimerUPP,
		74	NULL,
		75	&pSalData->mrTimerRef) == noErr )
		76	pSalData->mbTimerInstalled = TRUE;
		77	else
		78	{
		79	fprintf(stderr, "Could not install timer task!\n");
		80	pSalData->mbTimerInstalled = FALSE;
		81	}
		82	}
		83
		84	void AquaSalTimerProc ( EventLoopTimerRef theTimer, void * /* userData */)
		85	{
		86	fprintf(stderr, "...AquaSalTimerProc...\n");
		87
		88	SalData* pSalData = GetSalData();
56	ImplSVData* pSVData = ImplGetSVData();	89	ImplSVData* pSVData = ImplGetSVData();
57		90
58	AquaSalTimer pSalTimer = (AquaSalTimer) pSVData->mpSalTimer;	91	AquaSalTimer pSalTimer = (AquaSalTimer) pSVData->mpSalTimer;
59	if( pSalTimer )	92
		93	if( pSalTimer && !pSalData->mbInTimerProc )
60	{	94	{
61	#ifdef USEMAINTHREAD	95	#ifdef USEMAINTHREAD
62	// send event to main thread	96	// Send event to the main thread
63	SalData* pSalData = GetSalData();
64	AquaSalFrame pFrame = dynamic_cast<AquaSalFrame>(pSalData->mpFirstFrame);	97	AquaSalFrame pFrame = dynamic_cast<AquaSalFrame>(pSalData->mpFirstFrame);
65		98
66	if( pFrame )	99	if( pFrame )
67	pFrame->PostTimerEvent( pSalTimer );	100	pFrame->PostTimerEvent( pSalTimer );
		101
		102	// FIXME?
68	// fire again using current timeout as this is a single shot timer	103	// fire again using current timeout as this is a single shot timer
69	pSalTimer->ReStart();	104	ImplSalStartTimer( pSalData->mnTimerOrgMS, FALSE );
70	#else	105	#else
71	// call back directly from timer thread	106	// call back directly from timer thread
72	if( ImplSalYieldMutexTryToAcquire() )	107	if( ImplSalYieldMutexTryToAcquire() )
73	{	108	{
		109	pSalData->mbInTimerProc = TRUE;
74	pSalTimer->CallCallback();	110	pSalTimer->CallCallback();
		111	pSalData->mbInTimerProc = FALSE;
75	ImplSalYieldMutexRelease();	112	ImplSalYieldMutexRelease();
76		113
		114	// FIXME?
77	// fire again using current timeout as this is a single shot timer	115	// fire again using current timeout as this is a single shot timer
78	pSalTimer->ReStart();	116	ImplSalStartTimer( pSalData->mnTimerOrgMS, FALSE );
79	}	117	}
80	else	118	else
81	{	119	{
82	// could not acquire solar mutex, so	120	// could not acquire solar mutex, so
83	// fire again with a short delay (10ms)	121	// fire again with a short delay (10ms)
84	//fprintf(stderr, "TIMER: solar mutex not free\n");	122	fprintf(stderr, "SHOULD NOT HAPPEN! TIMER: solar mutex not free\n");
85	pSalTimer->ReStart( 10 );	123	ImplSalStartTimer( 10, TRUE );
86	}	124	}
87		125
88	#endif	126	#endif
Lines 93-157 Link Here
93		131
94	AquaSalTimer::AquaSalTimer( )	132	AquaSalTimer::AquaSalTimer( )
95	{	133	{
96	mbInstalled = FALSE;	134	fprintf(stderr, "AquaSalTimer::AquaSalTimer\n");
97	mMS = 0;	135	SalData* pSalData = GetSalData();
98	mTask.tmAddr = NewTimerUPP( AquaSalTimerProc );	136
		137	pSalData->mbTimerInstalled = FALSE;
		138	pSalData->mnTimerMS = 0;
		139	pSalData->mnTimerOrgMS = 0;
		140	pSalData->mrTimerUPP = NewEventLoopTimerUPP( AquaSalTimerProc );
99	}	141	}
100		142
101	AquaSalTimer::~AquaSalTimer()	143	AquaSalTimer::~AquaSalTimer()
102	{	144	{
103	if( mbInstalled )	145	fprintf(stderr, "AquaSalTimer::~AquaSalTimer\n");
104	RemoveTimeTask( (QElemPtr) &mTask );
105	DisposeTimerUPP( mTask.tmAddr );
106	}
107		146
108	// -----------------------------------------------------------------------	147	SalData* pSalData = GetSalData();
		148	if( pSalData->mbTimerInstalled )
		149	RemoveEventLoopTimer( pSalData->mrTimerRef );
		150
		151	DisposeEventLoopTimerUPP( pSalData->mrTimerUPP );
		152	}
109		153
110	void AquaSalTimer::Start( ULONG nMS )	154	void AquaSalTimer::Start( ULONG nMS )
111	{	155	{
112	// cancel current timer	156	fprintf(stderr, "AquaSalTimer::Start(%lu ms)\n", nMS);
113	if( mbInstalled )	157
114	RemoveTimeTask( (QElemPtr) &mTask );	158	ImplSalStartTimer(nMS, FALSE);
115
116	// store new timeout
117	mMS = nMS;
118
119	// install the timer task
120	mbInstalled = InstallTask();
121
122	// fire
123	if( mbInstalled )
124	PrimeTimeTask( (QElemPtr) &mTask, mMS );
125	}
126
127	void AquaSalTimer::ReStart( ULONG nMS )
128	{
129	if( mbInstalled )
130	// use current timeout if nMS == 0
131	PrimeTimeTask( (QElemPtr) &mTask, nMS ? nMS : mMS );
132	}	159	}
133		160
134	void AquaSalTimer::Stop()	161	void AquaSalTimer::Stop()
135	{	162	{
136	if( mbInstalled )	163	fprintf(stderr, "AquaSalTimer::Stop\n");
137	{
138	RemoveTimeTask( (QElemPtr) &mTask );
139	mbInstalled = FALSE;
140	}
141	}
142		164
143	BOOL AquaSalTimer::InstallTask()	165	SalData* pSalData = GetSalData();
144	{	166	if( pSalData->mbTimerInstalled )
145	// install the timer task
146	mTask.tmWakeUp = 0;
147	mTask.tmCount = 0;
148	if( InstallTimeTask( (QElemPtr) &mTask ) == noErr )
149	return TRUE;
150	else
151	{	167	{
152	fprintf(stderr, "Could not install timer task!\n");	168	// FIXME
153	return FALSE;	169	RemoveEventLoopTimer( pSalData->mrTimerRef );
		170	pSalData->mbTimerInstalled = FALSE;
154	}	171	}
155	}	172	}
156		173
157	// -----------------------------------------------------------------------

Lines 38-43 Link Here

(-)vcl/aqua/inc/saltimer.h (-15 / +7 lines)
38		38
39	#include <premac.h>	39	#include <premac.h>
40	#include <CoreServices/CoreServices.h>	40	#include <CoreServices/CoreServices.h>
		41	#include <Carbon/Carbon.h>
41	#include <postmac.h>	42	#include <postmac.h>
42		43
43	#ifndef _SV_SALTIMER_HXX	44	#ifndef _SV_SALTIMER_HXX
Lines 46-68 Link Here
46		47
47	class AquaSalTimer : public SalTimer	48	class AquaSalTimer : public SalTimer
48	{	49	{
49	private:	50	public:
50	TMTask mTask; // the timer task	51
51	BOOL mbInstalled; // timer task is in queue
52	long mMS; // current timer interval in msec
53	BOOL InstallTask(); // installs timer task and returns status
54
55	public:
56	AquaSalTimer();	52	AquaSalTimer();
57	virtual ~AquaSalTimer();	53	virtual ~AquaSalTimer();
58		54
59	// overload all pure virtual methods	55	void Start( ULONG nMS );
60	void Start( ULONG nMS );	56	void Stop();
61	void Stop();	57
62
63	// restarts active tasks using the current timeout
64	// optional with different timeout (when nMS is != 0)
65	void ReStart( ULONG nMS = 0 );
66	};	58	};
67		59
68	#endif	60	#endif