← Back to branch summary

~ubuntu-branches/ubuntu/precise/xorg-server/precise-updates

« back to all changes in this revision

Viewing changes to xkb/xkb.c

Tags: 2:1.10.1-2
* Build xserver-xorg-core-udeb on hurd-i386.  Thanks, Samuel Thibault!
* Upload to unstable.

Show diffs side-by-side

added added

removed removed

Lines of Context:
xkb/xkb.c
915
915
                                       stuff->axtOptsMask);
916
916
            }
917
917
 
918
 
            if (stuff->changeCtrls & XkbPerKeyRepeatMask)
 
918
            if (stuff->changeCtrls & XkbPerKeyRepeatMask) {
919
919
                memcpy(new.per_key_repeat, stuff->perKeyRepeat,
920
920
                       XkbPerKeyBitArraySize);
 
921
                if (xkbi->repeatKey &&
 
922
                    !BitIsOn(new.per_key_repeat, xkbi->repeatKey)) {
 
923
                    AccessXCancelRepeatKey(xkbi, xkbi->repeatKey);
 
924
                }
 
925
            }
921
926
 
922
927
            old= *ctrl;
923
928
            *ctrl= new;
1677
1682
    if (!(XkbKeySymsMask&req->present))
1678
1683
        return 1;
1679
1684
    CHK_REQ_KEY_RANGE2(0x11,req->firstKeySym,req->nKeySyms,req,(*errorRtrn),0);
1680
 
    map = &xkb->map->key_sym_map[xkb->min_key_code];
1681
 
    for (i=xkb->min_key_code;i<(unsigned)req->firstKeySym;i++,map++) {
1682
 
        register int g,ng,w;
1683
 
        ng= XkbNumGroups(map->group_info);
1684
 
        for (w=g=0;g<ng;g++) {
1685
 
            if (map->kt_index[g]>=(unsigned)nTypes) {
1686
 
                *errorRtrn = _XkbErrCode4(0x13,i,g,map->kt_index[g]);
1687
 
                return 0;
1688
 
            }
1689
 
            if (mapWidths[map->kt_index[g]]>w)
1690
 
                w= mapWidths[map->kt_index[g]];
1691
 
        }
1692
 
        symsPerKey[i] = w*ng;
1693
 
    }
1694
1685
    for (i=0;i<req->nKeySyms;i++) {
1695
1686
        KeySym *pSyms;
1696
1687
        register unsigned nG;
2345
2336
    int                 nTypes = 0, nActions;
2346
2337
    CARD8               mapWidths[XkbMaxLegalKeyCode + 1] = {0};
2347
2338
    CARD16              symsPerKey[XkbMaxLegalKeyCode + 1] = {0};
 
2339
    XkbSymMapPtr        map;
 
2340
    int                 i;
2348
2341
 
2349
2342
    xkbi= dev->key->xkbInfo;
2350
2343
    xkb = xkbi->desc;
2373
2366
        client->errorValue = nTypes;
2374
2367
        return BadValue;
2375
2368
    }
 
2369
 
 
2370
    /* symsPerKey/mapWidths must be filled regardless of client-side flags */
 
2371
    map = &xkb->map->key_sym_map[xkb->min_key_code];
 
2372
    for (i=xkb->min_key_code;i<xkb->max_key_code;i++,map++) {
 
2373
        register int g,ng,w;
 
2374
        ng= XkbNumGroups(map->group_info);
 
2375
        for (w=g=0;g<ng;g++) {
 
2376
            if (map->kt_index[g]>=(unsigned)nTypes) {
 
2377
                client->errorValue = _XkbErrCode4(0x13,i,g,map->kt_index[g]);
 
2378
                return 0;
 
2379
            }
 
2380
            if (mapWidths[map->kt_index[g]]>w)
 
2381
                w= mapWidths[map->kt_index[g]];
 
2382
        }
 
2383
        symsPerKey[i] = w*ng;
 
2384
    }
 
2385
 
2376
2386
    if ((req->present & XkbKeySymsMask) &&
2377
2387
        (!CheckKeySyms(client,xkb,req,nTypes,mapWidths,symsPerKey,
2378
2388
                                        (xkbSymMapWireDesc **)&values,&error))) {
3634
3644
        swapl(&rep->indicators,n);
3635
3645
    }
3636
3646
 
3637
 
    start = desc = malloc(length);
 
3647
    start = desc = calloc(1, length);
3638
3648
    if ( !start )
3639
3649
        return BadAlloc;
