← Back to branch summary

~ubuntu-branches/ubuntu/hardy/kdebase-workspace/hardy-backports

« back to all changes in this revision

Viewing changes to kwin/main.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Richard A. Johnson
  • Date: 2008-05-02 23:57:34 UTC
  • mfrom: (1.2.1 upstream) (20.1.22 hardy)
  • Revision ID: james.westby@ubuntu.com-20080502235734-kwrykz4qcvunwqf4
Tags: 4:4.0.4-0ubuntu1~hardy1
https://launchpad.net/bugs/225994
https://launchpad.net/bugs/220655
* New upstream release (LP: #225994)
* Updated control file (LP: #220655)
* Updated install files

Show diffs side-by-side

added added

removed removed

Lines of Context:
kwin/main.cpp
36
36
#include <QX11Info>
37
37
#include <stdio.h>
38
38
#include <fixx11h.h>
 
39
#include <kxerrorhandler.h>
39
40
#include <QtDBus/QtDBus>
40
41
 
41
42
#include <kdialog.h>
72
73
// and -rdynamic in CXXFLAGS for kBacktrace() to work.
73
74
static bool kwin_sync = false;
74
75
 
 
76
// this is copied from KXErrorHandler and modified to explicitly use known extensions
 
77
static QByteArray errorMessage( const XErrorEvent& event, Display* dpy )
 
78
    { // "Error: <error> (<value>), Request: <request>(<value>), Resource: <value>"
 
79
    QByteArray ret;
 
80
    char tmp[ 256 ];
 
81
    char num[ 256 ];
 
82
    if( event.request_code < 128 ) // core request
 
83
        {
 
84
        XGetErrorText( dpy, event.error_code, tmp, 255 );
 
85
        if( char* paren = strchr( tmp, '(' )) // the explanation in parentheses just makes
 
86
            *paren = '\0';                     // it more verbose and is not really useful
 
87
        // the various casts are to get overloads non-ambiguous :-/
 
88
        ret = QByteArray( "error: " ) + (const char*)tmp + '[' + QByteArray::number( event.error_code ) + ']';
 
89
        sprintf( num, "%d", event.request_code );
 
90
        XGetErrorDatabaseText( dpy, "XRequest", num, "<unknown>", tmp, 256 );
 
91
        ret += QByteArray( ", request: " ) + (const char*)tmp + '[' + QByteArray::number( event.request_code ) + ']';
 
92
        if( event.resourceid != 0 )
 
93
            ret += QByteArray( ", resource: 0x" ) + QByteArray::number( (qlonglong)event.resourceid, 16 );
 
94
        }
 
95
    else // extensions
 
96
        {
 
97
        // XGetErrorText() currently has a bug that makes it fail to find text
 
98
        // for some errors (when error==error_base), also XGetErrorDatabaseText()
 
99
        // requires the right extension name, so it is needed to get info about
 
100
        // all extensions. However that is almost impossible:
 
101
        // - Xlib itself has it, but in internal data.
 
102
        // - Opening another X connection now can cause deadlock with server grabs.
 
103
        // - Fetching it at startup means a bunch of roundtrips.
 
104
 
 
105
        // KWin here explicitly uses known extensions.        
 
106
        int nextensions;
 
107
        const char** extensions;
 
108
        int* majors;
 
109
        int* error_bases;
 
110
        Extensions::fillExtensionsData( extensions, nextensions, majors, error_bases );
 
111
        XGetErrorText( dpy, event.error_code, tmp, 255 );
 
112
        int index = -1;
 
113
        int base = 0;
 
114
        for( int i = 0;
 
115
             i < nextensions;
 
116
             ++i )
 
117
            if( error_bases[ i ] != 0
 
118
                && event.error_code >= error_bases[ i ] && ( index == -1 || error_bases[ i ] > base ))
 
119
                {
 
120
                index = i;
 
121
                base = error_bases[ i ];
 
122
                }
 
123
        if( tmp == QString::number( event.error_code )) // XGetErrorText() failed,
 
124
            { // or it has a bug that causes not finding all errors, check ourselves
 
125
            if( index != -1 )
 
126
                {
 
127
                snprintf( num, 255, "%s.%d", extensions[ index ], event.error_code - base );
 
128
                XGetErrorDatabaseText( dpy, "XProtoError", num, "<unknown>", tmp, 255 );
 
129
                }
 
130
            else
 
131
                strcpy( tmp, "<unknown>" );
 
132
            }
 
133
        if( char* paren = strchr( tmp, '(' ))
 
134
            *paren = '\0';
 
135
        if( index != -1 )
 
136
            ret = QByteArray( "error: " ) + (const char*)tmp + '[' + (const char*)extensions[ index ]
 
137
                + '+' + QByteArray::number( event.error_code - base ) + ']';
 
138
        else
 
139
            ret = QByteArray( "error: " ) + (const char*)tmp + '[' + QByteArray::number( event.error_code ) + ']';
 
140
        tmp[ 0 ] = '\0';
 
141
        for( int i = 0;
 
142
             i < nextensions;
 
143
             ++i )
 
144
            if( majors[ i ] == event.request_code )
 
145
                {
 
146
                snprintf( num, 255, "%s.%d", extensions[ i ], event.minor_code );
 
147
                XGetErrorDatabaseText( dpy, "XRequest", num, "<unknown>", tmp, 255 );
 
148
                ret += QByteArray( ", request: " ) + (const char*)tmp + '[' + (const char*)extensions[ i ] + '+'
 
149
                    + QByteArray::number( event.minor_code ) + ']';
 
150
                }
 
151
        if( tmp[ 0 ] == '\0' ) // not found???
 
152
            ret += QByteArray( ", request <unknown> [" ) + QByteArray::number( event.request_code ) + ':'
 
153
                + QByteArray::number( event.minor_code ) + ']';
 
154
        if( event.resourceid != 0 )
 
155
            ret += QByteArray( ", resource: 0x" ) + QByteArray::number( (qlonglong)event.resourceid, 16 );
 
156
        }
 
157
    return ret;
 
158
    }
 
159
 
75
160
static
76
161
int x11ErrorHandler(Display *d, XErrorEvent *e)
77
162
    {
78
 
    char msg[80], req[80], number[80];
79
163
    bool ignore_badwindow = true; //maybe temporary
80
164
 
81
165
    if (initting &&
92
176
    if (ignore_badwindow && (e->error_code == BadWindow || e->error_code == BadColor))
93
177
        return 0;
94
178
 
95
 
    XGetErrorText(d, e->error_code, msg, sizeof(msg));
96
 
    sprintf(number, "%d", e->request_code);
97
 
    XGetErrorDatabaseText(d, "XRequest", number, "<unknown>", req, sizeof(req));
98
 
 
99
 
    fprintf(stderr, "kwin: %s(0x%lx): %s\n", req, e->resourceid, msg);
 
179
//    fprintf( stderr, "kwin: X Error (%s)\n", KXErrorHandler::errorMessage( *e, d ).data());
 
180
    fprintf( stderr, "kwin: X Error (%s)\n", errorMessage( *e, d ).data());
100
181
 
101
182
    if( kwin_sync )
102
 
        kDebug() << kBacktrace();
 
183
        fprintf( stderr, "%s\n", kBacktrace().toLocal8Bit().data());
103
184
 
104
185
    if (initting)
105
186
        {
409
490
        signal(SIGHUP, SIG_IGN);
410
491
    // HACK this is needed for AIGLX
411
492
    setenv( "LIBGL_ALWAYS_INDIRECT","1", true );
 
493
    // HACK this is needed to work around a Qt4.4.0RC1 bug (#157659)
 
494
    setenv( "QT_SLOW_TOPLEVEL_RESIZE", "1", true );
412
495
    KWin::Application a;
413
496
    KWin::SessionManager weAreIndeed;
414
497
    KWin::SessionSaveDoneHelper helper;