← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/blender/gutsy-security

« back to all changes in this revision

Viewing changes to source/blender/src/editface.c

  • Committer: Bazaar Package Importer
  • Author(s): Florian Ernst
  • Date: 2007-05-17 11:47:59 UTC
  • mfrom: (1.2.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20070517114759-yp4ybrnhp2u7pk66
Tags: 2.44-1
* New upstream release.
* Drop debian/patches/01_64bits_stupidity, not needed anymore: as of this
  version blender is 64 bits safe again. Adjust README.Debian accordingly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/src/editface.c
1
1
/**
2
 
 * $Id: editface.c,v 1.83 2007/01/30 23:07:56 nicholasbishop Exp $
 
2
 * $Id: editface.c,v 1.91 2007/05/09 21:34:35 blendix Exp $
3
3
 *
4
4
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
5
5
 *
95
95
#include "BSE_trans_types.h"
96
96
 
97
97
#include "BDR_unwrapper.h"
 
98
#include "BDR_editobject.h"
98
99
 
99
100
#include "BPY_extern.h"
100
101
#include "BPY_menus.h"
183
184
 
184
185
        switch (G.vd->around) 
185
186
        {
186
 
        case V3D_CENTRE: /* bounding box center */
 
187
        case V3D_CENTER: /* bounding box center */
187
188
                min[0]= min[1]= min[2]= 1e20f;
188
189
                max[0]= max[1]= max[2]= -1e20f; 
189
190
 
190
191
                tface= me->mtface;
191
192
                mface= me->mface;
192
193
                for(a=0; a<me->totface; a++, mface++, tface++) {
193
 
                        if(tface->flag & TF_SELECT) {
 
194
                        if(mface->flag & ME_FACE_SEL) {
194
195
                                DO_MINMAX((me->mvert+mface->v1)->co, min, max);
195
196
                                DO_MINMAX((me->mvert+mface->v2)->co, min, max);
196
197
                                DO_MINMAX((me->mvert+mface->v3)->co, min, max);
372
373
                tface= me->mtface;
373
374
                mface= me->mface;
374
375
                for(a=0; a<me->totface; a++, mface++, tface++) {
375
 
                        if(tface->flag & TF_SELECT) {
 
376
                        if(mface->flag & ME_FACE_SEL) {
376
377
                                uv_calc_shift_project(tface->uv[0],cent,rotatematrix,3,(me->mvert+mface->v1)->co,min,max);
377
378
                                uv_calc_shift_project(tface->uv[1],cent,rotatematrix,3,(me->mvert+mface->v2)->co,min,max);
378
379
                                uv_calc_shift_project(tface->uv[2],cent,rotatematrix,3,(me->mvert+mface->v3)->co,min,max);
388
389
                tface= me->mtface;
389
390
                mface= me->mface;
390
391
                for(a=0; a<me->totface; a++, mface++, tface++) {
391
 
                        if(tface->flag & TF_SELECT) {
 
392
                        if(mface->flag & ME_FACE_SEL) {
392
393
                                if(mface->v4) b= 3; else b= 2;
393
394
                                for(; b>=0; b--) {
394
395
                                        tface->uv[b][0]= ((tface->uv[b][0]-min[0])*fac)/dx;
405
406
                tface= me->mtface;
406
407
                mface= me->mface;
407
408
                for(a=0; a<me->totface; a++, mface++, tface++) {
408
 
                        if(tface->flag & TF_SELECT) {
 
409
                        if(mface->flag & ME_FACE_SEL) {
409
410
                                uv_calc_shift_project(tface->uv[0],cent,rotatematrix,4,(me->mvert+mface->v1)->co,NULL,NULL);
410
411
                                uv_calc_shift_project(tface->uv[1],cent,rotatematrix,4,(me->mvert+mface->v2)->co,NULL,NULL);
411
412
                                uv_calc_shift_project(tface->uv[2],cent,rotatematrix,4,(me->mvert+mface->v3)->co,NULL,NULL);
417
418
 
418
419
        case B_UVAUTO_RESET:
419
420
                tface= me->mtface;
420
 
                for(a=0; a<me->totface; a++, tface++)
421
 
                        if(tface->flag & TF_SELECT) 
 
421
                mface= me->mface;
 
422
                for(a=0; a<me->totface; a++, tface++, mface++)
 
423
                        if(mface->flag & ME_FACE_SEL) 
422
424
                                default_uv(tface->uv, 1.0);
423
425
                break;
424
426
 
437
439
                tface= me->mtface;
438
440
                mface= me->mface;
439
441
                for(a=0; a<me->totface; a++, mface++, tface++) {
440
 
                        if(tface->flag & TF_SELECT) {
 
442
                        if(mface->flag & ME_FACE_SEL) {
441
443
                                uv_calc_shift_project(tface->uv[0],cent,rotatematrix,mapmode,(me->mvert+mface->v1)->co,NULL,NULL);
442
444
                                uv_calc_shift_project(tface->uv[1],cent,rotatematrix,mapmode,(me->mvert+mface->v2)->co,NULL,NULL);
443
445
                                uv_calc_shift_project(tface->uv[2],cent,rotatematrix,mapmode,(me->mvert+mface->v3)->co,NULL,NULL);
475
477
                tface= me->mtface;
476
478
                mface= me->mface;
477
479
                for(a=0; a<me->totface; a++, mface++, tface++) {
478
 
                        if(tface->flag & TF_SELECT) {
 
480
                        if(mface->flag & ME_FACE_SEL) {
479
481
                                CalcNormFloat((mv+mface->v1)->co, (mv+mface->v2)->co, (mv+mface->v3)->co, no);
480
482
                                        
481
483
                                no[0]= fabs(no[0]);
520
522
                tface= me->mtface;
521
523
                mface= me->mface;
522
524
                for(a=0; a<me->totface; a++, mface++, tface++) {
523
 
                        if(!(tface->flag & TF_SELECT)) continue;
 
525
                        if(!(mface->flag & ME_FACE_SEL)) continue;
524
526
                                
525
527
                        dx= dy= 0;
526
528
                        if(mface->v4) b= 3; else b= 2;
554
556
{
555
557
        Mesh *me;
556
558
        MTFace *tf;
 
559
        MFace *mf;
557
560
        int a;
558
561
        
559
562
        if(OBACT==NULL || OBACT->type!=OB_MESH)
570
573
                }
571
574
        }
572
575
 
573
 
        for(a=0, tf=me->mtface; a < me->totface; a++, tf++) {
574
 
                if(tf->flag & TF_SELECT) {
 
576
        
 
577
        for(a=0, tf=me->mtface, mf=me->mface; a < me->totface; a++, tf++, mf++) {
 
578
                if(mf->flag & ME_FACE_SEL) {
575
579
                        if(mcol) *mcol = (me->mcol)? &me->mcol[a*4]: NULL;
576
580
                        return tf;
577
581
                }
578
582
        }
579
583
 
580
 
        for(a=0, tf=me->mtface; a < me->totface; a++, tf++) {
581
 
                if((tf->flag & TF_HIDE)==0) {
 
584
        for(a=0, tf=me->mtface, mf=me->mface; a < me->totface; a++, tf++, mf++) {
 
585
                if((mf->flag & ME_HIDE)==0) {
582
586
                        if(mcol) *mcol = (me->mcol)? &me->mcol[a*4]: NULL;
583
587
                        return tf;
584
588
                }
626
630
void reveal_tface()
627
631
{
628
632
        Mesh *me;
629
 
        MTFace *tface;
 
633
        MFace *mface;
630
634
        int a;
631
635
        
632
636
        me= get_mesh(OBACT);
633
637
        if(me==0 || me->mtface==0 || me->totface==0) return;
634
638
        
635
 
        tface= me->mtface;
 
639
        mface= me->mface;
636
640
        a= me->totface;
637
641
        while(a--) {
638
 
                if(tface->flag & TF_HIDE) {
639
 
                        tface->flag |= TF_SELECT;
640
 
                        tface->flag -= TF_HIDE;
 
642
                if(mface->flag & ME_HIDE) {
 
643
                        mface->flag |= ME_FACE_SEL;
 
644
                        mface->flag -= ME_HIDE;
641
645
                }
642
 
                tface++;
 
646
                mface++;
643
647
        }
644
648
 
645
649
        BIF_undo_push("Reveal UV face");
650
654
void hide_tface()
651
655
{
652
656
        Mesh *me;
653
 
        MTFace *tface;
 
657
        MFace *mface;
654
658
        int a;
655
659
        
656
660
        me= get_mesh(OBACT);
661
665
                return;
662
666
        }
663
667
        
664
 
        tface= me->mtface;
 
668
        mface= me->mface;
665
669
        a= me->totface;
666
670
        while(a--) {
667
 
                if(tface->flag & TF_HIDE);
 
671
                if(mface->flag & ME_HIDE);
668
672
                else {
669
673
                        if(G.qual & LR_SHIFTKEY) {
670
 
                                if( (tface->flag & TF_SELECT)==0) tface->flag |= TF_HIDE;
 
674
                                if( (mface->flag & ME_FACE_SEL)==0) mface->flag |= ME_HIDE;
671
675
                        }
672
676
                        else {
673
 
                                if( (tface->flag & TF_SELECT)) tface->flag |= TF_HIDE;
 
677
                                if( (mface->flag & ME_FACE_SEL)) mface->flag |= ME_HIDE;
674
678
                        }
675
679
                }
676
 
                if(tface->flag & TF_HIDE) tface->flag &= ~TF_SELECT;
 
680
                if(mface->flag & ME_HIDE) mface->flag &= ~ME_FACE_SEL;
677
681
                
678
 
                tface++;
 
682
                mface++;
679
683
        }
680
684
 
681
685
        BIF_undo_push("Hide UV face");
708
712
void deselectall_tface()
709
713
{
710
714
        Mesh *me;
711
 
        MTFace *tface;
 
715
        MFace *mface;
712
716
        int a, sel;
713
717
                
714
718
        me= get_mesh(OBACT);
715
719
        if(me==0 || me->mtface==0) return;
716
720
        
717
 
        tface= me->mtface;
 
721
        mface= me->mface;
718
722
        a= me->totface;
719
723
        sel= 0;
720
724
        while(a--) {
721
 
                if(tface->flag & TF_HIDE);
722
 
                else if(tface->flag & TF_SELECT) sel= 1;
723
 
                tface++;
 
725
                if(mface->flag & ME_HIDE);
 
726
                else if(mface->flag & ME_FACE_SEL) sel= 1;
 
727
                mface++;
724
728
        }
725
729
        
726
 
        tface= me->mtface;
 
730
        mface= me->mface;
727
731
        a= me->totface;
728
732
        while(a--) {
729
 
                if(tface->flag & TF_HIDE);
 
733
                if(mface->flag & ME_HIDE);
730
734
                else {
731
 
                        if(sel) tface->flag &= ~TF_SELECT;
732
 
                        else tface->flag |= TF_SELECT;
 
735
                        if(sel) mface->flag &= ~ME_FACE_SEL;
 
736
                        else mface->flag |= ME_FACE_SEL;
733
737
                }
734
 
                tface++;
 
738
                mface++;
735
739
        }
736
740
 
737
741
        BIF_undo_push("(De)select all UV face");
742
746
void selectswap_tface(void)
743
747
{
744
748
        Mesh *me;
745
 
        MTFace *tface;
 
749
        MFace *mface;
746
750
        int a;
747
751
                
748
752
        me= get_mesh(OBACT);
749
753
        if(me==0 || me->mtface==0) return;
750
754
        
751
 
        tface= me->mtface;
 
755
        mface= me->mface;
752
756
        a= me->totface;
753
757
        while(a--) {
754
 
                if(tface->flag & TF_HIDE);
 
758
                if(mface->flag & ME_HIDE);
755
759
                else {
756
 
                        if(tface->flag & TF_SELECT) tface->flag &= ~TF_SELECT;
757
 
                        else tface->flag |= TF_SELECT;
 
760
                        if(mface->flag & ME_FACE_SEL) mface->flag &= ~ME_FACE_SEL;
 
761
                        else mface->flag |= ME_FACE_SEL;
758
762
                }
759
 
                tface++;
 
763
                mface++;
760
764
        }
761
765
 
762
766
        BIF_undo_push("Select inverse UV face");
782
786
                tf= me->mtface;
783
787
                mf= me->mface;
784
788
                for(a=0; a<me->totface; a++, tf++, mf++) {
785
 
                        if(tf->flag & TF_SELECT) {
 
789
                        if(mf->flag & ME_FACE_SEL) {
786
790
                                float u1= tf->uv[0][0];
787
791
                                float v1= tf->uv[0][1];
788
792
                                
814
818
                mcol= me->mcol;
815
819
                mf= me->mface;
816
820
                for(a=0; a<me->totface; a++, tf++, mf++, mcol+=4) {
817
 
                        if(tf->flag & TF_SELECT) {
 
821
                        if(mf->flag & ME_FACE_SEL) {
818
822
                                MCol tmpcol= mcol[0];
819
823
                                
820
824
                                mcol[0]= mcol[1];
853
857
                tf= me->mtface;
854
858
 
855
859
                for (a=0; a<me->totface; a++, tf++, mf++) {
856
 
                        if(tf->flag & TF_SELECT) {
 
860
                        if(mf->flag & ME_FACE_SEL) {
857
861
                                float u1= tf->uv[0][0];
858
862
                                float v1= tf->uv[0][1];
859
863
                                if(mf->v4) {
887
891
                mcol= me->mcol;
888
892
 
889
893
                for (a=0; a<me->totface; a++, tf++, mf++, mcol+=4) {
890
 
                        if(tf->flag & TF_SELECT) {
 
894
                        if(mf->flag & ME_FACE_SEL) {
891
895
                                MCol tmpcol= mcol[0];
892
896
 
893
897
                                if(mf->v4) {
911
915
        object_uvs_changed(OBACT);
912
916
}
913
917
 
914
 
void minmax_tface(float *min, float *max)
 
918
int minmax_tface(float *min, float *max)
915
919
{
916
920
        Object *ob;
917
921
        Mesh *me;
918
922
        MFace *mf;
919
923
        MTFace *tf;
920
924
        MVert *mv;
921
 
        int a;
 
925
        int a, ok=0;
922
926
        float vec[3], bmat[3][3];
923
927
        
924
928
        ob = OBACT;
925
 
        if (ob==0) return;
 
929
        if (ob==0) return ok;
926
930
        me= get_mesh(ob);
927
 
        if(me==0 || me->mtface==0) return;
 
931
        if(me==0 || me->mtface==0) return ok;
928
932
        
929
933
        Mat3CpyMat4(bmat, ob->obmat);
930
934
 
932
936
        mf= me->mface;
933
937
        tf= me->mtface;
934
938
        for (a=me->totface; a>0; a--, mf++, tf++) {
935
 
                if (tf->flag & TF_HIDE || !(tf->flag & TF_SELECT))
 
939
                if (mf->flag & ME_HIDE || !(mf->flag & ME_FACE_SEL))
936
940
                        continue;
937
941
 
938
942
                VECCOPY(vec, (mv+mf->v1)->co);
956
960
                        VecAddf(vec, vec, ob->obmat[3]);
957
961
                        DO_MINMAX(vec, min, max);
958
962
                }
 
963
                ok= 1;
959
964
        }
 
965
        return ok;
960
966
}
961
967
 
962
968
#define ME_SEAM_DONE ME_SEAM_LAST               /* reuse this flag */
1009
1015
        float *cost;
1010
1016
        MEdge *med;
1011
1017
        int a, *nedges, *edges, *prevedge, mednum = -1, nedgeswap = 0;
1012
 
        MTFace *tf;
1013
1018
        MFace *mf;
1014
1019
 
1015
1020
        /* mark hidden edges as done, so we don't use them */
1016
1021
        ehash = BLI_edgehash_new();
1017
1022
 
1018
 
        for (a=0, mf=me->mface, tf=me->mtface; a<me->totface; a++, tf++, mf++) {
1019
 
                if (!(tf->flag & TF_HIDE)) {
 
1023
        for (a=0, mf=me->mface; a<me->totface; a++, mf++) {
 
1024
                if (!(mf->flag & ME_HIDE)) {
1020
1025
                        BLI_edgehash_insert(ehash, mf->v1, mf->v2, NULL);
1021
1026
                        BLI_edgehash_insert(ehash, mf->v2, mf->v3, NULL);
1022
1027
                        if (mf->v4) {
1172
1177
void seam_mark_clear_tface(short mode)
1173
1178
{
1174
1179
        Mesh *me;
1175
 
        MTFace *tf;
1176
1180
        MFace *mf;
1177
1181
        MEdge *med;
1178
1182
        int a;
1189
1193
        if (mode == 2) {
1190
1194
                EdgeHash *ehash = BLI_edgehash_new();
1191
1195
 
1192
 
                for (a=0, mf=me->mface, tf=me->mtface; a<me->totface; a++, tf++, mf++)
1193
 
                        if (!(tf->flag & TF_HIDE) && (tf->flag & TF_SELECT))
 
1196
                for (a=0, mf=me->mface; a<me->totface; a++, mf++)
 
1197
                        if (!(mf->flag & ME_HIDE) && (mf->flag & ME_FACE_SEL))
1194
1198
                                seam_edgehash_insert_face(ehash, mf);
1195
1199
 
1196
1200
                for (a=0, med=me->medge; a<me->totedge; a++, med++)
1204
1208
                EdgeHash *ehash1 = BLI_edgehash_new();
1205
1209
                EdgeHash *ehash2 = BLI_edgehash_new();
1206
1210
 
1207
 
                for (a=0, mf=me->mface, tf=me->mtface; a<me->totface; a++, tf++, mf++) {
1208
 
                        if ((tf->flag & TF_HIDE) || !(tf->flag & TF_SELECT))
 
1211
                for (a=0, mf=me->mface; a<me->totface; a++, mf++) {
 
1212
                        if ((mf->flag & ME_HIDE) || !(mf->flag & ME_FACE_SEL))
1209
1213
                                seam_edgehash_insert_face(ehash1, mf);
1210
1214
                        else
1211
1215
                                seam_edgehash_insert_face(ehash2, mf);
1234
1238
        Object *ob;
1235
1239
        Mesh *me;
1236
1240
        MTFace *tface, *tsel;
1237
 
        MFace *msel;
 
1241
        MFace *mface, *msel;
1238
1242
        short mval[2];
1239
1243
        unsigned int a, index;
1240
1244
 
1256
1260
        tsel= (((MTFace*)me->mtface)+index);
1257
1261
        msel= (((MFace*)me->mface)+index);
1258
1262
 
1259
 
        if (tsel->flag & TF_HIDE) return;
 
1263
        if (msel->flag & ME_HIDE) return;
1260
1264
        
1261
1265
        /* clear flags */
1262
1266
        tface = me->mtface;
 
1267
        mface = me->mface;
1263
1268
        a = me->totface;
1264
1269
        while (a--) {
1265
1270
                if (G.qual & LR_SHIFTKEY)
1266
1271
                        tface->flag &= ~TF_ACTIVE;
1267
 
                else
1268
 
                        tface->flag &= ~(TF_ACTIVE+TF_SELECT);
 
1272
                else {
 
1273
                        tface->flag &= ~TF_ACTIVE;
 
1274
                        mface->flag &= ~ME_FACE_SEL;
 
1275
                }
1269
1276
                tface++;
 
1277
                mface++;
1270
1278
        }
1271
1279
        
1272
1280
        tsel->flag |= TF_ACTIVE;
1273
1281
 
1274
1282
        if (G.qual & LR_SHIFTKEY) {
1275
 
                if (tsel->flag & TF_SELECT)
1276
 
                        tsel->flag &= ~TF_SELECT;
 
1283
                if (msel->flag & ME_FACE_SEL)
 
1284
                        msel->flag &= ~ME_FACE_SEL;
1277
1285
                else
1278
 
                        tsel->flag |= TF_SELECT;
 
1286
                        msel->flag |= ME_FACE_SEL;
1279
1287
        }
1280
 
        else tsel->flag |= TF_SELECT;
 
1288
        else msel->flag |= ME_FACE_SEL;
1281
1289
        
1282
1290
        /* image window redraw */
1283
1291
        
1290
1298
{
1291
1299
        Mesh *me;
1292
1300
        MTFace *tface;
 
1301
        MFace *mface;
1293
1302
        rcti rect;
1294
1303
        struct ImBuf *ibuf;
1295
1304
        unsigned int *rt;
1329
1338
                        rt++;
1330
1339
                }
1331
1340
                
1332
 
                tface= me->mtface;
1333
 
                for(a=1; a<=me->totface; a++, tface++) {
 
1341
                mface= me->mface;
 
1342
                for(a=1; a<=me->totface; a++, tface++, mface++) {
1334
1343
                        if(selar[a]) {
1335
 
                                if(tface->flag & TF_HIDE);
 
1344
                                if(mface->flag & ME_HIDE);
1336
1345
                                else {
1337
 
                                        if(val==LEFTMOUSE) tface->flag |= TF_SELECT;
1338
 
                                        else tface->flag &= ~TF_SELECT;
 
1346
                                        if(val==LEFTMOUSE) mface->flag |= ME_FACE_SEL;
 
1347
                                        else mface->flag &= ~ME_FACE_SEL;
1339
1348
                                }
1340
1349
                        }
1341
1350
                }
1417
1426
        Mesh *me = 0;
1418
1427
        
1419
1428
        if(ob==NULL) return;
1420
 
        if(ob->id.lib) {
1421
 
                error("Can't edit library data");
 
1429
        if(object_data_is_libdata(ob)) {
 
1430
                error_libdata();
1422
1431
                return;
1423
1432
        }
1424
1433
        
1425
1434
        me= get_mesh(ob);
1426
 
        if(me && me->id.lib) {
1427
 
                error("Can't edit library data");
1428
 
                return;
1429
 
        }
1430
1435
        
1431
1436
        scrarea_queue_headredraw(curarea);
1432
1437
        
1442
1447
                        setcursor_space(SPACE_VIEW3D, CURSOR_STD);
1443
1448
                        BIF_undo_push("End UV Faceselect");
1444
1449
                }
1445
 
 
1446
 
                if(me)
1447
 
                        select_mface_from_tface(me);
1448
1450
        }
1449
1451
        else if (me && (ob->lay & G.vd->lay)) {
1450
1452
                G.f |= G_FACESELECT;
1451
1453
                if(me->mtface==NULL)
1452
1454
                        make_tfaces(me);
1453
 
                select_tface_from_mface(me);
1454
1455
 
1455
1456
                setcursor_space(SPACE_VIEW3D, CURSOR_FACESEL);
1456
1457
                BIF_undo_push("Set UV Faceselect");
1463
1464
        allqueue(REDRAWIMAGE, 0);
1464
1465
}
1465
1466
 
1466
 
void select_tface_from_mface(Mesh *me)
1467
 
{
1468
 
        MFace *mf;
1469
 
        MTFace *tf;
1470
 
        int a, hasactive=0;
1471
 
 
1472
 
        if(!me->mtface) return;
1473
 
 
1474
 
        mf= me->mface;
1475
 
        tf= me->mtface;
1476
 
        for(a=0; a<me->totface; a++, mf++, tf++) {
1477
 
                if(mf->flag & ME_FACE_SEL) tf->flag |= TF_SELECT;
1478
 
                else tf->flag &= ~TF_SELECT;
1479
 
 
1480
 
                if(mf->flag & ME_HIDE) tf->flag |= TF_HIDE;
1481
 
                else tf->flag &= ~TF_HIDE;
1482
 
 
1483
 
                if(tf->flag & TF_ACTIVE) {
1484
 
                        if(hasactive) tf->flag &= ~TF_ACTIVE;
1485
 
                        else hasactive= 1;
1486
 
                }
1487
 
        }
1488
 
}
1489
 
 
1490
 
void select_mface_from_tface(Mesh *me)
1491
 
{
1492
 
        MFace *mf;
1493
 
        MTFace *tf;
1494
 
        int a;
1495
 
 
1496
 
        if(!me->mtface) return;
1497
 
 
1498
 
        mf= me->mface;
1499
 
        tf= me->mtface;
1500
 
        for(a=0; a<me->totface; a++, mf++, tf++) {
1501
 
                if(tf->flag & TF_SELECT) mf->flag |= ME_FACE_SEL;
1502
 
                else mf->flag &= ~ME_FACE_SEL;
1503
 
 
1504
 
                if(tf->flag & TF_HIDE) mf->flag |= ME_HIDE;
1505
 
                else mf->flag &= ~ME_HIDE;
1506
 
        }
1507
 
}
1508
 
 
1509
1467
/* Texture Paint */
1510
1468
 
1511
1469
void set_texturepaint() /* toggle */
1515
1473
        
1516
1474
        scrarea_queue_headredraw(curarea);
1517
1475
        if(ob==NULL) return;
1518
 
        if(ob->id.lib) {
1519
 
                error("Can't edit library data");
 
1476
        
 
1477
        if (object_data_is_libdata(ob)) {
 
1478
                error_libdata();
1520
1479
                return;
1521
1480
        }
1522
1481
 
1523
1482
        me= get_mesh(ob);
1524
 
        if(me && me->id.lib) {
1525
 
                error("Can't edit library data");
1526
 
                return;
1527
 
        }
1528
1483
        
1529
1484
        if(me)
1530
1485
                DAG_object_flush_update(G.scene, ob, OB_RECALC_DATA);
1687
1642
{
1688
1643
        Object *ob;
1689
1644
        Mesh *me;
1690
 
        MTFace *tface;  
 
1645
        MTFace *tface;
 
1646
        MFace *mface;   
1691
1647
        short a, foundtex=0;
1692
1648
        Image *ima;
1693
1649
        char uvname[160];
1722
1678
 
1723
1679
        /* select everything with the same texture */
1724
1680
        tface = me->mtface;
 
1681
        mface = me->mface;
1725
1682
        a = me->totface;
1726
1683
        while (a--) {           
1727
1684
                ima=tface->tpage;
1728
 
                if(ima && ima->name){
 
1685
                if(!(mface->flag & ME_HIDE) && ima && ima->name){
1729
1686
                        if(!strcmp(ima->name, uvname)){
1730
 
                                tface->flag |= TF_SELECT;
 
1687
                                mface->flag |= ME_FACE_SEL;
1731
1688
                        }
1732
 
                        else tface->flag &= ~TF_SELECT;
 
1689
                        else mface->flag &= ~ME_FACE_SEL;
1733
1690
                }
1734
 
                else tface->flag &= ~TF_SELECT;
 
1691
                else mface->flag &= ~ME_FACE_SEL;
1735
1692
                tface++;
 
1693
                mface++;
1736
1694
        }
1737
1695
        
1738
1696
        /* image window redraw */