← Back to branch summary

~ubuntu-branches/ubuntu/utopic/blender/utopic-proposed

« back to all changes in this revision

Viewing changes to source/blender/editors/space_image/space_image.c

  • Committer: Package Import Robot
  • Author(s): Matteo F. Vescovi
  • Date: 2012-04-28 12:11:12 UTC
  • mto: (14.1.6 experimental) (1.5.1)
  • mto: This revision was merged to the branch mainline in revision 34.
  • Revision ID: package-import@ubuntu.com-20120428121112-2zi0vp8b6vejda8i
Tags: upstream-2.63
Import upstream version 2.63

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/editors/space_image/space_image.c
32
32
#include <string.h>
33
33
#include <stdio.h>
34
34
 
 
35
#include "DNA_mesh_types.h"
35
36
#include "DNA_meshdata_types.h"
36
37
#include "DNA_object_types.h"
37
38
#include "DNA_scene_types.h"
40
41
 
41
42
#include "BLI_blenlib.h"
42
43
#include "BLI_math.h"
43
 
#include "BLI_editVert.h"
44
44
#include "BLI_rand.h"
45
45
#include "BLI_utildefines.h"
46
46
 
52
52
#include "BKE_mesh.h"
53
53
#include "BKE_scene.h"
54
54
#include "BKE_screen.h"
 
55
#include "BKE_tessmesh.h"
55
56
 
56
57
#include "IMB_imbuf_types.h"
57
58
 
87
88
        /* context may be NULL, so use global */
88
89
        ED_uvedit_assign_image(G.main, scene, obedit, ima, sima->image);
89
90
        
90
 
        /* change the space ima after because uvedit_face_visible uses the space ima
 
91
        /* change the space ima after because uvedit_face_visible_test uses the space ima
91
92
         * to check if the face is displayed in UV-localview */
92
 
        sima->image= ima;
 
93
        sima->image = ima;
93
94
        
94
 
        if(ima == NULL || ima->type==IMA_TYPE_R_RESULT || ima->type==IMA_TYPE_COMPOSITE)
 
95
        if (ima == NULL || ima->type == IMA_TYPE_R_RESULT || ima->type == IMA_TYPE_COMPOSITE)
95
96
                sima->flag &= ~SI_DRAWTOOL;
96
97
        
97
 
        if(sima->image)
 
98
        if (sima->image)
98
99
                BKE_image_signal(sima->image, &sima->iuser, IMA_SIGNAL_USER_NEW_IMAGE);
99
100
        
100
 
        if(sima->image && sima->image->id.us==0)
101
 
                sima->image->id.us= 1;
 
101
        if (sima->image && sima->image->id.us == 0)
 
102
                sima->image->id.us = 1;
102
103
        
103
 
        if(obedit)
104
 
                WM_main_add_notifier(NC_GEOM|ND_DATA, obedit->data);
 
104
        if (obedit)
 
105
                WM_main_add_notifier(NC_GEOM | ND_DATA, obedit->data);
105
106
 
106
 
        WM_main_add_notifier(NC_SPACE|ND_SPACE_IMAGE, NULL);
 
107
        WM_main_add_notifier(NC_SPACE | ND_SPACE_IMAGE, NULL);
107
108
}
108
109
 
