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