← Back to branch summary

~ubuntu-branches/ubuntu/intrepid/xserver-xgl/intrepid

« back to all changes in this revision

Viewing changes to hw/xfree86/xaa/xaaGCmisc.c

  • Committer: Bazaar Package Importer
  • Author(s): Matthew Garrett
  • Date: 2006-02-13 14:21:43 UTC
  • Revision ID: james.westby@ubuntu.com-20060213142143-mad6z9xzem7hzxz9
Tags: upstream-7.0.0
Import upstream version 7.0.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
hw/xfree86/xaa/xaaGCmisc.c
 
1
/* $XFree86: xc/programs/Xserver/hw/xfree86/xaa/xaaGCmisc.c,v 1.14 2000/05/03 00:44:23 tsi Exp $ */
 
2
 
 
3
#ifdef HAVE_XORG_CONFIG_H
 
4
#include <xorg-config.h>
 
5
#endif
 
6
 
 
7
#include "misc.h"
 
8
#include "xf86.h"
 
9
#include "xf86_ansic.h"
 
10
#include "xf86_OSproc.h"
 
11
 
 
12
#include <X11/X.h>
 
13
#include "scrnintstr.h"
 
14
#include <X11/fonts/fontstruct.h>
 
15
#include "dixfontstr.h"
 
16
#include "xf86str.h"
 
17
#include "xaa.h"
 
18
#include "xaalocal.h"
 
19
#include "migc.h"
 
20
#include "mi.h"
 
21
#include "gcstruct.h"
 
22
#include "pixmapstr.h"
 
23
 
 
24
void
 
25
XAAValidateCopyArea(
 
26
   GCPtr         pGC,
 
27
   unsigned long changes,
 
28
   DrawablePtr   pDraw )
 
29
{
 
30
   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
 
31
 
 
32
   if(infoRec->CopyArea &&
 
33
        CHECK_PLANEMASK(pGC,infoRec->CopyAreaFlags) &&
 
34
        CHECK_ROP(pGC,infoRec->CopyAreaFlags) &&
 
35
        CHECK_ROPSRC(pGC,infoRec->CopyAreaFlags)
 
36
        )
 
37
        pGC->ops->CopyArea = infoRec->CopyArea;
 
38
   else
 
39
        pGC->ops->CopyArea = XAAFallbackOps.CopyArea;
 
40
}
 
41
 
 
42
void
 
43
XAAValidatePutImage(
 
44
   GCPtr         pGC,
 
45
   unsigned long changes,
 
46
   DrawablePtr   pDraw )
 
47
{
 
48
   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
 
49
 
 
50
   if(infoRec->PutImage &&
 
51
        CHECK_PLANEMASK(pGC,infoRec->PutImageFlags) &&
 
52
        CHECK_ROP(pGC,infoRec->PutImageFlags) &&
 
53
        CHECK_ROPSRC(pGC,infoRec->PutImageFlags) &&
 
54
        CHECK_COLORS(pGC,infoRec->PutImageFlags)
 
55
        )
 
56
        pGC->ops->PutImage = infoRec->PutImage;
 
57
   else
 
58
        pGC->ops->PutImage = XAAFallbackOps.PutImage;
 
59
}
 
60
 
 
61
void
 
62
XAAValidateCopyPlane(
 
63
   GCPtr         pGC,
 
64
   unsigned long changes,
 
65
   DrawablePtr   pDraw )
 
66
{
 
67
   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
 
68
 
 
69
   if(infoRec->CopyPlane &&
 
70
        CHECK_PLANEMASK(pGC,infoRec->CopyPlaneFlags) &&
 
71
        CHECK_ROP(pGC,infoRec->CopyPlaneFlags) &&
 
72
        CHECK_ROPSRC(pGC,infoRec->CopyPlaneFlags) &&
 
73
        CHECK_COLORS(pGC,infoRec->CopyPlaneFlags)
 
74
        )
 
75
        pGC->ops->CopyPlane = infoRec->CopyPlane;
 
76
   else
 
77
        pGC->ops->CopyPlane = XAAFallbackOps.CopyPlane;
 
78
}
 
79
 
 
80
void
 
81
XAAValidatePushPixels(
 
82
   GCPtr         pGC,
 
83
   unsigned long changes,
 
84
   DrawablePtr   pDraw )
 