109
110
ImBuf *ED_space_image_acquire_buffer(SpaceImage *sima, void **lock_r)
110
111
{
111
112
        ImBuf *ibuf;
112
113
        
113
 
        if(sima && sima->image) {
 
114
        if (sima && sima->image) {
114
115
#if 0
115
 
                if(sima->image->type==IMA_TYPE_R_RESULT && BIF_show_render_spare())
 
116
                if (sima->image->type == IMA_TYPE_R_RESULT && BIF_show_render_spare())
116
117
                        return BIF_render_spare_imbuf();
117
118
                else
118
119
#endif
119
 
                        ibuf= BKE_image_acquire_ibuf(sima->image, &sima->iuser, lock_r);
 
120
                ibuf = BKE_image_acquire_ibuf(sima->image, &sima->iuser, lock_r);
120
121
                
121
 
                if(ibuf && (ibuf->rect || ibuf->rect_float))
 
122
                if (ibuf && (ibuf->rect || ibuf->rect_float))
122
123
                        return ibuf;
123
124
        }
124
125
        
127
128
 
128
129
void ED_space_image_release_buffer(SpaceImage *sima, void *lock)
129
130
{
130
 
        if(sima && sima->image)
 
131
        if (sima && sima->image)
131
132
                BKE_image_release_ibuf(sima->image, lock);
132
133
}
133
134
 
137
138
        void *lock;
138
139
        int has_buffer;
139
140
        
140
 
        ibuf= ED_space_image_acquire_buffer(sima, &lock);
141
 
        has_buffer= (ibuf != NULL);
 
141
        ibuf = ED_space_image_acquire_buffer(sima, &lock);
 
142
        has_buffer = (ibuf != NULL);
142
143
        ED_space_image_release_buffer(sima, lock);
143
144
        
144
145
        return has_buffer;
146
147
 
147
148
void ED_image_size(Image *ima, int *width, int *height)
148
149
{
149
 
        ImBuf *ibuf= NULL;
 
150
        ImBuf *ibuf = NULL;
150
151
        void *lock;
151
152
        
152
 
        if(ima)
153
 
                ibuf= BKE_image_acquire_ibuf(ima, NULL, &lock);
 
153
        if (ima)
 
154
                ibuf = BKE_image_acquire_ibuf(ima, NULL, &lock);
154
155
        
155
 
        if(ibuf && ibuf->x > 0 && ibuf->y > 0) {
156
 
                *width= ibuf->x;
157
 
                *height= ibuf->y;
 
156
        if (ibuf && ibuf->x > 0 && ibuf->y > 0) {
 
157
                *width = ibuf->x;
 
158
                *height = ibuf->y;
158
159
        }
159
160
        else {
160
 
                *width= 256;
161
 
                *height= 256;
 
161
                *width = 256;
 
162
                *height = 256;
162
163
        }
163
164
        
164
 
        if(ima)
 
165
        if (ima)
165
166
                BKE_image_release_ibuf(ima, lock);
166
167
}
167
168
 
168
169
void ED_space_image_size(SpaceImage *sima, int *width, int *height)
169
170
{
170
 
        Scene *scene= sima->iuser.scene;
 
171
        Scene *scene = sima->iuser.scene;
171
172
        ImBuf *ibuf;
172
173
        void *lock;
173
174
        
174
 
        ibuf= ED_space_image_acquire_buffer(sima, &lock);
 
175
        ibuf = ED_space_image_acquire_buffer(sima, &lock);
175
176
        
176
 
        if(ibuf && ibuf->x > 0 && ibuf->y > 0) {
177
 
                *width= ibuf->x;
178
 
                *height= ibuf->y;
 
177
        if (ibuf && ibuf->x > 0 && ibuf->y > 0) {
 
178
                *width = ibuf->x;
 
179
                *height = ibuf->y;
179
180
        }
180
 
        else if(sima->image && sima->image->type==IMA_TYPE_R_RESULT && scene) {
 
181
        else if (sima->image && sima->image->type == IMA_TYPE_R_RESULT && scene) {
181
182
                /* not very important, just nice */
182
 
                *width= (scene->r.xsch*scene->r.size)/100;
183
 
                *height= (scene->r.ysch*scene->r.size)/100;
 
183
                *width = (scene->r.xsch * scene->r.size) / 100;
 
184
                *height = (scene->r.ysch * scene->r.size) / 100;
184
185
 
185
 
                if((scene->r.mode & R_BORDER) && (scene->r.mode & R_CROP)) {
 
186
                if ((scene->r.mode & R_BORDER) && (scene->r.mode & R_CROP)) {
186
187
                        *width *= (scene->r.border.xmax - scene->r.border.xmin);
187
188
                        *height *= (scene->r.border.ymax - scene->r.border.ymin);
188
189
                }
189
190
 
190
191
        }
191
192
        /* I know a bit weak... but preview uses not actual image size */
192
 
        // XXX else if(image_preview_active(sima, width, height));
 
193
        // XXX else if (image_preview_active(sima, width, height));
193
194
        else {
194
 
                *width= 256;
195
 
                *height= 256;
 
195
                *width = 256;
 
196
                *height = 256;
196
197
        }
197
198
        
198
199
        ED_space_image_release_buffer(sima, lock);
200
201
 
201
202
void ED_image_aspect(Image *ima, float *aspx, float *aspy)
202
203
{
203
 
        *aspx= *aspy= 1.0;
 
204
        *aspx = *aspy = 1.0;
204
205
        
205
 
        if((ima == NULL) || (ima->type == IMA_TYPE_R_RESULT) || (ima->type == IMA_TYPE_COMPOSITE) ||
206
 
           (ima->aspx==0.0f || ima->aspy==0.0f))
 
206
        if ((ima == NULL) || (ima->type == IMA_TYPE_R_RESULT) || (ima->type == IMA_TYPE_COMPOSITE) ||
 
207
            (ima->aspx == 0.0f || ima->aspy == 0.0f))
207
208
                return;
208
209
        
209
210
        /* x is always 1 */
210
 
        *aspy = ima->aspy/ima->aspx;
 
211
        *aspy = ima->aspy / ima->aspx;
211
212
}
212
213
 
213
214
void ED_space_image_aspect(SpaceImage *sima, float *aspx, float *aspy)
221
222
        
222
223
        ED_space_image_size(sima, &width, &height);
223
224
        
224
 
        *zoomx= (float)(ar->winrct.xmax - ar->winrct.xmin + 1)/(float)((ar->v2d.cur.xmax - ar->v2d.cur.xmin)*width);
225
 
        *zoomy= (float)(ar->winrct.ymax - ar->winrct.ymin + 1)/(float)((ar->v2d.cur.ymax - ar->v2d.cur.ymin)*height);
 
225
        *zoomx = (float)(ar->winrct.xmax - ar->winrct.xmin + 1) / (float)((ar->v2d.cur.xmax - ar->v2d.cur.xmin) * width);
 
226
        *zoomy = (float)(ar->winrct.ymax - ar->winrct.ymin + 1) / (float)((ar->v2d.cur.ymax - ar->v2d.cur.ymin) * height);
226
227
}
227
228
 
228
229
void ED_space_image_uv_aspect(SpaceImage *sima, float *aspx, float *aspy)
235
236
        *aspx *= (float)w;
236
237
        *aspy *= (float)h;
237
238
        
238
 
        if(*aspx < *aspy) {
239
 
                *aspy= *aspy / *aspx;
240
 
                *aspx= 1.0f;
 
239
        if (*aspx < *aspy) {
 
240
                *aspy = *aspy / *aspx;
 
241
                *aspx = 1.0f;
241
242
        }
242
243
        else {
243
 
                *aspx= *aspx / *aspy;
244
 
                *aspy= 1.0f;            
 
244
                *aspx = *aspx / *aspy;
 
245
                *aspy = 1.0f;
245
246
        }
246
247
}
247
248
 
263
264
 
264
265
int ED_space_image_show_paint(SpaceImage *sima)
265
266
{
266
 
        if(ED_space_image_show_render(sima))
 
267
        if (ED_space_image_show_render(sima))
267
268
                return 0;
268
269
        
269
270
        return (sima->flag & SI_DRAWTOOL);
271
272
 
272
273
int ED_space_image_show_uvedit(SpaceImage *sima, Object *obedit)
273
274
{
274
 
        if(sima && (ED_space_image_show_render(sima) || ED_space_image_show_paint(sima)))
 
275
        if (sima && (ED_space_image_show_render(sima) || ED_space_image_show_paint(sima)))
275
276
                return 0;
276
277
 
277
 
        if(obedit && obedit->type == OB_MESH) {
278
 
                EditMesh *em = BKE_mesh_get_editmesh(obedit->data);
 
278
        if (obedit && obedit->type == OB_MESH) {
 
279
                struct BMEditMesh *em = BMEdit_FromObject(obedit);
279
280
                int ret;
280
281
                
281
 
                ret = EM_texFaceCheck(em);
 
282
                ret = EDBM_mtexpoly_check(em);
282
283
                
283
 
                BKE_mesh_end_editmesh(obedit->data, em);
284
284
                return ret;
285
285
        }
286
286
        
289
289
 
290
290
int ED_space_image_show_uvshadow(SpaceImage *sima, Object *obedit)
291
291
{
292
 
        if(ED_space_image_show_render(sima))
 
292
        if (ED_space_image_show_render(sima))
293
293
                return 0;
294
294
        
295
 
        if(ED_space_image_show_paint(sima))
296
 
                if(obedit && obedit->type == OB_MESH) {
297
 
                        EditMesh *em = BKE_mesh_get_editmesh(obedit->data);
 
295
        if (ED_space_image_show_paint(sima))
 
296
                if (obedit && obedit->type == OB_MESH) {
 
297
                        struct BMEditMesh *em = BMEdit_FromObject(obedit);
298
298
                        int ret;
299
299
                        
300
 
                        ret = EM_texFaceCheck(em);
 
300
                        ret = EDBM_mtexpoly_check(em);
301
301
                        
302
 
                        BKE_mesh_end_editmesh(obedit->data, em);
303
302
                        return ret;
304
303
                }
305
304
        
309
308
 
310
309
static void image_scopes_tag_refresh(ScrArea *sa)
311
310
{
312
 
        SpaceImage *sima= (SpaceImage *)sa->spacedata.first;
 
311
        SpaceImage *sima = (SpaceImage *)sa->spacedata.first;
313
312
        ARegion *ar;
314
313
 
315
314
        /* only while histogram is visible */
316
 
        for (ar=sa->regionbase.first; ar; ar=ar->next) {
 
315
        for (ar = sa->regionbase.first; ar; ar = ar->next) {
317
316
                if (ar->regiontype == RGN_TYPE_PREVIEW && ar->flag & RGN_FLAG_HIDDEN)
318
317
                        return;
319
318
        }
320
319
 
321
 
        sima->scopes.ok=0;
 
320
        sima->scopes.ok = 0;
322
321
}
323
322
 
324
323
 
328
327
{
329
328
        ARegion *ar, *arnew;
330
329
 
331
 
        ar= BKE_area_find_region_type(sa, RGN_TYPE_UI);
332
 
        if(ar) return ar;
 
330
        ar = BKE_area_find_region_type(sa, RGN_TYPE_UI);
 
331
        if (ar) return ar;
333
332
        
334
333
        /* add subdiv level; after header */
335
 
        ar= BKE_area_find_region_type(sa, RGN_TYPE_HEADER);
 
334
        ar = BKE_area_find_region_type(sa, RGN_TYPE_HEADER);
336
335
 
337
336
        /* is error! */
338
 
        if(ar==NULL) return NULL;
 
337
        if (ar == NULL) return NULL;
339
338
        
340
 
        arnew= MEM_callocN(sizeof(ARegion), "buttons for image");
 
339
        arnew = MEM_callocN(sizeof(ARegion), "buttons for image");
341
340
        
342
341
        BLI_insertlinkafter(&sa->regionbase, ar, arnew);
343
 
        arnew->regiontype= RGN_TYPE_UI;
344
 
        arnew->alignment= RGN_ALIGN_LEFT;
 
342
        arnew->regiontype = RGN_TYPE_UI;
 
343
        arnew->alignment = RGN_ALIGN_LEFT;
345
344
        
346
345
        arnew->flag = RGN_FLAG_HIDDEN;
347
346
        
352
351
{
353
352
        ARegion *ar, *arnew;
354
353
 
355
 
        ar= BKE_area_find_region_type(sa, RGN_TYPE_PREVIEW);
356
 
        if(ar) return ar;
 
354
        ar = BKE_area_find_region_type(sa, RGN_TYPE_PREVIEW);
 
355
        if (ar) return ar;
357
356
 
358
357
        /* add subdiv level; after buttons */
359
 
        ar= BKE_area_find_region_type(sa, RGN_TYPE_UI);
 
358
        ar = BKE_area_find_region_type(sa, RGN_TYPE_UI);
360
359
 
361
360
        /* is error! */
362
 
        if(ar==NULL) return NULL;
 
361
        if (ar == NULL) return NULL;
363
362
        
364
 
        arnew= MEM_callocN(sizeof(ARegion), "scopes for image");
 
363
        arnew = MEM_callocN(sizeof(ARegion), "scopes for image");
365
364
        
366
365
        BLI_insertlinkafter(&sa->regionbase, ar, arnew);
367
 
        arnew->regiontype= RGN_TYPE_PREVIEW;
368
 
        arnew->alignment= RGN_ALIGN_RIGHT;
 
366
        arnew->regiontype = RGN_TYPE_PREVIEW;
 
367
        arnew->alignment = RGN_ALIGN_RIGHT;
369
368
        
370
369
        arnew->flag = RGN_FLAG_HIDDEN;
371
370
 
381
380
        ARegion *ar;
382
381
        SpaceImage *simage;
383
382
        
384
 
        simage= MEM_callocN(sizeof(SpaceImage), "initimage");
385
 
        simage->spacetype= SPACE_IMAGE;
386
 
        simage->zoom= 1;
387
 
        simage->lock= 1;
388
 
        
389
 
        simage->iuser.ok= 1;
390
 
        simage->iuser.fie_ima= 2;
391
 
        simage->iuser.frames= 100;
 
383
        simage = MEM_callocN(sizeof(SpaceImage), "initimage");
 
384
        simage->spacetype = SPACE_IMAGE;
 
385
        simage->zoom = 1;
 
386
        simage->lock = 1;
 
387
 
 
388
        simage->iuser.ok = 1;
 
389
        simage->iuser.fie_ima = 2;
 
390
        simage->iuser.frames = 100;
392
391
        
393
392
        scopes_new(&simage->scopes);
394
 
        simage->sample_line_hist.height= 100;
 
393
        simage->sample_line_hist.height = 100;
395
394
 
396
395
        /* header */
397
 
        ar= MEM_callocN(sizeof(ARegion), "header for image");
 
396
        ar = MEM_callocN(sizeof(ARegion), "header for image");
398
397
        
399
398
        BLI_addtail(&simage->regionbase, ar);
400
 
        ar->regiontype= RGN_TYPE_HEADER;
401
 
        ar->alignment= RGN_ALIGN_BOTTOM;
 
399
        ar->regiontype = RGN_TYPE_HEADER;
 
400
        ar->alignment = RGN_ALIGN_BOTTOM;
402
401
        
403
402
        /* buttons/list view */
404
 
        ar= MEM_callocN(sizeof(ARegion), "buttons for image");
 
403
        ar = MEM_callocN(sizeof(ARegion), "buttons for image");
405
404
        
406
405
        BLI_addtail(&simage->regionbase, ar);
407
 
        ar->regiontype= RGN_TYPE_UI;
408
 
        ar->alignment= RGN_ALIGN_LEFT;
 
406
        ar->regiontype = RGN_TYPE_UI;
 
407
        ar->alignment = RGN_ALIGN_LEFT;
409
408
        ar->flag = RGN_FLAG_HIDDEN;
410
409
        
411
410
        /* scopes */
412
 
        ar= MEM_callocN(sizeof(ARegion), "buttons for image");
 
411
        ar = MEM_callocN(sizeof(ARegion), "buttons for image");
413
412
        
414
413
        BLI_addtail(&simage->regionbase, ar);
415
 
        ar->regiontype= RGN_TYPE_PREVIEW;
416
 
        ar->alignment= RGN_ALIGN_RIGHT;
 
414
        ar->regiontype = RGN_TYPE_PREVIEW;
 
415
        ar->alignment = RGN_ALIGN_RIGHT;
417
416
        ar->flag = RGN_FLAG_HIDDEN;
418
417
 
419
418
        /* main area */
420
 
        ar= MEM_callocN(sizeof(ARegion), "main area for image");
 
419
        ar = MEM_callocN(sizeof(ARegion), "main area for image");
421
420
        
422
421
        BLI_addtail(&simage->regionbase, ar);
423
 
        ar->regiontype= RGN_TYPE_WINDOW;
 
422
        ar->regiontype = RGN_TYPE_WINDOW;
424
423
        
425
424
        return (SpaceLink *)simage;
426
425
}
428
427
/* not spacelink itself */
429
428
static void image_free(SpaceLink *sl)
430
429
{       
431
 
        SpaceImage *simage= (SpaceImage*) sl;
 
430
        SpaceImage *simage = (SpaceImage *) sl;
432
431
        
433
 
        if(simage->cumap)
 
432
        if (simage->cumap)
434
433
                curvemapping_free(simage->cumap);
435
434
        scopes_free(&simage->scopes);
436
435
}
439
438
/* spacetype; init callback, add handlers */
440
439
static void image_init(struct wmWindowManager *UNUSED(wm), ScrArea *sa)
441
440
{
442
 
        ListBase *lb= WM_dropboxmap_find("Image", SPACE_IMAGE, 0);
 
441
        ListBase *lb = WM_dropboxmap_find("Image", SPACE_IMAGE, 0);
443
442
 
444
443
        /* add drop boxes */
445
444
        WM_event_add_dropbox_handler(&sa->handlers, lb);
448
447
 
449
448
static SpaceLink *image_duplicate(SpaceLink *sl)
450
449
{
451
 
        SpaceImage *simagen= MEM_dupallocN(sl);
 
450
        SpaceImage *simagen = MEM_dupallocN(sl);
452
451
        
453
452
        /* clear or remove stuff from old */
454
 
        if(simagen->cumap)
455
 
                simagen->cumap= curvemapping_copy(simagen->cumap);
 
453
        if (simagen->cumap)
 
454
                simagen->cumap = curvemapping_copy(simagen->cumap);
456
455
 
457
456
        scopes_new(&simagen->scopes);
458
457
 
496
495
 
497
496
static void image_keymap(struct wmKeyConfig *keyconf)
498
497
{
499
 
        wmKeyMap *keymap= WM_keymap_find(keyconf, "Image Generic", SPACE_IMAGE, 0);
 
498
        wmKeyMap *keymap = WM_keymap_find(keyconf, "Image Generic", SPACE_IMAGE, 0);
500
499
        wmKeyMapItem *kmi;
 
500
        int i;
501
501
        
502
502
        WM_keymap_add_item(keymap, "IMAGE_OT_new", NKEY, KM_PRESS, KM_ALT, 0);
503
503
        WM_keymap_add_item(keymap, "IMAGE_OT_open", OKEY, KM_PRESS, KM_ALT, 0);
510
510
        WM_keymap_add_item(keymap, "IMAGE_OT_cycle_render_slot", JKEY, KM_PRESS, 0, 0);
511
511
        RNA_boolean_set(WM_keymap_add_item(keymap, "IMAGE_OT_cycle_render_slot", JKEY, KM_PRESS, KM_ALT, 0)->ptr, "reverse", TRUE);
512
512
        
513
 
        keymap= WM_keymap_find(keyconf, "Image", SPACE_IMAGE, 0);
 
513
        keymap = WM_keymap_find(keyconf, "Image", SPACE_IMAGE, 0);
514
514
        
515
515
        WM_keymap_add_item(keymap, "IMAGE_OT_view_all", HOMEKEY, KM_PRESS, 0, 0);
516
516
        WM_keymap_add_item(keymap, "IMAGE_OT_view_selected", PADPERIOD, KM_PRESS, 0, 0);
541
541
        RNA_enum_set(WM_keymap_add_item(keymap, "IMAGE_OT_curves_point_set", ACTIONMOUSE, KM_PRESS, KM_SHIFT, 0)->ptr, "point", 1);
542
542
 
543
543
        /* toggle editmode is handy to have while UV unwrapping */
544
 
        kmi= WM_keymap_add_item(keymap, "OBJECT_OT_mode_set", TABKEY, KM_PRESS, 0, 0);
 
544
        kmi = WM_keymap_add_item(keymap, "OBJECT_OT_mode_set", TABKEY, KM_PRESS, 0, 0);
545
545
        RNA_enum_set(kmi->ptr, "mode", OB_MODE_EDIT);
546
546
        RNA_boolean_set(kmi->ptr, "toggle", TRUE);
 
547
 
 
548
        /* fast switch to render slots */
 
549
        for (i = 0; i < MAX2(IMA_MAX_RENDER_SLOT, 9); i++) {
 
550
                kmi = WM_keymap_add_item(keymap, "WM_OT_context_set_int", ONEKEY+i, KM_PRESS, 0, 0);
 
551
                RNA_string_set(kmi->ptr, "data_path", "space_data.image.render_slot");
 
552
                RNA_int_set(kmi->ptr, "value", i);
 
553
        }
547
554
}
548
555
 
549
556
/* dropboxes */
550
557
static int image_drop_poll(bContext *UNUSED(C), wmDrag *drag, wmEvent *UNUSED(event))
551
558
{
552
 
        if(drag->type==WM_DRAG_PATH)
553
 
                if(ELEM3(drag->icon, 0, ICON_FILE_IMAGE, ICON_FILE_BLANK))      /* rule might not work? */
 
559
        if (drag->type == WM_DRAG_PATH)
 
560
                if (ELEM3(drag->icon, 0, ICON_FILE_IMAGE, ICON_FILE_BLANK)) /* rule might not work? */
554
561
                        return 1;
555
562
        return 0;
556
563
}
564
571
/* area+region dropbox definition */
565
572
static void image_dropboxes(void)
566
573
{
567
 
        ListBase *lb= WM_dropboxmap_find("Image", SPACE_IMAGE, 0);
 
574
        ListBase *lb = WM_dropboxmap_find("Image", SPACE_IMAGE, 0);
568
575
        
569
576
        WM_dropbox_add(lb, "IMAGE_OT_open", image_drop_poll, image_drop_copy);
570
577
}
574
581
static void image_refresh(const bContext *C, ScrArea *UNUSED(sa))
575
582
{
576
583
        Scene *scene = CTX_data_scene(C);
577
 
        SpaceImage *sima= CTX_wm_space_image(C);
578
 
        Object *obedit= CTX_data_edit_object(C);
 
584
        SpaceImage *sima = CTX_wm_space_image(C);
 
585
        Object *obedit = CTX_data_edit_object(C);
579
586
        Image *ima;
580
587
 
581
 
        ima= ED_space_image(sima);
 
588
        ima = ED_space_image(sima);
582
589
 
583
 
        if(sima->iuser.flag & IMA_ANIM_ALWAYS)
 
590
        if (sima->iuser.flag & IMA_ANIM_ALWAYS)
584
591
                BKE_image_user_calc_frame(&sima->iuser, scene->r.cfra, 0);
585
592
        
586
593
        /* check if we have to set the image from the editmesh */
587
 
        if(ima && (ima->source==IMA_SRC_VIEWER || sima->pin));
588
 
        else if(obedit && obedit->type == OB_MESH) {
589
 
                Mesh *me= (Mesh*)obedit->data;
590
 
                EditMesh *em= BKE_mesh_get_editmesh(me);
591
 
                int sloppy= 1; /* partially selected face is ok */
 
594
        if (ima && (ima->source == IMA_SRC_VIEWER || sima->pin)) ;
 
595
        else if (obedit && obedit->type == OB_MESH) {
 
596
                Mesh *me = (Mesh *)obedit->data;
 
597
                struct BMEditMesh *em = me->edit_btmesh;
 
598
                int sloppy = 1; /* partially selected face is ok */
592
599
 
593
 
                if(scene_use_new_shading_nodes(scene)) {
 
600
                if (scene_use_new_shading_nodes(scene)) {
594
601
                        /* new shading system, get image from material */
595
 
                        EditFace *efa= EM_get_actFace(em, sloppy);
 
602
                        BMFace *efa = BM_active_face_get(em->bm, sloppy);
596
603
 
597
 
                        if(efa) {
 
604
                        if (efa) {
598
605
                                Image *node_ima;
599
 
                                ED_object_get_active_image(obedit, efa->mat_nr, &node_ima, NULL, NULL);
 
606
                                ED_object_get_active_image(obedit, efa->mat_nr + 1, &node_ima, NULL, NULL);
600
607
 
601
 
                                if(node_ima)
602
 
                                        sima->image= node_ima;
 
608
                                if (node_ima)
 
609
                                        sima->image = node_ima;
603
610
                        }
604
611
                }
605
612
                else {
606
613
                        /* old shading system, we set texface */
607
 
                        MTFace *tf;
 
614
                        MTexPoly *tf;
608
615
                        
609
 
                        if(em && EM_texFaceCheck(em)) {
610
 
                                sima->image= NULL;
611
 
                                
612
 
                                tf = EM_get_active_mtface(em, NULL, NULL, sloppy);
613
 
                                
614
 
                                if(tf) {
 
616
                        if (em && EDBM_mtexpoly_check(em)) {
 
617
                                sima->image = NULL;
 
618
                                
 
619
                                tf = EDBM_mtexpoly_active_get(em, NULL, TRUE); /* partially selected face is ok */
 
620
                                
 
621
                                if (tf) {
615
622
                                        /* don't need to check for pin here, see above */
616
 
                                        sima->image= tf->tpage;
 
623
                                        sima->image = tf->tpage;
617
624
                                        
618
 
                                        if(sima->flag & SI_EDITTILE);
619
 
                                        else sima->curtile= tf->tile;
 
625
                                        if (sima->flag & SI_EDITTILE) ;
 
626
                                        else sima->curtile = tf->tile;
620
627
                                }
621
628
                        }
622
629
                }
623
 
 
624
 
                BKE_mesh_end_editmesh(obedit->data, em);
625
630
        }
626
631
}
627
632
 
628
633
static void image_listener(ScrArea *sa, wmNotifier *wmn)
629
634
{
630
 
        SpaceImage *sima= (SpaceImage *)sa->spacedata.first;
 
635
        SpaceImage *sima = (SpaceImage *)sa->spacedata.first;
631
636
        
632
637
        /* context changes */
633
 
        switch(wmn->category) {
 
638
        switch (wmn->category) {
634
639
                case NC_SCENE:
635
 
                        switch(wmn->data) {
 
640
                        switch (wmn->data) {
636
641
                                case ND_FRAME:
637
642
                                        image_scopes_tag_refresh(sa);
638
643
                                        ED_area_tag_refresh(sa);
656
661
                        }
657
662
                        break;
658
663
                case NC_SPACE:  
659
 
                        if(wmn->data == ND_SPACE_IMAGE) {
 
664
                        if (wmn->data == ND_SPACE_IMAGE) {
660
665
                                image_scopes_tag_refresh(sa);
661
666
                                ED_area_tag_redraw(sa);
662
667
                        }
663
668
                        break;
664
669
                case NC_GEOM:
665
 
                        switch(wmn->data) {
 
670
                        switch (wmn->data) {
666
671
                                case ND_DATA:
667
672
                                case ND_SELECT:
668
673
                                        image_scopes_tag_refresh(sa);
672
677
                        }
673
678
                case NC_OBJECT:
674
679
                {
675
 
                        Object *ob= (Object *)wmn->reference;
676
 
                        switch(wmn->data) {
 
680
                        Object *ob = (Object *)wmn->reference;
 
681
                        switch (wmn->data) {
677
682
                                case ND_TRANSFORM:
678
683
                                case ND_MODIFIER:
679
 
                                        if(ob && (ob->mode & OB_MODE_EDIT) && sima->lock && (sima->flag & SI_DRAWSHADOW)) {
 
684
                                        if (ob && (ob->mode & OB_MODE_EDIT) && sima->lock && (sima->flag & SI_DRAWSHADOW)) {
680
685
                                                ED_area_tag_refresh(sa);
681
686
                                                ED_area_tag_redraw(sa);
682
687
                                        }
690
695
 
691
696
static int image_context(const bContext *C, const char *member, bContextDataResult *result)
692
697
{
693
 
        SpaceImage *sima= CTX_wm_space_image(C);
 
698
        SpaceImage *sima = CTX_wm_space_image(C);
694
699
 
695
 
        if(CTX_data_dir(member)) {
 
700
        if (CTX_data_dir(member)) {
696
701
                CTX_data_dir_set(result, image_context_dir);
697
702
        }
698
 
        else if(CTX_data_equals(member, "edit_image")) {
699
 
                CTX_data_id_pointer_set(result, (ID*)ED_space_image(sima));
 
703
        else if (CTX_data_equals(member, "edit_image")) {
 
704
                CTX_data_id_pointer_set(result, (ID *)ED_space_image(sima));
700
705
                return 1;
701
706
        }
702
707
 
708
713
/* sets up the fields of the View2D from zoom and offset */
709
714
static void image_main_area_set_view2d(SpaceImage *sima, ARegion *ar)
710
715
{
711
 
        Image *ima= ED_space_image(sima);
 
716
        Image *ima = ED_space_image(sima);
712
717
        float x1, y1, w, h;
713
718
        int width, height, winx, winy;
714
719
        
715
720
#if 0
716
 
        if(image_preview_active(curarea, &width, &height));
 
721
        if (image_preview_active(curarea, &width, &height)) ;
717
722
        else
718
723
#endif
719
724
        ED_space_image_size(sima, &width, &height);
720
725
 
721
 
        w= width;
722
 
        h= height;
 
726
        w = width;
 
727
        h = height;
723
728
        
724
 
        if(ima)
725
 
                h *= ima->aspy/ima->aspx;
 
729
        if (ima)
 
730
                h *= ima->aspy / ima->aspx;
726
731
 
727
 
        winx= ar->winrct.xmax - ar->winrct.xmin + 1;
728
 
        winy= ar->winrct.ymax - ar->winrct.ymin + 1;
 
732
        winx = ar->winrct.xmax - ar->winrct.xmin + 1;
 
733
        winy = ar->winrct.ymax - ar->winrct.ymin + 1;
729
734
                
730
 
        ar->v2d.tot.xmin= 0;
731
 
        ar->v2d.tot.ymin= 0;
732
 
        ar->v2d.tot.xmax= w;
733
 
        ar->v2d.tot.ymax= h;
 
735
        ar->v2d.tot.xmin = 0;
 
736
        ar->v2d.tot.ymin = 0;
 
737
        ar->v2d.tot.xmax = w;
 
738
        ar->v2d.tot.ymax = h;
734
739
        
735
 
        ar->v2d.mask.xmin= ar->v2d.mask.ymin= 0;
736
 
        ar->v2d.mask.xmax= winx;
737
 
        ar->v2d.mask.ymax= winy;
 
740
        ar->v2d.mask.xmin = ar->v2d.mask.ymin = 0;
 
741
        ar->v2d.mask.xmax = winx;
 
742
        ar->v2d.mask.ymax = winy;
738
743
 
739
744
        /* which part of the image space do we see? */
740
 
        x1= ar->winrct.xmin+(winx-sima->zoom*w)/2.0f;
741
 
        y1= ar->winrct.ymin+(winy-sima->zoom*h)/2.0f;
 
745
        x1 = ar->winrct.xmin + (winx - sima->zoom * w) / 2.0f;
 
746
        y1 = ar->winrct.ymin + (winy - sima->zoom * h) / 2.0f;
742
747
 
743
 
        x1-= sima->zoom*sima->xof;
744
 
        y1-= sima->zoom*sima->yof;
 
748
        x1 -= sima->zoom * sima->xof;
 
749
        y1 -= sima->zoom * sima->yof;
745
750
        
746
751
        /* relative display right */
747
 
        ar->v2d.cur.xmin= ((ar->winrct.xmin - (float)x1)/sima->zoom);
748
 
        ar->v2d.cur.xmax= ar->v2d.cur.xmin + ((float)winx/sima->zoom);
 
752
        ar->v2d.cur.xmin = ((ar->winrct.xmin - (float)x1) / sima->zoom);
 
753
        ar->v2d.cur.xmax = ar->v2d.cur.xmin + ((float)winx / sima->zoom);
749
754
        
750
755
        /* relative display left */
751
 
        ar->v2d.cur.ymin= ((ar->winrct.ymin-(float)y1)/sima->zoom);
752
 
        ar->v2d.cur.ymax= ar->v2d.cur.ymin + ((float)winy/sima->zoom);
 
756
        ar->v2d.cur.ymin = ((ar->winrct.ymin - (float)y1) / sima->zoom);
 
757
        ar->v2d.cur.ymax = ar->v2d.cur.ymin + ((float)winy / sima->zoom);
753
758
        
754
759
        /* normalize 0.0..1.0 */
755
760
        ar->v2d.cur.xmin /= w;
767
772
        // UI_view2d_region_reinit(&ar->v2d, V2D_COMMONVIEW_STANDARD, ar->winx, ar->winy);
768
773
 
769
774
        /* image paint polls for mode */
770
 
        keymap= WM_keymap_find(wm->defaultconf, "Image Paint", 0, 0);
 
775
        keymap = WM_keymap_find(wm->defaultconf, "Image Paint", 0, 0);
771
776
        WM_event_add_keymap_handler_bb(&ar->handlers, keymap, &ar->v2d.mask, &ar->winrct);
772
777
 
773
 
        keymap= WM_keymap_find(wm->defaultconf, "UV Editor", 0, 0);
 
778
        keymap = WM_keymap_find(wm->defaultconf, "UV Editor", 0, 0);
774
779
        WM_event_add_keymap_handler(&ar->handlers, keymap);
775
780
        
776
 
        keymap= WM_keymap_find(wm->defaultconf, "UV Sculpt", 0, 0);
 
781
        keymap = WM_keymap_find(wm->defaultconf, "UV Sculpt", 0, 0);
777
782
        WM_event_add_keymap_handler(&ar->handlers, keymap);
778
783
 
779
784
        /* own keymaps */
780
 
        keymap= WM_keymap_find(wm->defaultconf, "Image Generic", SPACE_IMAGE, 0);
 
785
        keymap = WM_keymap_find(wm->defaultconf, "Image Generic", SPACE_IMAGE, 0);
781
786
        WM_event_add_keymap_handler(&ar->handlers, keymap);
782
 
        keymap= WM_keymap_find(wm->defaultconf, "Image", SPACE_IMAGE, 0);
 
787
        keymap = WM_keymap_find(wm->defaultconf, "Image", SPACE_IMAGE, 0);
783
788
        WM_event_add_keymap_handler_bb(&ar->handlers, keymap, &ar->v2d.mask, &ar->winrct);
784
789
 
785
790
}
787
792
static void image_main_area_draw(const bContext *C, ARegion *ar)
788
793
{
789
794
        /* draw entirely, view changes should be handled here */
790
 
        SpaceImage *sima= CTX_wm_space_image(C);
791
 
        Object *obact= CTX_data_active_object(C);
792
 
        Object *obedit= CTX_data_edit_object(C);
793
 
        Scene *scene= CTX_data_scene(C);
794
 
        View2D *v2d= &ar->v2d;
 
795
        SpaceImage *sima = CTX_wm_space_image(C);
 
796
        Object *obact = CTX_data_active_object(C);
 
797
        Object *obedit = CTX_data_edit_object(C);
 
798
        Scene *scene = CTX_data_scene(C);
 
799
        View2D *v2d = &ar->v2d;
795
800
        //View2DScrollers *scrollers;
796
801
        float col[3];
797
802
        
804
809
        glClear(GL_COLOR_BUFFER_BIT);
805
810
 
806
811
        /* put scene context variable in iuser */
807
 
        sima->iuser.scene= scene;
 
812
        sima->iuser.scene = scene;
808
813
 
809
814
        /* we set view2d from own zoom and offset each time */
810
815
        image_main_area_set_view2d(sima, ar);
827
832
        draw_image_grease_pencil((bContext *)C, 0);
828
833
        
829
834
        /* scrollers? */
830
 
        /*scrollers= UI_view2d_scrollers_calc(C, v2d, V2D_UNIT_VALUES, V2D_GRID_CLAMP, V2D_ARG_DUMMY, V2D_ARG_DUMMY);
 
835
#if 0
 
836
        scrollers = UI_view2d_scrollers_calc(C, v2d, V2D_UNIT_VALUES, V2D_GRID_CLAMP, V2D_ARG_DUMMY, V2D_ARG_DUMMY);
831
837
        UI_view2d_scrollers_draw(C, v2d, scrollers);
832
 
        UI_view2d_scrollers_free(scrollers);*/
 
838
        UI_view2d_scrollers_free(scrollers);
 
839
#endif
833
840
}
834
841
 
835
842
static void image_main_area_listener(ARegion *ar, wmNotifier *wmn)
836
843
{
837
844
        /* context changes */
838
 
        switch(wmn->category) {
 
845
        switch (wmn->category) {
839
846
                case NC_SCREEN:
840
 
                        if (wmn->data==ND_GPENCIL)
 
847
                        if (wmn->data == ND_GPENCIL)
841
848
                                ED_region_tag_redraw(ar);
842
 
                break;
 
849
                        break;
843
850
        }
844
851
}
845
852
 
852
859
 
853
860
        ED_region_panels_init(wm, ar);
854
861
        
855
 
        keymap= WM_keymap_find(wm->defaultconf, "Image Generic", SPACE_IMAGE, 0);
 
862
        keymap = WM_keymap_find(wm->defaultconf, "Image Generic", SPACE_IMAGE, 0);
856
863
        WM_event_add_keymap_handler(&ar->handlers, keymap);
857
864
}
858
865
 
864
871
static void image_buttons_area_listener(ARegion *ar, wmNotifier *wmn)
865
872
{
866
873
        /* context changes */
867
 
        switch(wmn->category) {
 
874
        switch (wmn->category) {
868
875
                case NC_SCREEN:
869
 
                        if (wmn->data==ND_GPENCIL)
 
876
                        if (wmn->data == ND_GPENCIL)
870
877
                                ED_region_tag_redraw(ar);
871
878
                        break;
872
879
                case NC_BRUSH:
873
 
                        if(wmn->action==NA_EDITED)
 
880
                        if (wmn->action == NA_EDITED)
874
881
                                ED_region_tag_redraw(ar);
875
882
                        break;
 
883
                case NC_TEXTURE:
 
884
                case NC_MATERIAL:
 
885
                        /* sending by texture render job and needed to properly update displaying
 
886
                         * brush texture icon */
 
887
                        ED_region_tag_redraw(ar);
 
888
                        break;
876
889
        }
877
890
}
878
891
 
885
898
        
886
899
        ED_region_panels_init(wm, ar);
887
900
        
888
 
        keymap= WM_keymap_find(wm->defaultconf, "Image Generic", SPACE_IMAGE, 0);
 
901
        keymap = WM_keymap_find(wm->defaultconf, "Image Generic", SPACE_IMAGE, 0);
889
902
        WM_event_add_keymap_handler(&ar->handlers, keymap);
890
903
}
891
904
 
892
905
static void image_scope_area_draw(const bContext *C, ARegion *ar)
893
906
{
894
 
        SpaceImage *sima= CTX_wm_space_image(C);
895
 
        Scene *scene= CTX_data_scene(C);
 
907
        SpaceImage *sima = CTX_wm_space_image(C);
 
908
        Scene *scene = CTX_data_scene(C);
896
909
        void *lock;
897
 
        ImBuf *ibuf= ED_space_image_acquire_buffer(sima, &lock);
898
 
        if(ibuf) {
899
 
                scopes_update(&sima->scopes, ibuf, scene->r.color_mgt_flag & R_COLOR_MANAGEMENT );
 
910
        ImBuf *ibuf = ED_space_image_acquire_buffer(sima, &lock);
 
911
        if (ibuf) {
 
912
                scopes_update(&sima->scopes, ibuf, scene->r.color_mgt_flag & R_COLOR_MANAGEMENT);
900
913
        }
901
914
        ED_space_image_release_buffer(sima, lock);
902
915
        
906
919
static void image_scope_area_listener(ARegion *ar, wmNotifier *wmn)
907
920
{
908
921
        /* context changes */
909
 
        switch(wmn->category) {
 
922
        switch (wmn->category) {
910
923
                case NC_SCENE:
911
 
                        switch(wmn->data) {
 
924
                        switch (wmn->data) {
912
925
                                case ND_MODE:
913
926
                                case ND_RENDER_RESULT:
914
927
                                case ND_COMPO_RESULT:
942
955
static void image_header_area_listener(ARegion *ar, wmNotifier *wmn)
943
956
{
944
957
        /* context changes */
945
 
        switch(wmn->category) {
 
958
        switch (wmn->category) {
946
959
                case NC_SCENE:
947
 
                        switch(wmn->data) {
 
960
                        switch (wmn->data) {
948
961
                                case ND_MODE:
949
962
                                case ND_TOOLSETTINGS:
950
963
                                        ED_region_tag_redraw(ar);
952
965
                        }
953
966
                        break;
954
967
                case NC_GEOM:
955
 
                        switch(wmn->data) {
 
968
                        switch (wmn->data) {
956
969
                                case ND_DATA:
957
970
                                case ND_SELECT:
958
971
                                        ED_region_tag_redraw(ar);
967
980
/* only called once, from space/spacetypes.c */
968
981
void ED_spacetype_image(void)
969
982
{
970
 
        SpaceType *st= MEM_callocN(sizeof(SpaceType), "spacetype image");
 
983
        SpaceType *st = MEM_callocN(sizeof(SpaceType), "spacetype image");
971
984
        ARegionType *art;
972
985
        
973
 
        st->spaceid= SPACE_IMAGE;
 
986
        st->spaceid = SPACE_IMAGE;
974
987
        strncpy(st->name, "Image", BKE_ST_MAXNAME);
975
988
        
976
 
        st->new= image_new;
977
 
        st->free= image_free;
978
 
        st->init= image_init;
979
 
        st->duplicate= image_duplicate;
980
 
        st->operatortypes= image_operatortypes;
981
 
        st->keymap= image_keymap;
982
 
        st->dropboxes= image_dropboxes;
983
 
        st->refresh= image_refresh;
984
 
        st->listener= image_listener;
985
 
        st->context= image_context;
 
989
        st->new = image_new;
 
990
        st->free = image_free;
 
991
        st->init = image_init;
 
992
        st->duplicate = image_duplicate;
 
993
        st->operatortypes = image_operatortypes;
 
994
        st->keymap = image_keymap;
 
995
        st->dropboxes = image_dropboxes;
 
996
        st->refresh = image_refresh;
 
997
        st->listener = image_listener;
 
998
        st->context = image_context;
986
999
        
987
1000
        /* regions: main window */
988
 
        art= MEM_callocN(sizeof(ARegionType), "spacetype image region");
 
1001
        art = MEM_callocN(sizeof(ARegionType), "spacetype image region");
989
1002
        art->regionid = RGN_TYPE_WINDOW;
990
 
        art->keymapflag= ED_KEYMAP_FRAMES|ED_KEYMAP_GPENCIL;
991
 
        art->init= image_main_area_init;
992
 
        art->draw= image_main_area_draw;
993
 
        art->listener= image_main_area_listener;
 
1003
        art->keymapflag = ED_KEYMAP_FRAMES | ED_KEYMAP_GPENCIL;
 
1004
        art->init = image_main_area_init;
 
1005
        art->draw = image_main_area_draw;
 
1006
        art->listener = image_main_area_listener;
994
1007
 
995
1008
        BLI_addhead(&st->regiontypes, art);
996
1009
        
997
1010
        /* regions: listview/buttons */
998
 
        art= MEM_callocN(sizeof(ARegionType), "spacetype image region");
 
1011
        art = MEM_callocN(sizeof(ARegionType), "spacetype image region");
999
1012
        art->regionid = RGN_TYPE_UI;
1000
 
        art->prefsizex= 220; // XXX
1001
 
        art->keymapflag= ED_KEYMAP_UI|ED_KEYMAP_FRAMES;
1002
 
        art->listener= image_buttons_area_listener;
1003
 
        art->init= image_buttons_area_init;
1004
 
        art->draw= image_buttons_area_draw;
 
1013
        art->prefsizex = 220; // XXX
 
1014
        art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_FRAMES;
 
1015
        art->listener = image_buttons_area_listener;
 
1016
        art->init = image_buttons_area_init;
 
1017
        art->draw = image_buttons_area_draw;
1005
1018
        BLI_addhead(&st->regiontypes, art);
1006
1019
 
1007
1020
        image_buttons_register(art);
1008
1021
        ED_uvedit_buttons_register(art);
1009
1022
        
1010
1023
        /* regions: statistics/scope buttons */
1011
 
        art= MEM_callocN(sizeof(ARegionType), "spacetype image region");
 
1024
        art = MEM_callocN(sizeof(ARegionType), "spacetype image region");
1012
1025
        art->regionid = RGN_TYPE_PREVIEW;
1013
 
        art->prefsizex= 220; // XXX
1014
 
        art->keymapflag= ED_KEYMAP_UI|ED_KEYMAP_FRAMES;
1015
 
        art->listener= image_scope_area_listener;
1016
 
        art->init= image_scope_area_init;
1017
 
        art->draw= image_scope_area_draw;
 
1026
        art->prefsizex = 220; // XXX
 
1027
        art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_FRAMES;
 
1028
        art->listener = image_scope_area_listener;
 
1029
        art->init = image_scope_area_init;
 
1030
        art->draw = image_scope_area_draw;
1018
1031
        BLI_addhead(&st->regiontypes, art);
1019
1032
 
1020
1033
        /* regions: header */
1021
 
        art= MEM_callocN(sizeof(ARegionType), "spacetype image region");
 
1034
        art = MEM_callocN(sizeof(ARegionType), "spacetype image region");
1022
1035
        art->regionid = RGN_TYPE_HEADER;
1023
 
        art->prefsizey= HEADERY;
1024
 
        art->keymapflag= ED_KEYMAP_UI|ED_KEYMAP_VIEW2D|ED_KEYMAP_FRAMES|ED_KEYMAP_HEADER;
1025
 
        art->listener= image_header_area_listener;
1026
 
        art->init= image_header_area_init;
1027
 
        art->draw= image_header_area_draw;
 
1036
        art->prefsizey = HEADERY;
 
1037
        art->keymapflag = ED_KEYMAP_UI | ED_KEYMAP_VIEW2D | ED_KEYMAP_FRAMES | ED_KEYMAP_HEADER;
 
1038
        art->listener = image_header_area_listener;
 
1039
        art->init = image_header_area_init;
 
1040
        art->draw = image_header_area_draw;
1028
1041
        
1029
1042
        BLI_addhead(&st->regiontypes, art);
1030
1043