Attachment #70014 for issue #112421

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




            {
                gint nMonitors = gdk_screen_get_n_monitors(pScreen);
                m_aXineramaScreens = std::vector<Rectangle>();
                m_aXineramaScreenIndexMap = std::vector<int>(nMonitors);
                for (gint i = 0; i < nMonitors; ++i)
                {
                    GdkRectangle dest;
                    gdk_screen_get_monitor_geometry(pScreen, i, &dest);
                    addXineramaScreenUnique( i, dest.x, dest.y, dest.width, dest.height );
                }
                m_bXinerama = m_aXineramaScreens.size() > 1;
                if( ! m_aFrames.empty() )

    }
}

extern "C"
{
    typedef gint(* screen_get_primary_monitor)(GdkScreen *screen);
}

int GtkSalDisplay::GetDefaultMonitorNumber() const
{
    GdkScreen* pScreen = gdk_display_get_screen( m_pGdkDisplay, m_nDefaultScreen );
#if GTK_CHECK_VERSION(2,20,0)
    return m_aXineramaScreenIndexMap[gdk_screen_get_primary_monitor(pScreen)];
#else
    static screen_get_primary_monitor sym_gdk_screen_get_primary_monitor =
        (screen_get_primary_monitor)osl_getAsciiFunctionSymbol( GetSalData()->m_pPlugin, "gdk_screen_get_primary_monitor" );
    if (sym_gdk_screen_get_primary_monitor)
        return sym_gdk_screen_get_primary_monitor( pScreen );
    //gdk_screen_get_primary_monitor unavailable, take the first laptop monitor as the default
    gint nMonitors = gdk_screen_get_n_monitors(pScreen);
    for (gint i = 0; i < nMonitors; ++i)
    {
        if (g_ascii_strncasecmp (gdk_screen_get_monitor_plug_name(pScreen, i), "LVDS", 4) == 0)
            return m_aXineramaScreenIndexMap[i];
    }
    return 0;
#endif
}

void GtkSalDisplay::initScreen( int nScreen ) const
{
    if( nScreen < 0 || nScreen >= static_cast<int>(m_aScreens.size()) )

Lines 73-78 Link Here

(-)vcl.orig/unx/inc/plugins/gtk/gtkdata.hxx (+2 lines)
73	virtual long Dispatch( XEvent *pEvent );	73	virtual long Dispatch( XEvent *pEvent );
74	virtual void initScreen( int nScreen ) const;	74	virtual void initScreen( int nScreen ) const;
75		75
		76	virtual int GetDefaultMonitorNumber() const;
		77
76	static GdkFilterReturn filterGdkEvent( GdkXEvent* sys_event,	78	static GdkFilterReturn filterGdkEvent( GdkXEvent* sys_event,
77	GdkEvent* event,	79	GdkEvent* event,
78	gpointer data );	80	gpointer data );





    bool			m_bXinerama;
    std::vector< Rectangle > m_aXineramaScreens;
    std::vector< int > m_aXineramaScreenIndexMap;
    std::list<SalFrame*> m_aFrames;
    std::list<SalObject*> m_aSalObjects;
    

    int             processRandREvent( XEvent* );

    void			doDestruct();
    void            addXineramaScreenUnique( int i, long i_nX, long i_nY, long i_nWidth, long i_nHeight );
public:
	static	SalDisplay	   *GetSalDisplay( Display* display );
	static	BOOL			BestVisual( Display     *pDisp,

	XLIB_Window		GetDrawable( int nScreen ) const { return getDataForScreen( nScreen ).m_aRefWindow; }
	Display		   *GetDisplay() const { return pDisp_; }
	int				GetDefaultScreenNumber() const { return m_nDefaultScreen; }
	virtual int		GetDefaultMonitorNumber() const { return 0; }
    const Size&     GetScreenSize( int nScreen ) const { return getDataForScreen( nScreen ).m_aSize; }
	srv_vendor_t	GetServerVendor() const { return meServerVendor; }
	void			SetServerVendor() { meServerVendor = sal_GetServerVendor(pDisp_); }




             sal::static_int_cast< unsigned int >(GetVisual(m_nDefaultScreen).GetVisualId()) );
}

