workbench/libs/muimaster/classes/imageadjust.c

   1 /*
   2     Copyright © 2002-2003, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #define MUIMASTER_YES_INLINE_STDARG
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10
  11 #include <graphics/gfx.h>
  12 #include <graphics/view.h>
  13 #include <clib/alib_protos.h>
  14
  15 #include <proto/dos.h>
  16 #include <proto/exec.h>
  17 #include <proto/graphics.h>
  18 #include <proto/utility.h>
  19 #include <proto/intuition.h>
  20 #include <proto/muimaster.h>
  21
  22 #include <string.h>
  23
  24 /*  #define MYDEBUG 1 */
  25 #include "debug.h"
  26
  27 #include "imspec_intern.h"
  28 #include "mui.h"
  29 #include "muimaster_intern.h"
  30 #include "support.h"
  31 #include "support_classes.h"
  32 #include "imageadjust_private.h"
  33
  34 extern struct Library *MUIMasterBase;
  35
  36 STATIC STRPTR StrDupPooled(APTR pool, CONST_STRPTR str)
  37 {
  38     char *newstr;
  39     if (!str)
  40         return NULL;
  41     newstr = AllocPooled(pool, strlen(str) + 1);
  42     if (newstr)
  43         strcpy(newstr, str);
  44     return newstr;
  45 }
  46
  47 static void Bitmap_Function(struct Hook *hook, Object *obj, APTR msg)
  48 {
  49     struct Imageadjust_DATA *data = *(struct Imageadjust_DATA **)msg;
  50     char buf[255];
  51     STRPTR name = NULL;
  52
  53     get(data->bitmap_string, MUIA_String_Contents, &name);
  54     if (name && strlen(name) > 0)
  55     {
  56         snprintf(buf, 255, "5:%s", name);
  57         set(data->bitmap_image, MUIA_Imagedisplay_Spec, (IPTR) buf);
  58     }
  59 }
  60
  61
  62 static void Gradient_Function(struct Hook *hook, Object *obj, APTR msg)
  63 {
  64     struct Imageadjust_DATA *data = *(struct Imageadjust_DATA **)msg;
  65     struct MUI_RGBcolor *start_rgb;
  66     struct MUI_RGBcolor *end_rgb;
  67     LONG angle = XGET(data->gradient_angle_slider, MUIA_Numeric_Value);
  68     LONG is_tiled = XGET(data->gradient_type_cycle, MUIA_Cycle_Active);
  69
  70     start_rgb = (struct MUI_RGBcolor *)XGET(data->gradient_start_poppen,
  71         MUIA_Pendisplay_RGBcolor);
  72     end_rgb = (struct MUI_RGBcolor *)XGET(data->gradient_end_poppen,
  73         MUIA_Pendisplay_RGBcolor);
  74
  75     snprintf(data->gradient_imagespec, sizeof(data->gradient_imagespec),
  76         "%s:%d,%08x,%08x,%08x-%08x,%08x,%08x",
  77         is_tiled ? "8" : "7",
  78         (int)angle,
  79         (unsigned int)start_rgb->red,
  80         (unsigned int)start_rgb->green,
  81         (unsigned int)start_rgb->blue,
  82         (unsigned int)end_rgb->red,
  83         (unsigned int)end_rgb->green, (unsigned int)end_rgb->blue);
  84
  85     set(data->gradient_imagedisplay, MUIA_Imagedisplay_Spec,
  86         data->gradient_imagespec);
  87 }
  88
  89 static void GradientSwap_Function(struct Hook *hook, Object *obj, APTR msg)
  90 {
  91     struct Imageadjust_DATA *data = *(struct Imageadjust_DATA **)msg;
  92     struct MUI_RGBcolor *start_rgb;
  93     struct MUI_RGBcolor *end_rgb;
  94     struct MUI_RGBcolor tmp;
  95
  96     start_rgb = (struct MUI_RGBcolor *)XGET(data->gradient_start_poppen,
  97         MUIA_Pendisplay_RGBcolor);
  98     end_rgb = (struct MUI_RGBcolor *)XGET(data->gradient_end_poppen,
  99         MUIA_Pendisplay_RGBcolor);
 100
 101     tmp = *start_rgb;
 102     set(data->gradient_start_poppen, MUIA_Pendisplay_RGBcolor,
 103         (IPTR) end_rgb);
 104     set(data->gradient_end_poppen, MUIA_Pendisplay_RGBcolor, (IPTR) & tmp);
 105     Gradient_Function(NULL, obj, &data);
 106 }
 107
 108
 109 static VOID Pattern_Select_Function(struct Hook *hook, Object *obj,
 110     void **msg)
 111 {
 112     struct Imageadjust_DATA *data = (struct Imageadjust_DATA *)hook->h_Data;
 113     SIPTR new_selected = (SIPTR) msg[0];
 114
 115     if (data->last_pattern_selected != -1)
 116         set(data->pattern_image[data->last_pattern_selected], MUIA_Selected,
 117             FALSE);
 118     data->last_pattern_selected = new_selected;
 119 }
 120
 121
 122 static VOID Vector_Select_Function(struct Hook *hook, Object *obj,
 123     void **msg)
 124 {
 125     struct Imageadjust_DATA *data = (struct Imageadjust_DATA *)hook->h_Data;
 126     SIPTR new_selected = (SIPTR) msg[0];
 127
 128     if (data->last_vector_selected != -1)
 129         set(data->vector_image[data->last_vector_selected], MUIA_Selected,
 130             FALSE);
 131     data->last_vector_selected = new_selected;
 132 }
 133
 134
 135 struct ExternalListEntry
 136 {
 137     STRPTR reldir;
 138     ULONG dirlen;
 139     STRPTR filename;
 140     ULONG namelen;
 141     LONG type;
 142 };
 143
 144 static void Imageadjust_External_Display(struct Hook *h, char **strings,
 145     struct ExternalListEntry *entry)
 146 {
 147     static char buf[256];
 148
 149     if (entry->filename)
 150     {
 151         int len;
 152         *strings = buf;
 153         snprintf(buf, 256, "%s", FilePart(entry->filename));
 154         buf[255] = 0;
 155         len = strlen(buf);
 156         if (len > 4 && !strcmp(buf + len - 4, ".mf0"))
 157             buf[len - 4] = 0;
 158         else if (len > 4 && !strcmp(buf + len - 4, ".mb0"))
 159             buf[len - 4] = 0;
 160         else if (len > 4 && !strcmp(buf + len - 4, ".mbr"))
 161             buf[len - 4] = 0;
 162         else if (len > 6 && !strcmp(buf + len - 6, ".image"))
 163             buf[len - 6] = 0;
 164     }
 165 }
 166
 167 static struct ExternalListEntry *Imageadjust_External_Construct(struct Hook
 168     *h, APTR pool, struct ExternalListEntry *ele)
 169 {
 170     struct ExternalListEntry *entry = NULL;
 171
 172     if (NULL == ele)
 173         return NULL;
 174
 175     if (NULL != ele->filename)
 176     {
 177         entry = AllocPooled(pool, sizeof(struct ExternalListEntry));
 178         if (NULL != entry)
 179         {
 180             *entry = *ele;
 181             entry->filename = StrDupPooled(pool, entry->filename);
 182             entry->reldir = StrDupPooled(pool, entry->reldir);
 183             return entry;
 184         }
 185     }
 186     return NULL;
 187 }
 188
 189 static void Imageadjust_External_Destruct(struct Hook *h, APTR pool,
 190     struct ExternalListEntry *entry)
 191 {
 192     if (entry != NULL)
 193     {
 194         if (entry->filename != NULL)
 195             FreePooled(pool, entry->filename, entry->namelen + 1);
 196         if (entry->reldir != NULL)
 197             FreePooled(pool, entry->reldir, entry->dirlen + 1);
 198         FreePooled(pool, entry, sizeof(struct ExternalListEntry));
 199     }
 200 }
 201
 202
 203 /**************************************************************************
 204  Adds a directory to the list
 205 **************************************************************************/
 206 static int AddDirectory(Object *list, STRPTR dir, LONG parent)
 207 {
 208     BPTR lock = Lock(dir, ACCESS_READ);
 209     struct ExAllControl *eac;
 210     struct ExAllData *ead, *EAData;
 211     LONG more;
 212     int dir_len = strlen(dir);
 213     if (!lock)
 214         return 0;
 215
 216     //bug("AddDirectory: locked %s\n", dir);
 217
 218     eac = (struct ExAllControl *)AllocDosObject(DOS_EXALLCONTROL, NULL);
 219     if (!eac)
 220     {
 221         UnLock(lock);
 222         return 0;
 223     }
 224
 225     EAData = AllocVec(1024, 0);
 226     if (!EAData)
 227     {
 228         FreeDosObject(DOS_EXALLCONTROL, eac);
 229         UnLock(lock);
 230         return 0;
 231     }
 232
 233     eac->eac_LastKey = 0;
 234
 235     do
 236     {
 237         //DoMethod(_app(list), MUIM_Application_InputBuffered);
 238
 239         more = ExAll(lock, EAData, 1024, ED_TYPE, eac);
 240         if ((!more) && (IoErr() != ERROR_NO_MORE_ENTRIES))
 241             break;
 242         if (eac->eac_Entries == 0)
 243             continue;
 244
 245         ead = EAData;
 246         do
 247         {
 248             size_t namelen = strlen(ead->ed_Name);
 249             int len = dir_len + namelen + 10;
 250             char *buf;
 251
 252             //DoMethod(_app(list), MUIM_Application_InputBuffered);
 253
 254             buf = AllocVec(len, 0);
 255             if (buf)
 256             {
 257                 LONG num = 0;
 258                 int is_directory;
 259                 BOOL add_me = TRUE;
 260
 261                 if (ead->ed_Type > 0)
 262                 {
 263                     is_directory = 1;
 264                     if (ead->ed_Type == ST_SOFTLINK)
 265                     {
 266                         /* TODO: Special handling */
 267                     }
 268                 }
 269                 else
 270                     is_directory = 0;
 271
 272                 strcpy(buf, dir);
 273                 AddPart(buf, ead->ed_Name, len);
 274
 275                 if (!is_directory && namelen > 4
 276                     && !strcmp(ead->ed_Name + namelen - 4, ".mf1"))
 277                     add_me = FALSE;
 278                 if (!is_directory && namelen > 4
 279                     && !strcmp(ead->ed_Name + namelen - 4, ".mb1"))
 280                     add_me = FALSE;
 281
 282                 if (add_me)
 283                 {
 284                     struct ExternalListEntry ele;
 285                     //bug("AddDirectory: adding image %s\n", buf);
 286
 287
 288                     ele.reldir = dir + strlen(IMSPEC_EXTERNAL_PREFIX);
 289                     ele.dirlen = strlen(ele.reldir);
 290                     ele.filename = ead->ed_Name;
 291                     ele.namelen = strlen(ele.filename);
 292                     ele.type = ead->ed_Type;
 293
 294                     if (!is_directory)
 295                     {
 296                         num = DoMethod(list, MUIM_List_InsertSingle,
 297                             (IPTR) & ele, MUIV_List_Insert_Bottom);
 298                     }
 299                 }
 300                 // FIXME: where does num's value come from here?
 301                 if (num != -1 && is_directory)
 302                 {
 303                     AddDirectory(list, buf, num);
 304                 }
 305                 FreeVec(buf);
 306             }
 307             ead = ead->ed_Next;
 308         }
 309         while (ead);
 310     }
 311     while (more);
 312
 313     FreeVec(EAData);
 314     FreeDosObject(DOS_EXALLCONTROL, eac);
 315     UnLock(lock);
 316     return 1;
 317 }
 318
 319
 320
 321 /**************************************************************************
 322  ...
 323 **************************************************************************/
 324 STATIC VOID Imageadjust_SetImagespec(Object *obj,
 325     struct Imageadjust_DATA *data, char *spec)
 326 {
 327     char *s;
 328     if (!spec)
 329         spec = "0:128";
 330
 331     s = (char *)spec;
 332
 333     switch (*s)
 334     {
 335     case '0':
 336         {
 337             LONG pat;
 338             StrToLong(s + 2, &pat);
 339             pat -= MUII_BACKGROUND;
 340
 341             if (pat >= 0 && pat < 18)
 342             {
 343                 set(data->pattern_image[pat], MUIA_Selected, TRUE);
 344                 set(obj, MUIA_Group_ActivePage, 0);
 345             }
 346         }
 347         break;
 348
 349     case '1':
 350         {
 351             LONG vect;
 352             StrToLong(s + 2, &vect);
 353
 354             if (vect >= 0 && vect < 24)
 355             {
 356                 set(data->vector_image[vect], MUIA_Selected, TRUE);
 357                 set(obj, MUIA_Group_ActivePage, 1);
 358             }
 359
 360         }
 361         break;
 362
 363     case '2':
 364         switch (data->adjust_type)
 365         {
 366         case MUIV_Imageadjust_Type_All:
 367         case MUIV_Imageadjust_Type_Image:
 368             nfset(obj, MUIA_Group_ActivePage, 2);
 369             break;
 370         case MUIV_Imageadjust_Type_Background:
 371             nfset(obj, MUIA_Group_ActivePage, 1);
 372             break;
 373         default:
 374             nfset(obj, MUIA_Group_ActivePage, 0);
 375             break;
 376         }
 377         D(bug("imageadjust: setting color to %s\n", s));
 378         set(data->color_group, MUIA_Penadjust_Spec, (IPTR) s + 2);
 379         break;
 380
 381     case '3':
 382     case '4':
 383         {
 384             struct ExternalListEntry *entry;
 385             LONG entries = 0;
 386             int i;
 387
 388             set(obj, MUIA_Group_ActivePage, 3);
 389
 390             get(data->external_list, MUIA_List_Entries, &entries);
 391             for (i = 0; i < entries; i++)
 392             {
 393                 DoMethod(data->external_list, MUIM_List_GetEntry, i,
 394                     (IPTR) & entry);
 395                 if (entry != NULL
 396                     && entry->reldir != NULL && entry->filename != NULL)
 397                 {
 398                     STRPTR file = FilePart(s + 2);
 399                     //bug("entry->reldir = %s, s + 2 = %s, len=%d\n",
 400                     //entry->reldir, s + 2, strlen(s + 2) - strlen(file) - 1);
 401                     if (!strncmp(entry->reldir, s + 2,
 402                             strlen(s + 2) - strlen(file) - 1))
 403                     {
 404                         //bug("entry->filename = %s, file = %s\n",
 405                         //entry->filename, file);
 406                         if (!strcmp(entry->filename, file))
 407                         {
 408                             set(data->external_list, MUIA_List_Active, i);
 409                             break;
 410                         }
 411                     }
 412                 }
 413             }
 414         }
 415         break;
 416
 417     case '5':
 418         set(data->bitmap_string, MUIA_String_Contents, (IPTR) s + 2);
 419         Bitmap_Function(NULL, obj, &data);
 420         if (data->adjust_type == MUIV_Imageadjust_Type_All)
 421             set(obj, MUIA_Group_ActivePage, 4);
 422         else
 423             set(obj, MUIA_Group_ActivePage, 2);
 424         break;
 425
 426     case '6':
 427         {
 428             LONG img;
 429             StrToLong(s + 2, &img);
 430         }
 431         break;
 432
 433     case '7':
 434     case '8':
 435         {
 436             struct MUI_ImageSpec_intern spec;
 437             if (zune_gradient_string_to_intern(s + 2, &spec))
 438             {
 439                 struct MUI_RGBcolor col;
 440                 col.red = spec.u.gradient.start_rgb[0] * 0x01010101;
 441                 col.green = spec.u.gradient.start_rgb[1] * 0x01010101;
 442                 col.blue = spec.u.gradient.start_rgb[2] * 0x01010101;
 443
 444                 nnset(data->gradient_start_poppen, MUIA_Pendisplay_RGBcolor,
 445                     &col);
 446
 447                 col.red = spec.u.gradient.end_rgb[0] * 0x01010101;
 448                 col.green = spec.u.gradient.end_rgb[1] * 0x01010101;
 449                 col.blue = spec.u.gradient.end_rgb[2] * 0x01010101;
 450
 451                 nnset(data->gradient_end_poppen, MUIA_Pendisplay_RGBcolor,
 452                     &col);
 453
 454                 nnset(data->gradient_angle_slider, MUIA_Numeric_Value,
 455                     spec.u.gradient.angle);
 456
 457                 set(data->gradient_type_cycle, MUIA_Cycle_Active,
 458                     *s == '7' ? 0 : 1);
 459             }
 460
 461             Gradient_Function(NULL, obj, &data);
 462             if (data->adjust_type == MUIV_Imageadjust_Type_All)
 463                 set(obj, MUIA_Group_ActivePage, 5);
 464             else
 465                 set(obj, MUIA_Group_ActivePage, 3);
 466         }
 467         break;
 468     }
 469 }
 470
 471 IPTR Imageadjust__OM_NEW(struct IClass *cl, Object *obj, struct opSet *msg)
 472 {
 473     struct Imageadjust_DATA *data;
 474     struct TagItem *tag;
 475     struct TagItem *tags;
 476     static const char *const labels_all[] =
 477         { "Pattern", "Vector", "Color", "External", "Bitmap", "Gradient",
 478             NULL };
 479     static const char *const labels_image[] =
 480         { "Pattern", "Vector", "Color", "External", NULL };
 481     static const char *const labels_bg[] =
 482         { "Pattern", "Color", "Bitmap", "Gradient", NULL };
 483     static const char *const labels_color[] = { "Color", NULL };
 484     static const char *const gradient_type_entries[] =
 485         { "Scaled", "Tiled", NULL };
 486
 487     Object *pattern_group = NULL;
 488     Object *vector_group = NULL;
 489     Object *external_list = NULL;
 490     Object *bitmap_string = NULL;
 491     Object *bitmap_image = NULL;
 492     Object *bitmap_popasl = NULL;
 493     Object *gradient_imagedisplay = NULL;
 494     Object *gradient_start_poppen = NULL;
 495     Object *gradient_end_poppen = NULL;
 496     Object *gradient_angle_slider = NULL;
 497     Object *gradient_type_cycle = NULL;
 498     Object *gradient_horiz_button = NULL;
 499     Object *gradient_vert_button = NULL;
 500     Object *gradient_swap_button = NULL;
 501     char *spec = NULL;
 502     LONG i;
 503     LONG adjust_type;
 504     Object *color_group = NULL;
 505     Object *external_group = NULL;
 506     Object *bitmap_group = NULL;
 507     Object *gradient_group = NULL;
 508
 509     adjust_type =
 510         GetTagData(MUIA_Imageadjust_Type, MUIV_Imageadjust_Type_All,
 511         msg->ops_AttrList);
 512
 513     color_group = MUI_NewObject(MUIC_Penadjust, TAG_DONE);
 514
 515     if (adjust_type == MUIV_Imageadjust_Type_All ||
 516         adjust_type == MUIV_Imageadjust_Type_Image)
 517     {
 518         external_group = (Object *) ListviewObject,
 519             MUIA_Listview_List, (IPTR) (external_list =
 520                 (Object *) ListObject, InputListFrame,
 521                 MUIA_List_ConstructHook, MUIV_List_ConstructHook_String,
 522                 MUIA_List_DestructHook, MUIV_List_DestructHook_String,
 523                 End),
 524             End;
 525     }
 526
 527     if (adjust_type == MUIV_Imageadjust_Type_All ||
 528         adjust_type == MUIV_Imageadjust_Type_Background)
 529     {
 530         bitmap_group = (Object *) VGroup,
 531             Child, (IPTR) (bitmap_image = (Object *) ImagedisplayObject,
 532                 TextFrame,
 533                 InnerSpacing(0, 0),
 534                 MUIA_Imagedisplay_FreeHoriz, TRUE,
 535                 MUIA_Imagedisplay_FreeVert, TRUE,
 536                 MUIA_Dropable, FALSE,
 537                 End),
 538             Child, (IPTR) (bitmap_popasl = (Object *) PopaslObject,
 539                 MUIA_Popstring_String, (IPTR) (bitmap_string =
 540                     (Object *) StringObject, StringFrame, MUIA_CycleChain, 1,
 541                     End),
 542                 MUIA_Popstring_Button, (IPTR) PopButton(MUII_PopFile),
 543                 End),
 544             End;
 545
 546         gradient_group = (Object *) ColGroup(2),
 547             Child, (IPTR) FreeLabel("Type:"),
 548             Child, (IPTR) (gradient_type_cycle = MUI_MakeObject(MUIO_Cycle,
 549                 (IPTR) "Type:", (IPTR) gradient_type_entries)),
 550             Child, (IPTR) FreeLabel("Angle:"),
 551             Child, (IPTR) VGroup,
 552                 Child, (IPTR) HGroup,
 553                     MUIA_Group_SameWidth, TRUE,
 554                     Child,
 555                         (IPTR) (gradient_horiz_button = (Object *) TextObject,
 556                         ButtonFrame,
 557                         MUIA_Background, MUII_ButtonBack,
 558                         MUIA_InputMode, MUIV_InputMode_RelVerify,
 559                         MUIA_Text_PreParse, (IPTR) "\33c",
 560                         MUIA_Text_Contents, (IPTR) "Vertical",
 561                         End),
 562                     Child,
 563                         (IPTR) (gradient_vert_button = (Object *) TextObject,
 564                         ButtonFrame,
 565                         MUIA_Background, MUII_ButtonBack,
 566                         MUIA_InputMode, MUIV_InputMode_RelVerify,
 567                         MUIA_Text_PreParse, (IPTR) "\33c",
 568                         MUIA_Text_Contents, (IPTR) "Horizontal",
 569                         End),
 570                     End,
 571                 Child, (IPTR) (gradient_angle_slider = (Object *) SliderObject,
 572                     MUIA_Group_Horiz, TRUE,
 573                     MUIA_Numeric_Min, 0,
 574                     MUIA_Numeric_Max, 179,
 575                     End),
 576                 End,
 577             Child, (IPTR) FreeLabel("Colors:"),
 578             Child, (IPTR) HGroup,
 579                 Child, (IPTR) (gradient_start_poppen = (Object *) PoppenObject,
 580                     MUIA_Window_Title, (IPTR) "Start pen",
 581                     MUIA_Pendisplay_Spec, (IPTR) "rbbbbbbbb,bbbbbbbb,bbbbbbbb",
 582                     End),
 583                 Child, (IPTR) VCenter((gradient_swap_button =
 584                     (Object *) TextObject, ButtonFrame,
 585                     MUIA_Background, MUII_ButtonBack,
 586                     MUIA_InputMode, MUIV_InputMode_RelVerify,
 587                     MUIA_Text_Contents, (IPTR) "<->",
 588                     MUIA_Weight, 0,
 589                     End)),
 590                 Child, (IPTR) (gradient_end_poppen =
 591                     (Object *) PoppenObject,
 592                     MUIA_Window_Title, (IPTR) "End pen",
 593                     MUIA_Pendisplay_Spec, (IPTR) "r55555555,55555555,55555555",
 594                     End),
 595                 End,
 596             Child, (IPTR) FreeLabel("Preview:"),
 597             Child, (IPTR) (gradient_imagedisplay =
 598                 (Object *) ImagedisplayObject, TextFrame,
 599                 InnerSpacing(0, 0),
 600                 MUIA_Imagedisplay_FreeHoriz, TRUE,
 601                 MUIA_Imagedisplay_FreeVert, TRUE,
 602                 MUIA_Dropable, FALSE,
 603                 End),
 604             End;
 605     }
 606
 607     switch (adjust_type)
 608     {
 609     case MUIV_Imageadjust_Type_All:
 610         obj = (Object *) DoSuperNewTags(cl, obj, NULL,
 611             MUIA_Register_Titles, (IPTR) labels_all,
 612             Child, (IPTR) HCenter((pattern_group =
 613                     (Object *) ColGroup(6), End)),
 614             Child, (IPTR) HCenter((vector_group =
 615                     (Object *) ColGroup(6), End)),
 616             Child, (IPTR) color_group,
 617             Child, (IPTR) external_group,
 618             Child, (IPTR) bitmap_group,
 619             Child, (IPTR) gradient_group,
 620             TAG_MORE, (IPTR) msg->ops_AttrList);
 621         break;
 622     case MUIV_Imageadjust_Type_Background:
 623         obj = (Object *) DoSuperNewTags(cl, obj, NULL,
 624             MUIA_Register_Titles, (IPTR) labels_bg,
 625             Child, (IPTR) HCenter((pattern_group =
 626                 (Object *) ColGroup(6), End)),
 627             Child, (IPTR) color_group,
 628             Child, (IPTR) bitmap_group,
 629             Child, (IPTR) gradient_group,
 630             TAG_MORE, (IPTR) msg->ops_AttrList);
 631         break;
 632     case MUIV_Imageadjust_Type_Image:
 633         obj = (Object *) DoSuperNewTags(cl, obj, NULL,
 634             MUIA_Register_Titles, (IPTR) labels_image,
 635             Child, (IPTR) HCenter((pattern_group =
 636                 (Object *) ColGroup(6), End)),
 637             Child, (IPTR) HCenter((vector_group =
 638                 (Object *) ColGroup(6), End)),
 639             Child, (IPTR) color_group,
 640             Child, (IPTR) external_group,
 641             TAG_MORE, (IPTR) msg->ops_AttrList);
 642         break;
 643     case MUIV_Imageadjust_Type_Pen:
 644         obj = (Object *) DoSuperNewTags(cl, obj, NULL,
 645             MUIA_Register_Titles, (IPTR) labels_color,
 646             Child, (IPTR) color_group,
 647             TAG_MORE, (IPTR) msg->ops_AttrList);
 648         break;
 649     }
 650
 651     if (!obj)
 652         return FALSE;
 653
 654     data = INST_DATA(cl, obj);
 655     data->adjust_type = adjust_type;
 656     data->color_group = color_group;
 657     data->originator =
 658         (APTR) GetTagData(MUIA_Imageadjust_Originator, 0,
 659         msg->ops_AttrList);
 660
 661     if (adjust_type != MUIV_Imageadjust_Type_Pen)
 662     {
 663         data->last_pattern_selected = -1;
 664         data->pattern_select_hook.h_Data = data;
 665         data->pattern_select_hook.h_Entry = HookEntry;
 666         data->pattern_select_hook.h_SubEntry =
 667             (HOOKFUNC) Pattern_Select_Function;
 668
 669         for (i = 0; i < 18; i++)
 670         {
 671             data->pattern_image[i] = (Object *) ImageObject,
 672                 ButtonFrame,
 673                 MUIA_CycleChain, 1,
 674                 InnerSpacing(4, 4),
 675                 MUIA_Image_Spec, i + MUII_BACKGROUND,
 676                 MUIA_InputMode, MUIV_InputMode_Immediate,
 677                 MUIA_Image_FreeHoriz, TRUE,
 678                 MUIA_Image_FreeVert, TRUE,
 679                 MUIA_FixWidth, 16, MUIA_FixHeight, 16, End;
 680
 681             if (data->pattern_image[i])
 682             {
 683                 DoMethod(pattern_group, OM_ADDMEMBER,
 684                     (IPTR) data->pattern_image[i]);
 685                 DoMethod(data->pattern_image[i], MUIM_Notify, MUIA_Selected,
 686                     TRUE, (IPTR) obj, 3, MUIM_CallHook,
 687                     (IPTR) &data->pattern_select_hook, i);
 688             }
 689         }
 690
 691         if (adjust_type != MUIV_Imageadjust_Type_Background)
 692         {
 693             data->last_vector_selected = -1;
 694             data->vector_select_hook.h_Data = data;
 695             data->vector_select_hook.h_Entry = HookEntry;
 696             data->vector_select_hook.h_SubEntry =
 697                 (HOOKFUNC) Vector_Select_Function;
 698
 699             for (i = 0; i < 24; i++)
 700             {
 701                 char spec[10];
 702
 703                 snprintf(spec, sizeof(spec), "1:%d", (int)i);
 704                 data->vector_image[i] = (Object *) ImageObject,
 705                     ButtonFrame,
 706                     InnerSpacing(4, 4),
 707                     MUIA_CycleChain, 1,
 708                     MUIA_Image_Spec, (IPTR) spec,
 709                     MUIA_InputMode, MUIV_InputMode_Immediate,
 710                     MUIA_Weight, 0, End;
 711
 712                 if (data->vector_image[i])
 713                 {
 714                     DoMethod(vector_group, OM_ADDMEMBER,
 715                         (IPTR) data->vector_image[i]);
 716                     DoMethod(data->vector_image[i], MUIM_Notify,
 717                         MUIA_Selected, TRUE, (IPTR) obj, 3, MUIM_CallHook,
 718                         (IPTR) & data->vector_select_hook, i);
 719                 }
 720             }
 721         }
 722
 723         if (adjust_type != MUIV_Imageadjust_Type_Image)
 724         {
 725             data->bitmap_string = bitmap_string;
 726             data->bitmap_image = bitmap_image;
 727             data->bitmap_hook.h_Entry = HookEntry;
 728             data->bitmap_hook.h_SubEntry = (HOOKFUNC) Bitmap_Function;
 729             DoMethod(bitmap_popasl, MUIM_Notify, MUIA_Popasl_Active, FALSE,
 730                 (IPTR) obj, 3, MUIM_CallHook, (IPTR) & data->bitmap_hook,
 731                 (IPTR) data);
 732             DoMethod(bitmap_string, MUIM_Notify, MUIA_String_Acknowledge,
 733                 MUIV_EveryTime, (IPTR) obj, 3, MUIM_CallHook,
 734                 (IPTR) & data->bitmap_hook, (IPTR) data);
 735         }
 736     }
 737
 738     if (gradient_imagedisplay)
 739     {
 740         data->gradient_imagedisplay = gradient_imagedisplay;
 741         data->gradient_start_poppen = gradient_start_poppen;
 742         data->gradient_end_poppen = gradient_end_poppen;
 743         data->gradient_angle_slider = gradient_angle_slider;
 744         data->gradient_type_cycle = gradient_type_cycle;
 745         data->gradient_vert_button = gradient_vert_button;
 746         data->gradient_horiz_button = gradient_horiz_button;
 747         data->gradient_swap_button = gradient_swap_button;
 748
 749         DoMethod(gradient_vert_button, MUIM_Notify, MUIA_Pressed, FALSE,
 750             (IPTR) gradient_angle_slider, 3, MUIM_Set, MUIA_Numeric_Value,
 751             90);
 752         DoMethod(gradient_horiz_button, MUIM_Notify, MUIA_Pressed, FALSE,
 753             (IPTR) gradient_angle_slider, 3, MUIM_Set, MUIA_Numeric_Value,
 754             0);
 755
 756         data->gradient_swap_hook.h_Entry = HookEntry;
 757         data->gradient_swap_hook.h_SubEntry =
 758             (HOOKFUNC) GradientSwap_Function;
 759         DoMethod(gradient_swap_button, MUIM_Notify, MUIA_Pressed, FALSE,
 760             (IPTR) obj, 3, MUIM_CallHook, (IPTR) & data->gradient_swap_hook,
 761             (IPTR) data);
 762
 763         data->gradient_hook.h_Entry = HookEntry;
 764         data->gradient_hook.h_SubEntry = (HOOKFUNC) Gradient_Function;
 765         DoMethod(gradient_start_poppen, MUIM_Notify, MUIA_Pendisplay_Spec,
 766             MUIV_EveryTime, (IPTR) obj, 3, MUIM_CallHook,
 767             (IPTR) & data->gradient_hook, (IPTR) data);
 768         DoMethod(gradient_end_poppen, MUIM_Notify, MUIA_Pendisplay_Spec,
 769             MUIV_EveryTime, (IPTR) obj, 3, MUIM_CallHook,
 770             (IPTR) & data->gradient_hook, (IPTR) data);
 771         DoMethod(gradient_angle_slider, MUIM_Notify, MUIA_Numeric_Value,
 772             MUIV_EveryTime, (IPTR) obj, 3, MUIM_CallHook,
 773             (IPTR) & data->gradient_hook, (IPTR) data);
 774         DoMethod(gradient_type_cycle, MUIM_Notify, MUIA_Cycle_Active,
 775             MUIV_EveryTime, (IPTR) obj, 3, MUIM_CallHook,
 776             (IPTR) & data->gradient_hook, (IPTR) data);
 777
 778         /* Set the gradient image to correct values */
 779         Gradient_Function(NULL, obj, &data);
 780     }
 781
 782     /* parse initial taglist */
 783     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 784     {
 785         switch (tag->ti_Tag)
 786         {
 787         case MUIA_Imageadjust_Spec:
 788             spec = (char *)tag->ti_Data;
 789             break;
 790         }
 791     }
 792
 793     if (adjust_type != MUIV_Imageadjust_Type_Background &&
 794         adjust_type != MUIV_Imageadjust_Type_Pen)
 795     {
 796         data->external_list = external_list;
 797         data->external_display_hook.h_Entry = HookEntry;
 798         data->external_display_hook.h_SubEntry =
 799             (HOOKFUNC) Imageadjust_External_Display;
 800         set(data->external_list, MUIA_List_DisplayHook,
 801             (IPTR) & data->external_display_hook);
 802
 803         data->external_construct_hook.h_Entry = HookEntry;
 804         data->external_construct_hook.h_SubEntry =
 805             (HOOKFUNC) Imageadjust_External_Construct;
 806         set(data->external_list, MUIA_List_ConstructHook,
 807             (IPTR) & data->external_construct_hook);
 808
 809         data->external_destruct_hook.h_Entry = HookEntry;
 810         data->external_destruct_hook.h_SubEntry =
 811             (HOOKFUNC) Imageadjust_External_Destruct;
 812         set(data->external_list, MUIA_List_DestructHook,
 813             (IPTR) & data->external_destruct_hook);
 814
 815         /* Because we have many children, we disable the forwarding of the
 816          * notify method */
 817         DoMethod(obj, MUIM_Group_DoMethodNoForward, MUIM_Notify,
 818             MUIA_Group_ActivePage, 3, (IPTR) obj, 1,
 819             MUIM_Imageadjust_ReadExternal);
 820
 821         if (data->originator)
 822             DoMethod(data->external_list, MUIM_Notify,
 823                 MUIA_Listview_DoubleClick, TRUE,
 824                 MUIV_Notify_Application, 5, MUIM_Application_PushMethod,
 825                 (IPTR) data->originator, 2, MUIM_Popimage_CloseWindow,
 826                 TRUE);
 827     }
 828     Imageadjust_SetImagespec(obj, data, spec);
 829     return (IPTR) obj;
 830 }
 831
 832 IPTR Imageadjust__OM_DISPOSE(struct IClass *cl, Object *obj, Msg msg)
 833 {
 834     struct Imageadjust_DATA *data = INST_DATA(cl, obj);
 835
 836     if (data->imagespec)
 837         FreeVec(data->imagespec);
 838
 839     DoSuperMethodA(cl, obj, msg);
 840     return 0;
 841 }
 842
 843 IPTR Imageadjust__OM_SET(struct IClass *cl, Object *obj,
 844     struct opSet *msg)
 845 {
 846     struct TagItem *tags;
 847     struct TagItem *tag;
 848     struct Imageadjust_DATA *data = INST_DATA(cl, obj);
 849
 850     for (tags = msg->ops_AttrList; (tag = NextTagItem(&tags));)
 851     {
 852         switch (tag->ti_Tag)
 853         {
 854         case MUIA_Imageadjust_Spec:
 855             Imageadjust_SetImagespec(obj, data, (char *)tag->ti_Data);
 856             break;
 857         }
 858     }
 859
 860     return DoSuperMethodA(cl, obj, (Msg) msg);
 861 }
 862
 863 IPTR Imageadjust__OM_GET(struct IClass *cl, Object *obj,
 864     struct opGet *msg)
 865 {
 866     struct Imageadjust_DATA *data = INST_DATA(cl, obj);
 867     struct pages
 868     {
 869         LONG type;
 870         LONG pos[6];
 871     };
 872
 873     const static struct pages pages_per_type[] =
 874     {
 875         {MUIV_Imageadjust_Type_Pen, {2, -1, -1, -1, -1, -1}},
 876         {MUIV_Imageadjust_Type_Background, {0, 2, 4, 5, -1, -1}},
 877         {MUIV_Imageadjust_Type_Image, {0, 1, 2, 3, -1, -1}},
 878         {MUIV_Imageadjust_Type_All, {0, 1, 2, 3, 4, 5}},
 879     };
 880
 881     switch (msg->opg_AttrID)
 882     {
 883     case MUIA_Imageadjust_Spec:
 884         {
 885             int i;
 886
 887             LONG act = 0;
 888             if (data->imagespec)
 889             {
 890                 FreeVec(data->imagespec);
 891                 data->imagespec = NULL;
 892             }
 893
 894             get(obj, MUIA_Group_ActivePage, &act);
 895
 896             for (i = 0; i < 4; i++)
 897             {
 898                 if (pages_per_type[i].type == data->adjust_type)
 899                     break;
 900             }
 901
 902             act = pages_per_type[i].pos[act];
 903
 904             switch (act)
 905             {
 906             case 0:            /* Pattern */
 907                 if ((data->imagespec = AllocVec(40, 0)))
 908                 {
 909                     if (data->last_pattern_selected != -1)
 910                         snprintf(data->imagespec, 40, "0:%d",
 911                             (int)data->last_pattern_selected + 128);
 912                     else
 913                         strcpy(data->imagespec, "0:128");
 914                 }
 915                 break;
 916
 917             case 1:
 918                 if ((data->imagespec = AllocVec(20, 0)))
 919                 {
 920                     if (data->last_vector_selected != -1)
 921                         snprintf(data->imagespec, 20, "1:%d",
 922                             (int)data->last_vector_selected);
 923                     else
 924                         strcpy(data->imagespec, "0:128");
 925                 }
 926                 break;
 927
 928             case 2:
 929                 {
 930                     struct MUI_PenSpec *penspec = NULL;
 931
 932                     get(data->color_group, MUIA_Penadjust_Spec, &penspec);
 933                     if (penspec)
 934                     {
 935                         LONG len;
 936                         D(bug("imageadjust: penspec = %s\n", penspec));
 937                         len = strlen((STRPTR) penspec) + 3;
 938                         if ((data->imagespec = AllocVec(len, 0)))
 939                             snprintf(data->imagespec, len, "2:%s",
 940                                 penspec->ps_buf);
 941                     }
 942                 }
 943                 break;
 944
 945             case 3:            /* External */
 946                 {
 947                     struct ExternalListEntry *entry;
 948
 949                     DoMethod(data->external_list, MUIM_List_GetEntry,
 950                         MUIV_List_GetEntry_Active, (IPTR) & entry);
 951                     if (entry != NULL && entry->filename != NULL
 952                         && entry->reldir != NULL)
 953                     {
 954                         LONG len;
 955                         len =
 956                             2 + strlen(entry->reldir) + 1 +
 957                             strlen(entry->filename) + 1;
 958                         if ((data->imagespec = AllocVec(len, 0)))
 959                         {
 960                             snprintf(data->imagespec, len, "3:%s/%s",
 961                                 entry->reldir, entry->filename);
 962                             D(bug("Imageadjust_OM_GET: imspec=%s\n",
 963                                     data->imagespec));
 964                         }
 965                     }
 966                 }
 967                 break;
 968
 969             case 4:            /* Bitmap */
 970                 {
 971                     char *str = NULL;
 972                     get(data->bitmap_string, MUIA_String_Contents, &str);
 973                     if (str)
 974                     {
 975                         LONG len;
 976                         len = strlen(str) + 10;
 977                         if ((data->imagespec = AllocVec(len, 0)))
 978                             snprintf(data->imagespec, len, "5:%s", str);
 979                     }
 980                 }
 981                 break;
 982
 983             case 5:            /* Gradient */
 984                 data->imagespec = StrDup(data->gradient_imagespec);
 985                 break;
 986             }
 987             if (data->imagespec)
 988                 *msg->opg_Storage = (IPTR) data->imagespec;
 989             else
 990                 *msg->opg_Storage = (IPTR) "0:128";
 991         }
 992         return TRUE;
 993     }
 994
 995     return (DoSuperMethodA(cl, obj, (Msg) msg));
 996 }
 997
 998 IPTR Imageadjust__MUIM_Imageadjust_ReadExternal(struct IClass *cl,
 999     Object *obj, Msg msg)