85
{
 
86
   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
 
87
 
 
88
   if(infoRec->PushPixelsSolid &&
 
89
        (pGC->fillStyle == FillSolid) &&
 
90
        CHECK_PLANEMASK(pGC,infoRec->PushPixelsFlags) &&
 
91
        CHECK_ROP(pGC,infoRec->PushPixelsFlags) &&
 
92
        CHECK_ROPSRC(pGC,infoRec->PushPixelsFlags) &&
 
93
        CHECK_FG(pGC,infoRec->PushPixelsFlags) &&
 
94
        (!(infoRec->PushPixelsFlags & TRANSPARENCY_GXCOPY_ONLY) ||
 
95
          (pGC->alu == GXcopy))
 
96
        )
 
97
        pGC->ops->PushPixels = infoRec->PushPixelsSolid;
 
98
   else
 
99
        pGC->ops->PushPixels = XAAFallbackOps.PushPixels;
 
100
 
 
101
}
 
102
 
 
103
 
 
104
/* We make the assumption that the FillSpans, PolyFillRect, FillPolygon
 
105
   and PolyFillArc functions are linked in a way that they all have 
 
106
   the same rop/color/planemask restrictions. If the driver provides 
 
107
   a GC level replacement for these, it will need to supply a new 
 
108
   Validate functions if it breaks this assumption */
 
109
 
 
110
 
 
111
void
 
112
XAAValidateFillSpans(
 
113
   GCPtr         pGC,
 
114
   unsigned long changes,
 
115
   DrawablePtr   pDraw )
 
116
{
 
117
   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
 
118
 
 
119
   if(pGC->fillStyle != FillTiled) changes &= ~GCTile;
 
120
   if((pGC->fillStyle == FillTiled) || (pGC->fillStyle == FillSolid)) 
 
121
        changes &= ~GCStipple;
 
122
   if(!changes) return;
 
123
   
 
124
 
 
125
   pGC->ops->FillSpans = XAAFallbackOps.FillSpans;
 
126
   pGC->ops->PolyFillRect = XAAFallbackOps.PolyFillRect;
 
127
   pGC->ops->FillPolygon = XAAFallbackOps.FillPolygon;
 
128
   pGC->ops->PolyFillArc = XAAFallbackOps.PolyFillArc;
 
129
 
 
130
   switch(pGC->fillStyle){
 
131
   case FillSolid:
 
132
        if(infoRec->FillSpansSolid &&
 
133
                CHECK_PLANEMASK(pGC,infoRec->FillSpansSolidFlags) &&
 
134
                CHECK_ROP(pGC,infoRec->FillSpansSolidFlags) &&
 
135
                CHECK_ROPSRC(pGC,infoRec->FillSpansSolidFlags) &&
 
136
                CHECK_FG(pGC,infoRec->FillSpansSolidFlags)
 
137
                ) {
 
138
             pGC->ops->FillSpans = infoRec->FillSpansSolid;
 
139
             pGC->ops->PolyFillRect = infoRec->PolyFillRectSolid;
 
140
             pGC->ops->FillPolygon = infoRec->FillPolygonSolid;
 
141
             pGC->ops->PolyFillArc = infoRec->PolyFillArcSolid;
 
142
        }
 
143
        break;
 
144
        /* The [Stippled/OpaqueStippled/Tiled]FillChooser 
 
145
                functions do the validating */
 
146
   case FillStippled:
 
147
        if(infoRec->FillSpansStippled) {
 
148
             pGC->ops->FillSpans = infoRec->FillSpansStippled;
 
149
             pGC->ops->PolyFillRect = infoRec->PolyFillRectStippled;
 
150
             if(infoRec->FillPolygonStippled)
 
151
                 pGC->ops->FillPolygon = infoRec->FillPolygonStippled;
 
152
             else pGC->ops->FillPolygon = miFillPolygon;
 
153
             pGC->ops->PolyFillArc = miPolyFillArc;
 
154
        }
 
155
        break;
 
156
   case FillOpaqueStippled:
 
157
        if(infoRec->FillSpansOpaqueStippled) {
 
158
             pGC->ops->FillSpans = infoRec->FillSpansOpaqueStippled;
 
159
             pGC->ops->PolyFillRect = infoRec->PolyFillRectOpaqueStippled;
 
160
             if(infoRec->FillPolygonOpaqueStippled)
 
161
                 pGC->ops->FillPolygon = infoRec->FillPolygonOpaqueStippled;
 
162
             else pGC->ops->FillPolygon = miFillPolygon;
 
163
             pGC->ops->PolyFillArc = miPolyFillArc;
 
164
        }
 
165
        break;
 
166
   case FillTiled:
 
167
        if(infoRec->FillSpansTiled) {
 
168
             pGC->ops->FillSpans = infoRec->FillSpansTiled;
 
169
             pGC->ops->PolyFillRect = infoRec->PolyFillRectTiled;
 
170
             if(infoRec->FillPolygonTiled)
 
171
                 pGC->ops->FillPolygon = infoRec->FillPolygonTiled;
 
172
             else pGC->ops->FillPolygon = miFillPolygon;
 
173
             pGC->ops->PolyFillArc = miPolyFillArc;
 
174
        }
 
175
        break;
 
176
   default: return;
 
177
   }
 
178
}
 