void SalDisplay::addXineramaScreenUnique( int i, long i_nX, long i_nY, long i_nWidth, long i_nHeight )
{
    // see if any frame buffers are at the same coordinates
    // this can happen with weird configuration e.g. on

            if( m_aXineramaScreens[n].GetWidth() < i_nWidth ||
                m_aXineramaScreens[n].GetHeight() < i_nHeight )
            {
                m_aXineramaScreenIndexMap[i] = n;
                m_aXineramaScreens[n].SetSize( Size( i_nWidth, i_nHeight ) );
            }
            return;
        }
    }
    m_aXineramaScreenIndexMap[i] = m_aXineramaScreens.size();
    m_aXineramaScreens.push_back( Rectangle( Point( i_nX, i_nY ), Size( i_nWidth, i_nHeight ) ) );
}


            m_bXinerama = true;
            m_aXineramaScreens = std::vector<Rectangle>();
            for( int i = 0; i < nFramebuffers; i++ )
                addXineramaScreenUnique( i, pFramebuffers[i].x,
                                         pFramebuffers[i].y,
                                         pFramebuffers[i].width,
                                         pFramebuffers[i].height );

            m_aXineramaScreens = std::vector<Rectangle>();
            for( int i = 0; i < nFramebuffers; i++ )
            {
                addXineramaScreenUnique( i, pScreens[i].x_org,
                                         pScreens[i].y_org,
                                         pScreens[i].width,
                                         pScreens[i].height );

Lines 71-77 Link Here

(-)vcl.orig/unx/source/app/salsys.cxx (-1 / +1 lines)
71	unsigned int X11SalSystem::GetDefaultDisplayNumber()	71	unsigned int X11SalSystem::GetDefaultDisplayNumber()
72	{	72	{
73	SalDisplay* pSalDisp = GetX11SalData()->GetDisplay();	73	SalDisplay* pSalDisp = GetX11SalData()->GetDisplay();
74	return pSalDisp->GetDefaultScreenNumber();	74	return pSalDisp->IsXinerama() ? pSalDisp->GetDefaultMonitorNumber() : pSalDisp->GetDefaultScreenNumber();
75	}	75	}
76		76
77	Rectangle X11SalSystem::GetDisplayScreenPosSizePixel( unsigned int nScreen )	77	Rectangle X11SalSystem::GetDisplayScreenPosSizePixel( unsigned int nScreen )

Return to issue 112421

Lines 217-227 Link Here

(-)vcl.orig/unx/gtk/app/gtkdata.cxx (-1 / +28 lines)
217	{	217	{
218	gint nMonitors = gdk_screen_get_n_monitors(pScreen);	218	gint nMonitors = gdk_screen_get_n_monitors(pScreen);
219	m_aXineramaScreens = std::vector<Rectangle>();	219	m_aXineramaScreens = std::vector<Rectangle>();
		220	m_aXineramaScreenIndexMap = std::vector<int>(nMonitors);
220	for (gint i = 0; i < nMonitors; ++i)	221	for (gint i = 0; i < nMonitors; ++i)
221	{	222	{
222	GdkRectangle dest;	223	GdkRectangle dest;
223	gdk_screen_get_monitor_geometry(pScreen, i, &dest);	224	gdk_screen_get_monitor_geometry(pScreen, i, &dest);
224	addXineramaScreenUnique( dest.x, dest.y, dest.width, dest.height );	225	addXineramaScreenUnique( i, dest.x, dest.y, dest.width, dest.height );
225	}	226	}
226	m_bXinerama = m_aXineramaScreens.size() > 1;	227	m_bXinerama = m_aXineramaScreens.size() > 1;
227	if( ! m_aFrames.empty() )	228	if( ! m_aFrames.empty() )
Lines 235-240 Link Here
235	}	236	}
236	}	237	}
237		238
		239	extern "C"
		240	{
		241	typedef gint(* screen_get_primary_monitor)(GdkScreen *screen);
		242	}
		243
		244	int GtkSalDisplay::GetDefaultMonitorNumber() const
		245	{
		246	GdkScreen* pScreen = gdk_display_get_screen( m_pGdkDisplay, m_nDefaultScreen );
		247	#if GTK_CHECK_VERSION(2,20,0)
		248	return m_aXineramaScreenIndexMap[gdk_screen_get_primary_monitor(pScreen)];
		249	#else
		250	static screen_get_primary_monitor sym_gdk_screen_get_primary_monitor =
		251	(screen_get_primary_monitor)osl_getAsciiFunctionSymbol( GetSalData()->m_pPlugin, "gdk_screen_get_primary_monitor" );
		252	if (sym_gdk_screen_get_primary_monitor)
		253	return sym_gdk_screen_get_primary_monitor( pScreen );
		254	//gdk_screen_get_primary_monitor unavailable, take the first laptop monitor as the default
		255	gint nMonitors = gdk_screen_get_n_monitors(pScreen);
		256	for (gint i = 0; i < nMonitors; ++i)
		257	{
		258	if (g_ascii_strncasecmp (gdk_screen_get_monitor_plug_name(pScreen, i), "LVDS", 4) == 0)
		259	return m_aXineramaScreenIndexMap[i];
		260	}
		261	return 0;
		262	#endif
		263	}
		264