1000 {
1001     struct Imageadjust_DATA *data = INST_DATA(cl, obj);
1002
1003     DoMethod(data->external_list, MUIM_List_Clear);
1004     set(data->external_list, MUIA_List_Quiet, TRUE);
1005     AddDirectory(data->external_list, IMSPEC_EXTERNAL_PREFIX, -1);
1006     set(data->external_list, MUIA_List_Quiet, FALSE);
1007     return 0;
1008 }
1009
1010 #if 0
1011 IPTR Imageadjust__MUIM_Imageadjust_ExternalSelected(struct IClass *cl,
1012     Object *obj, Msg msg)
1013 {
1014     struct Imageadjust_DATA *data = INST_DATA(cl, obj);
1015
1016     if (data->originator)
1017         DoMethod(_app(obj), MUIM_Application_PushMethod, data->originator,
1018             2, MUIM_Popimage_CloseWindow, TRUE);
1019     return 0;
1020 }
1021 #endif
1022
1023 #if ZUNE_BUILTIN_IMAGEADJUST
1024 BOOPSI_DISPATCHER(IPTR, Imageadjust_Dispatcher, cl, obj, msg)
1025 {
1026     switch (msg->MethodID)
1027     {
1028     case OM_NEW:
1029         return Imageadjust__OM_NEW(cl, obj, (struct opSet *)msg);
1030
1031     case OM_DISPOSE:
1032         return Imageadjust__OM_DISPOSE(cl, obj, (APTR) msg);
1033
1034     case OM_SET:
1035         return Imageadjust__OM_SET(cl, obj, (struct opSet *)msg);
1036
1037     case OM_GET:
1038         return Imageadjust__OM_GET(cl, obj, (APTR) msg);
1039
1040     case MUIM_Imageadjust_ReadExternal:
1041         return Imageadjust__MUIM_Imageadjust_ReadExternal(cl, obj,
1042             (APTR) msg);
1043
1044     //case MUIM_Imageadjust_ExternalSelected:
1045     //    return Imageadjust__MUIM_Imageadjust_ExternalSelected(cl, obj,
1046     //        (APTR)msg);
1047
1048     default:
1049         return DoSuperMethodA(cl, obj, msg);
1050     }
1051 }
1052 BOOPSI_DISPATCHER_END
1053
1054 const struct __MUIBuiltinClass _MUI_Imageadjust_desc =
1055 {
1056     MUIC_Imageadjust,
1057     MUIC_Register,
1058     sizeof(struct Imageadjust_DATA),
1059     (void *)Imageadjust_Dispatcher
1060 };
1061 #endif /* ZUNE_BUILTIN_IMAGEADJUST */