179
 
 
180
 
 
181
/* We make the assumption that these Text8/16 and GlyphBlt functions
 
182
   are linked in a way that they all have the same rop/color/planemask
 
183
   restrictions. If the driver provides a GC level replacement for
 
184
   these, it will need to supply a new Validate functions if it breaks
 
185
   this assumption */
 
186
 
 
187
void
 
188
XAAValidatePolyGlyphBlt(
 
189
   GCPtr         pGC,
 
190
   unsigned long changes,
 
191
   DrawablePtr   pDraw )
 
192
{
 
193
   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
 
194
   Bool BigFont = FALSE;
 
195
 
 
196
   pGC->ops->PolyText8 = XAAFallbackOps.PolyText8;
 
197
   pGC->ops->PolyText16 = XAAFallbackOps.PolyText16;
 
198
   pGC->ops->PolyGlyphBlt = XAAFallbackOps.PolyGlyphBlt;
 
199
 
 
200
   if(!pGC->font) return;
 
201
   if(pGC->fillStyle != FillSolid) return;
 
202
 
 
203
   if((FONTMAXBOUNDS(pGC->font, rightSideBearing) - 
 
204
        FONTMINBOUNDS(pGC->font, leftSideBearing) > 32))
 
205
        BigFont = TRUE;
 
206
 
 
207
   /* no funny business */
 
208
   if((FONTMINBOUNDS(pGC->font, characterWidth) <= 0) ||
 
209
        ((FONTASCENT(pGC->font) + FONTDESCENT(pGC->font)) <= 0))
 
210
        return;
 
211
 
 
212
   /* Check for TE Fonts */
 
213
   if(!TERMINALFONT(pGC->font) || BigFont) {
 
214
        if(infoRec->PolyGlyphBltNonTE &&
 
215
            CHECK_PLANEMASK(pGC,infoRec->PolyGlyphBltNonTEFlags) &&
 
216
            CHECK_ROP(pGC,infoRec->PolyGlyphBltNonTEFlags) &&
 
217
            CHECK_ROPSRC(pGC,infoRec->PolyGlyphBltNonTEFlags) &&
 
218
            CHECK_FG(pGC,infoRec->PolyGlyphBltNonTEFlags) &&
 
219
            (!(infoRec->PolyGlyphBltNonTEFlags & TRANSPARENCY_GXCOPY_ONLY) ||
 
220
                (pGC->alu == GXcopy))
 
221
        ) {
 
222
            pGC->ops->PolyText8 = infoRec->PolyText8NonTE; 
 
223
            pGC->ops->PolyText16 = infoRec->PolyText16NonTE;
 
224
            pGC->ops->PolyGlyphBlt = infoRec->PolyGlyphBltNonTE;
 
225
        }
 
226
   } else {
 
227
        if(infoRec->PolyGlyphBltTE &&
 
228
            CHECK_PLANEMASK(pGC,infoRec->PolyGlyphBltTEFlags) &&
 
229
            CHECK_ROP(pGC,infoRec->PolyGlyphBltTEFlags) &&
 
230
            CHECK_ROPSRC(pGC,infoRec->PolyGlyphBltNonTEFlags) &&
 
231
            CHECK_FG(pGC,infoRec->PolyGlyphBltTEFlags) &&
 
232
            (!(infoRec->PolyGlyphBltTEFlags & TRANSPARENCY_GXCOPY_ONLY) ||
 
233
                (pGC->alu == GXcopy))
 
234
        ) {
 
235
            pGC->ops->PolyText8 = infoRec->PolyText8TE;
 
236
            pGC->ops->PolyText16 = infoRec->PolyText16TE;
 
237
            pGC->ops->PolyGlyphBlt = infoRec->PolyGlyphBltTE;
 
238
        }
 
239
   }
 
240
}
 