3640
3650
    if (xkb->names) {
4300
4310
static char *
4301
4311
XkbWriteCountedString(char *wire,char *str,Bool swap)
4302
4312
{
4303
 
    CARD16 len,*pLen;
 
4313
    CARD16 len,*pLen, paddedLen;
4304
4314
 
4305
4315
    if (!str)
4306
4316
        return wire;
4312
4322
        register int n;
4313
4323
        swaps(pLen,n);
4314
4324
    }
4315
 
    memcpy(&wire[2],str,len);
4316
 
    wire+= ((2+len+3)/4)*4;
 
4325
    paddedLen= pad_to_int32(sizeof(len)+len)-sizeof(len);
 
4326
    strncpy(&wire[sizeof(len)],str,paddedLen);
 
4327
    wire+= sizeof(len)+paddedLen;
4317
4328
    return wire;
4318
4329
}
4319
4330
 
4424
4435
        if (shape->approx!=NULL)
4425
4436
             shapeWire->approxNdx= XkbOutlineIndex(shape,shape->approx);
4426
4437
        else shapeWire->approxNdx= XkbNoShape;
 
4438
        shapeWire->pad= 0;
4427
4439
        if (swap) {
4428
4440
            register int n;
4429
4441
            swapl(&shapeWire->name,n);
4436
4448
            olWire= (xkbOutlineWireDesc *)wire;
4437
4449
            olWire->nPoints= ol->num_points;
4438
4450
            olWire->cornerRadius= ol->corner_radius;
 
4451
            olWire->pad= 0;
4439
4452
            wire= (char *)&olWire[1];
4440
4453
            ptWire= (xkbPointWireDesc *)wire;
4441
4454
            for (p=0,pt=ol->points;p<ol->num_points;p++,pt++) {
4549
4562
   olWire= (xkbOverlayWireDesc *)wire;
4550
4563
   olWire->name= ol->name;
4551
4564
   olWire->nRows= ol->num_rows;
 
4565
   olWire->pad1= 0;
 
4566
   olWire->pad2= 0;
4552
4567
   if (swap) {
4553
4568
        register int n;
4554
4569
        swapl(&olWire->name,n);
4561
4576
        rowWire= (xkbOverlayRowWireDesc *)wire;
4562
4577
        rowWire->rowUnder= row->row_under;
4563
4578
        rowWire->nKeys= row->num_keys;
 
4579
        rowWire->pad1= 0;
4564
4580
        wire= (char *)&rowWire[1];
4565
4581
        for (k=0,key=row->keys;k<row->num_keys;k++,key++) {
4566
4582
            xkbOverlayKeyWireDesc *     keyWire;
5559
5575
{
5560
5576
    DeviceIntPtr                dev;
5561
5577
    DeviceIntPtr                tmpd;
5562
 
    xkbGetKbdByNameReply        rep;
5563
 
    xkbGetMapReply              mrep;
5564
 
    xkbGetCompatMapReply        crep;
5565
 
    xkbGetIndicatorMapReply     irep;
5566
 
    xkbGetNamesReply            nrep;
5567
 
    xkbGetGeometryReply         grep;
5568
 
    XkbComponentNamesRec        names;
 
5578
    xkbGetKbdByNameReply        rep = {0};
 
5579
    xkbGetMapReply              mrep = {0};
 
5580
    xkbGetCompatMapReply        crep = {0};
 
5581
    xkbGetIndicatorMapReply     irep = {0};
 
5582
    xkbGetNamesReply            nrep = {0};
 
5583
    xkbGetGeometryReply         grep = {0};
 
5584
    XkbComponentNamesRec        names = {0};
5569
5585
    XkbDescPtr                  xkb, new;
5570
5586
    unsigned char *             str;
5571
5587
    char                        mapFile[PATH_MAX];
5887
5903
        XkbFreeKeyboard(new,XkbAllComponentsMask,TRUE);
5888
5904
        new= NULL;
5889
5905
    }
5890
 
    free(names.keycodes);
5891
 
    names.keycodes = NULL;
5892
 
    free(names.types);
5893
 
    names.types = NULL;
5894
 
    free(names.compat);
5895
 
    names.compat = NULL;
5896
 
    free(names.symbols);
5897
 
    names.symbols = NULL;
5898
 
    free(names.geometry);
5899
 
    names.geometry = NULL;
 
5906
    XkbFreeComponentNames(&names, FALSE);
5900
5907
    return Success;
5901
5908
}
5902
5909