238	void GtkSalDisplay::initScreen( int nScreen ) const	265	void GtkSalDisplay::initScreen( int nScreen ) const
239	{	266	{
240	if( nScreen < 0 \|\| nScreen >= static_cast<int>(m_aScreens.size()) )	267	if( nScreen < 0 \|\| nScreen >= static_cast<int>(m_aScreens.size()) )

Lines 2592-2598 Link Here

(-)vcl.orig/unx/source/app/saldisp.cxx (-3 / +5 lines)
2592	sal::static_int_cast< unsigned int >(GetVisual(m_nDefaultScreen).GetVisualId()) );	2592	sal::static_int_cast< unsigned int >(GetVisual(m_nDefaultScreen).GetVisualId()) );
2593	}	2593	}
2594		2594
2595	void SalDisplay::addXineramaScreenUnique( long i_nX, long i_nY, long i_nWidth, long i_nHeight )	2595	void SalDisplay::addXineramaScreenUnique( int i, long i_nX, long i_nY, long i_nWidth, long i_nHeight )
2596	{	2596	{
2597	// see if any frame buffers are at the same coordinates	2597	// see if any frame buffers are at the same coordinates
2598	// this can happen with weird configuration e.g. on	2598	// this can happen with weird configuration e.g. on
Lines 2606-2616 Link Here
2606	if( m_aXineramaScreens[n].GetWidth() < i_nWidth \|\|	2606	if( m_aXineramaScreens[n].GetWidth() < i_nWidth \|\|
2607	m_aXineramaScreens[n].GetHeight() < i_nHeight )	2607	m_aXineramaScreens[n].GetHeight() < i_nHeight )
2608	{	2608	{
		2609	m_aXineramaScreenIndexMap[i] = n;
2609	m_aXineramaScreens[n].SetSize( Size( i_nWidth, i_nHeight ) );	2610	m_aXineramaScreens[n].SetSize( Size( i_nWidth, i_nHeight ) );
2610	}	2611	}
2611	return;	2612	return;
2612	}	2613	}
2613	}	2614	}
		2615	m_aXineramaScreenIndexMap[i] = m_aXineramaScreens.size();