241
 
 
242
void
 
243
XAAValidateImageGlyphBlt(
 
244
   GCPtr         pGC,
 
245
   unsigned long changes,
 
246
   DrawablePtr   pDraw )
 
247
{
 
248
   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
 
249
   Bool BigFont = FALSE;
 
250
 
 
251
   pGC->ops->ImageText8 = XAAFallbackOps.ImageText8;
 
252
   pGC->ops->ImageText16 = XAAFallbackOps.ImageText16;
 
253
   pGC->ops->ImageGlyphBlt = XAAFallbackOps.ImageGlyphBlt;
 
254
 
 
255
   if(!pGC->font) return;
 
256
 
 
257
   if((FONTMAXBOUNDS(pGC->font, rightSideBearing) - 
 
258
        FONTMINBOUNDS(pGC->font, leftSideBearing) > 32))
 
259
        BigFont = TRUE;
 
260
 
 
261
   /* no funny business */
 
262
   if((FONTMINBOUNDS(pGC->font, characterWidth) <= 0) ||
 
263
        ((FONTASCENT(pGC->font) + FONTDESCENT(pGC->font)) <= 0))
 
264
        return;
 
265
 
 
266
 
 
267
   /* Check for TE Fonts */
 
268
   if(!TERMINALFONT(pGC->font) || BigFont || (pGC->depth == 32)) {
 
269
        if(infoRec->ImageGlyphBltNonTE &&
 
270
                CHECK_PLANEMASK(pGC,infoRec->ImageGlyphBltNonTEFlags) &&
 
271
                CHECK_FG(pGC,infoRec->ImageGlyphBltNonTEFlags) &&
 
272
           infoRec->SetupForSolidFill &&
 
273
                CHECK_PLANEMASK(pGC,infoRec->SolidFillFlags) &&
 
274
                CHECK_BG(pGC,infoRec->SolidFillFlags))
 
275
        {
 
276
                pGC->ops->ImageText8 = infoRec->ImageText8NonTE;
 
277
                pGC->ops->ImageText16 = infoRec->ImageText16NonTE;
 
278
                pGC->ops->ImageGlyphBlt = infoRec->ImageGlyphBltNonTE;
 
279
        }
 
280
   } else if(infoRec->ImageGlyphBltTE &&
 
281
             CHECK_PLANEMASK(pGC,infoRec->ImageGlyphBltTEFlags)){
 
282
        if(!(infoRec->ImageGlyphBltTEFlags & TRANSPARENCY_ONLY) &&  
 
283
                CHECK_COLORS(pGC,infoRec->ImageGlyphBltTEFlags))
 
284
        {
 
285
                pGC->ops->ImageText8 = infoRec->ImageText8TE;
 
286
                pGC->ops->ImageText16 = infoRec->ImageText16TE;
 
287
                pGC->ops->ImageGlyphBlt = infoRec->ImageGlyphBltTE;
 
288
        } else {
 
289
           if(CHECK_FG(pGC,infoRec->ImageGlyphBltTEFlags) &&
 
290
              infoRec->SetupForSolidFill &&
 
291
              CHECK_PLANEMASK(pGC,infoRec->SolidFillFlags) &&
 
292
              CHECK_BG(pGC,infoRec->SolidFillFlags)) 
 
293
           {
 
294
                pGC->ops->ImageText8 = infoRec->ImageText8TE;
 
295
                pGC->ops->ImageText16 = infoRec->ImageText16TE;
 
296
                pGC->ops->ImageGlyphBlt = infoRec->ImageGlyphBltTE;
 
297
           }
 
298
        }
 
299
    }
 
300
}
 
301
 
 
302
 
 
303
void
 
304
XAAValidatePolylines(
 
305
   GCPtr         pGC,
 
306
   unsigned long changes,
 
307
   DrawablePtr   pDraw )
 
308
{
 
309
   XAAInfoRecPtr infoRec = GET_XAAINFORECPTR_FROM_GC(pGC);
 
310
   XAAGCPtr   pGCPriv = (XAAGCPtr) (pGC)->devPrivates[XAAGCIndex].ptr;
 
311
 
 
312
   if(pGC->lineStyle == LineSolid) changes &= ~GCDashList;
 
313
   if(!changes) return;
 
314
 
 
315
   pGC->ops->PolySegment = XAAFallbackOps.PolySegment;
 
316
   pGC->ops->Polylines = XAAFallbackOps.Polylines;
 
317
   pGC->ops->PolyRectangle = XAAFallbackOps.PolyRectangle;
 
318
   pGC->ops->PolyArc = XAAFallbackOps.PolyArc;
 
319
 
 
320
   if((pGC->ops->FillSpans != XAAFallbackOps.FillSpans) &&
 
321
        (pGC->lineWidth > 0)){
 
322
        
 
323
        pGC->ops->PolyArc = miPolyArc;  
 
324
        pGC->ops->PolySegment = miPolySegment;  
 
325
        pGC->ops->PolyRectangle = miPolyRectangle;
 
326
        if(pGC->lineStyle == LineSolid)
 
327
            pGC->ops->Polylines = miWideLine;
 
328
        else
 
329
            pGC->ops->Polylines = miWideDash;
 
330
   }
 
331
 
 
332
   if((pGC->lineWidth == 0) && (pGC->fillStyle == FillSolid)) {
 
333
 
 
334
        if(pGC->lineStyle == LineSolid) {
 
335
 
 
336
           if(infoRec->PolyRectangleThinSolid &&
 
337
                CHECK_PLANEMASK(pGC,infoRec->PolyRectangleThinSolidFlags) &&
 
338
                CHECK_ROP(pGC,infoRec->PolyRectangleThinSolidFlags) &&
 
339
                CHECK_ROPSRC(pGC,infoRec->PolyRectangleThinSolidFlags) &&
 
340
                CHECK_FG(pGC,infoRec->PolyRectangleThinSolidFlags)) {
 
341
 
 
342
                pGC->ops->PolyRectangle = infoRec->PolyRectangleThinSolid;
 
343
           }
 
344
 
 
345
           if(infoRec->PolySegmentThinSolid &&
 
346
                CHECK_PLANEMASK(pGC,infoRec->PolySegmentThinSolidFlags) &&
 
347
                CHECK_ROP(pGC,infoRec->PolySegmentThinSolidFlags) &&
 
348
                CHECK_ROPSRC(pGC,infoRec->PolySegmentThinSolidFlags) &&
 
349
                CHECK_FG(pGC,infoRec->PolySegmentThinSolidFlags)) {
 
350
 
 
351
                pGC->ops->PolySegment = infoRec->PolySegmentThinSolid;
 
352
           }
 
353
 
 
354
           if(infoRec->PolylinesThinSolid &&
 
355
                CHECK_PLANEMASK(pGC,infoRec->PolylinesThinSolidFlags) &&
 
356
                CHECK_ROP(pGC,infoRec->PolylinesThinSolidFlags) &&
 
357
                CHECK_ROPSRC(pGC,infoRec->PolylinesThinSolidFlags) &&
 
358
                CHECK_FG(pGC,infoRec->PolylinesThinSolidFlags)) {
 
359
 
 
360
                pGC->ops->Polylines = infoRec->PolylinesThinSolid;
 
361
            }
 
362
        } else if((pGC->lineStyle == LineOnOffDash) && pGCPriv->DashPattern){
 
363
 
 
364
           if(infoRec->PolySegmentThinDashed &&
 
365
                !(infoRec->PolySegmentThinDashedFlags & NO_TRANSPARENCY) &&
 
366
                ((pGC->alu == GXcopy) || !(infoRec->PolySegmentThinDashedFlags &
 
367
                                        TRANSPARENCY_GXCOPY_ONLY)) &&
 
368
                CHECK_PLANEMASK(pGC,infoRec->PolySegmentThinDashedFlags) &&
 
369
                CHECK_ROP(pGC,infoRec->PolySegmentThinDashedFlags) &&
 
370
                CHECK_ROPSRC(pGC,infoRec->PolySegmentThinDashedFlags) &&
 
371
                CHECK_FG(pGC,infoRec->PolySegmentThinDashedFlags)) {
 
372
 
 
373
                pGC->ops->PolySegment = infoRec->PolySegmentThinDashed;
 
374
           }
 
375
 
 
376
           if(infoRec->PolylinesThinDashed &&
 
377
                !(infoRec->PolylinesThinDashedFlags & NO_TRANSPARENCY) &&
 
378
                ((pGC->alu == GXcopy) || !(infoRec->PolylinesThinDashedFlags &
 
379
                                        TRANSPARENCY_GXCOPY_ONLY)) &&
 
380
                CHECK_PLANEMASK(pGC,infoRec->PolylinesThinDashedFlags) &&
 
381
                CHECK_ROP(pGC,infoRec->PolylinesThinDashedFlags) &&
 
382
                CHECK_ROPSRC(pGC,infoRec->PolylinesThinDashedFlags) &&
 
383
                CHECK_FG(pGC,infoRec->PolylinesThinDashedFlags)) {
 
384
 
 
385
                pGC->ops->Polylines = infoRec->PolylinesThinDashed;
 
386
            }
 
387
 
 
388
           if(pGC->ops->Polylines != XAAFallbackOps.Polylines)
 
389
                pGC->ops->PolyRectangle = miPolyRectangle;
 
390
 
 
391
        } else if(pGCPriv->DashPattern && (pGC->depth != 32)) { 
 
392
           /* LineDoubleDash */
 
393
           if(infoRec->PolySegmentThinDashed &&
 
394
                !(infoRec->PolySegmentThinDashedFlags & TRANSPARENCY_ONLY) &&
 
395
                CHECK_PLANEMASK(pGC,infoRec->PolySegmentThinDashedFlags) &&
 
396
                CHECK_ROP(pGC,infoRec->PolySegmentThinDashedFlags) &&
 
397
                CHECK_ROPSRC(pGC,infoRec->PolySegmentThinDashedFlags) &&
 
398
                CHECK_COLORS(pGC,infoRec->PolySegmentThinDashedFlags)) {
 
399
 
 
400
                pGC->ops->PolySegment = infoRec->PolySegmentThinDashed;
 
401
           }
 
402
 
 
403
           if(infoRec->PolylinesThinDashed &&
 
404
                !(infoRec->PolylinesThinDashedFlags & TRANSPARENCY_ONLY) &&
 
405
                CHECK_PLANEMASK(pGC,infoRec->PolylinesThinDashedFlags) &&
 
406
                CHECK_ROP(pGC,infoRec->PolylinesThinDashedFlags) &&
 
407
                CHECK_ROPSRC(pGC,infoRec->PolylinesThinDashedFlags) &&
 
408
                CHECK_COLORS(pGC,infoRec->PolylinesThinDashedFlags)) {
 
409
 
 
410
                pGC->ops->Polylines = infoRec->PolylinesThinDashed;
 
411
            }
 
412
 
 
413
           if(pGC->ops->Polylines != XAAFallbackOps.Polylines)
 
414
                pGC->ops->PolyRectangle = miPolyRectangle;
 
415
 
 
416
        }
 
417
   }
 
418
 
 
419
   if(infoRec->PolylinesWideSolid &&
 
420
        (pGC->lineWidth > 0) &&
 
421
        (pGC->fillStyle == FillSolid) &&
 
422
        (pGC->lineStyle == LineSolid) &&
 
423
        CHECK_PLANEMASK(pGC,infoRec->PolylinesWideSolidFlags) &&
 
424
        CHECK_ROP(pGC,infoRec->PolylinesWideSolidFlags) &&
 
425
        CHECK_ROPSRC(pGC,infoRec->PolylinesWideSolidFlags) &&
 
426
        CHECK_FG(pGC,infoRec->PolylinesWideSolidFlags)) {
 
427
 
 
428
        pGC->ops->Polylines = infoRec->PolylinesWideSolid;
 
429
   } 
 
430
}