2614	m_aXineramaScreens.push_back( Rectangle( Point( i_nX, i_nY ), Size( i_nWidth, i_nHeight ) ) );	2616	m_aXineramaScreens.push_back( Rectangle( Point( i_nX, i_nY ), Size( i_nWidth, i_nHeight ) ) );
2615	}	2617	}
2616		2618
Lines 2638-2644 Link Here
2638	m_bXinerama = true;	2640	m_bXinerama = true;
2639	m_aXineramaScreens = std::vector<Rectangle>();	2641	m_aXineramaScreens = std::vector<Rectangle>();
2640	for( int i = 0; i < nFramebuffers; i++ )	2642	for( int i = 0; i < nFramebuffers; i++ )
2641	addXineramaScreenUnique( pFramebuffers[i].x,	2643	addXineramaScreenUnique( i, pFramebuffers[i].x,
2642	pFramebuffers[i].y,	2644	pFramebuffers[i].y,
2643	pFramebuffers[i].width,	2645	pFramebuffers[i].width,
2644	pFramebuffers[i].height );	2646	pFramebuffers[i].height );
Lines 2656-2662 Link Here
2656	m_aXineramaScreens = std::vector<Rectangle>();	2658	m_aXineramaScreens = std::vector<Rectangle>();
2657	for( int i = 0; i < nFramebuffers; i++ )	2659	for( int i = 0; i < nFramebuffers; i++ )
2658	{	2660	{
2659	addXineramaScreenUnique( pScreens[i].x_org,	2661	addXineramaScreenUnique( i, pScreens[i].x_org,
2660	pScreens[i].y_org,	2662	pScreens[i].y_org,
2661	pScreens[i].width,	2663	pScreens[i].width,
2662	pScreens[i].height );	2664	pScreens[i].height );

Lines 389-394 Link Here

(-)vcl.orig/unx/inc/saldisp.hxx (-1 / +3 lines)
389		389
390	bool m_bXinerama;	390	bool m_bXinerama;
391	std::vector< Rectangle > m_aXineramaScreens;	391	std::vector< Rectangle > m_aXineramaScreens;
		392	std::vector< int > m_aXineramaScreenIndexMap;
392	std::list<SalFrame*> m_aFrames;	393	std::list<SalFrame*> m_aFrames;
393	std::list<SalObject*> m_aSalObjects;	394	std::list<SalObject*> m_aSalObjects;
394		395
Lines 404-410 Link Here
404	int processRandREvent( XEvent* );	405	int processRandREvent( XEvent* );
405		406
406	void doDestruct();	407	void doDestruct();
407	void addXineramaScreenUnique( long i_nX, long i_nY, long i_nWidth, long i_nHeight );	408	void addXineramaScreenUnique( int i, long i_nX, long i_nY, long i_nWidth, long i_nHeight );
408	public:	409	public:
409	static SalDisplay GetSalDisplay( Display display );	410	static SalDisplay GetSalDisplay( Display display );
410	static BOOL BestVisual( Display *pDisp,	411	static BOOL BestVisual( Display *pDisp,
Lines 474-479 Link Here
474	XLIB_Window GetDrawable( int nScreen ) const { return getDataForScreen( nScreen ).m_aRefWindow; }	475	XLIB_Window GetDrawable( int nScreen ) const { return getDataForScreen( nScreen ).m_aRefWindow; }
475	Display *GetDisplay() const { return pDisp_; }	476	Display *GetDisplay() const { return pDisp_; }
476	int GetDefaultScreenNumber() const { return m_nDefaultScreen; }	477	int GetDefaultScreenNumber() const { return m_nDefaultScreen; }
		478	virtual int GetDefaultMonitorNumber() const { return 0; }
477	const Size& GetScreenSize( int nScreen ) const { return getDataForScreen( nScreen ).m_aSize; }	479	const Size& GetScreenSize( int nScreen ) const { return getDataForScreen( nScreen ).m_aSize; }
478	srv_vendor_t GetServerVendor() const { return meServerVendor; }	480	srv_vendor_t GetServerVendor() const { return meServerVendor; }
479	void SetServerVendor() { meServerVendor = sal_GetServerVendor(pDisp_); }	481	void SetServerVendor() { meServerVendor = sal_GetServerVendor(pDisp_); }