;/*
   Avail Flush >NIL:
   MakeClass Bar VER 1 REV 00 ;ASM
   Quit
*/

///Header
#include <libraries/feelin.h>

#include <clib/utility_protos.h>
#include <clib/exec_protos.h>
#include <clib/dos_protos.h>
#include <clib/graphics_protos.h>
#include <clib/feelin_protos.h>

#include <pragmas/exec_pragmas.h>
#include <pragmas/dos_pragmas.h>
#include <pragmas/graphics_pragmas.h>
#include <pragmas/utility_pragmas.h>

UBYTE FCC_Name[] = FC_Bar;
UBYTE FCC_ID[]   = "$VER: FC_Bar 1.00 (11-06-00) by Olivier Laviale (lotan9@aol.com)";

struct Library       *DOSBase,*GfxBase,*UtilityBase;
struct FeelinBase    *FeelinBase;

struct LocalObjectData
{
   STRPTR                         pcTitle;
   STRPTR                         pcPreParse;
//   struct FeelinTextDisplay         TD;
   APTR                             TD;
   UWORD                           nFlags;
   UWORD                           nReserved;
// FP_Xxx
   ULONG                           nPref_PreParse;
};

#define FF_Bar_Vertical (1L << 00)
//+

/*** Methods ***************************************************************/

///Bar.New
ULONG SAVEDS bar_New(struct FeelinClass *Class,APTR Obj,struct LocalObjectData *LOD,struct TagItem *Tags)
{
   struct TagItem *item;

   LOD -> nPref_PreParse = FP_Bar_PreParse;

   if (F_SuperDoA(Class,Obj,FM_New,(ULONG *)Tags))
   {
      while (item = NextTagItem(&Tags))
      {
         switch (item -> ti_Tag)
         {
            case FA_Bar_Title:      LOD -> pcTitle    = (STRPTR)item -> ti_Data; break;
            case FA_Bar_PreParse:   LOD -> pcPreParse = (STRPTR)item -> ti_Data; break;
         }
      }

      if (LOD -> pcTitle)
      {
         if (LOD -> TD = F_NewObjA(FC_TextDisplay,NULL))
         {
            F_Set(LOD -> TD,FA_TextDisplay_Contents,(ULONG)LOD -> pcTitle);
         }
         else
         {
            return NULL;
         }
      }
      return (ULONG)Obj;
   }

   return NULL;
}
//+
///Bar.Dispose
ULONG SAVEDS bar_Dispose(struct FeelinClass *Class,APTR Obj,struct LocalObjectData *LOD)
{
   LOD -> TD = (APTR) F_DisposeObj((APTR)LOD -> TD);
   return F_SuperDoA(Class,Obj,FM_Dispose,NULL);
}
//+
///Bar.Get
ULONG SAVEDS bar_Get(struct LocalObjectData *LOD,struct TagItem *Tags)
{
   struct TagItem *item;
   ULONG  *save;

   while (item = NextTagItem(&Tags))
   {
      save = (ULONG *)item -> ti_Data;

      switch (item -> ti_Tag)
      {
         case FA_Bar_Title:      *save = (ULONG)LOD -> pcTitle;    break;
         case FA_Bar_PreParse:   *save = (ULONG)LOD -> pcPreParse; break;
      }
   }
   return NULL;
}
//+
///Bar.Setup
ULONG SAVEDS bar_Setup(struct FeelinClass *Class,APTR Obj,struct LocalObjectData *LOD,ULONG *pnArgs)
{
   ULONG data;

   if (F_SuperDoA(Class,Obj,FM_Setup,pnArgs))
   {
      if (LOD -> TD)
      {
         data = (ULONG)"`l`Ss`Sh"; // Default
         F_Do(_client(Obj),FM_Client_Resolve,(ULONG)LOD -> nPref_PreParse,(ULONG)&data);
         LOD -> pcPreParse = (STRPTR)data;

         F_Do(LOD -> TD,FM_Set,
                        FA_TextDisplay_PreParse, (ULONG)LOD -> pcPreParse,
                        FA_TextDisplay_Font,     (ULONG)_font(Obj),
                        TAG_DONE);
      }
      return TRUE;
   }
   return FALSE;
}
//+
///Bar.Cleanup
ULONG SAVEDS bar_Cleanup(struct FeelinClass *Class,APTR Obj,struct LocalObjectData *LOD,ULONG *pnArgs)
{
   F_Do(LOD -> TD,FM_Set,
                  FA_Text_PreParse,     NULL,
                  FA_TextDisplay_Font,  NULL, TAG_DONE);

   return F_SuperDoA(Class,Obj,FM_Cleanup,pnArgs);
}
//+
///Bar.AskMinMax
ULONG SAVEDS bar_AskMinMax(struct FeelinClass *Class,struct FeelinObject *Obj,struct LocalObjectData *LOD)
{
   LOD -> nFlags = F_Get(Obj -> Parent,FA_Horizontal) ? LOD -> nFlags | FF_Bar_Vertical : LOD -> nFlags - (LOD ->nFlags & FF_Bar_Vertical);

   if (LOD -> TD)
   {
      if ((LOD -> nFlags & FF_Bar_Vertical) == FALSE)
      {
         _minh(Obj) += ((struct FeelinTextDisplay *)(LOD -> TD)) -> nHeight;
      }
   }
   else
   {
      if (LOD -> nFlags & FF_Bar_Vertical)
      {
         _minw(Obj) += 2;
         _maxw(Obj)  = _minw(Obj);
      }
      else
      {
         _minh(Obj) += 2;
         _maxh(Obj)  = _minh(Obj);
      }
   }
   return F_SuperDoA(Class,Obj,FM_AskMinMax,NULL);
}
//+
///Bar.Draw
ULONG SAVEDS bar_Draw(struct FeelinClass *Class,APTR Obj,struct LocalObjectData *LOD,ULONG *pnArgs)
{
   struct RastPort           *rp;
   struct FeelinTextDisplay  *td;
   struct FeelinRect          rect;
   ULONG  dark,shine;
   UWORD  x1,y1,x2,y2,w,h, bw;
   
   rp = _rp(Obj);
   x1 = _x(Obj); w = _w(Obj); x2 = x1 + w - 1; dark  = _pen(Obj,FV_Pen_Dark);
   y1 = _y(Obj); h = _h(Obj); y2 = y1 + h - 1; shine = _pen(Obj,FV_Pen_Shine);

   F_SuperDoA(Class,Obj,FM_Draw,pnArgs);

   if (LOD -> nFlags & FF_Bar_Vertical)
   {
      if (w > 2) x1 = w / 2 + x1 - 1;

      _APen(dark);  _Move(x1,y1);   _Draw(x1,y2);
      _APen(shine); _Move(x1+1,y1); _Draw(x1+1,y2);
   }
   else
   {
      if (td = LOD -> TD)
      {
         rect.x1 = x1+10+1; rect.y1 = y1;
         rect.x2 = x2-10-1; rect.y2 = y2;

         if (F_Do(td,FM_TextDisplay_Size,&rect) == 0) goto __done;

         bw = (w - 10 - td -> nWidth) / 2;
         y1 = (h / 2) + y1;

         _APen(shine); _Move(x1,y1);   _Draw(x1+bw-1,y1);   _Move(x2-bw+1,y1);   _Draw(x2,y1);
         _APen(dark);  _Move(x1,y1-1); _Draw(x1+bw-1,y1-1); _Move(x2-bw+1,y1-1); _Draw(x2,y1-1);

         rect.x1 = x1+bw+5; rect.x2 = x2-bw-5;

         F_Do(td,FM_TextDisplay_Draw,&rect,_render(Obj));
      }
      else
      {
__done:
         if (h > 2) y1 = h / 2 + y1 - 1;

         _APen(dark);  _Move(x1,y1);   _Draw(x2,y1);
         _APen(shine); _Move(x1,y1+1); _Draw(x2,y1+1);
      }
   }
   return NULL;
}
//+

/*** Class *****************************************************************/

///FCC_Dispatcher
ULONG SAVEDS ASM FCC_Dispatcher(REG_A2 struct FeelinClass *Class,REG_A0 APTR Obj,REG_D0 ULONG Method,REG_A1 ULONG *Args)
{
   struct LocalObjectData *LOD = INST_DATA(Class,Obj);

   switch (Method)
   {
      case FM_New:         return bar_New        (Class,Obj,LOD,(struct TagItem *)Args);
      case FM_Dispose:     return bar_Dispose    (Class,Obj,LOD);
      case FM_Get:                F_SuperDoA     (Class,Obj,Method,Args);
                           return bar_Get        (LOD,(struct TagItem *)Args);

      case FM_Setup:       return bar_Setup      (Class,Obj,LOD,Args);
      case FM_Cleanup:     return bar_Cleanup    (Class,Obj,LOD,Args);
      case FM_AskMinMax:   return bar_AskMinMax  (Class,Obj,LOD);
      case FM_Draw:        return bar_Draw       (Class,Obj,LOD,Args);

      default:             return F_SuperDoA     (Class,Obj,Method,Args);
   }
}
//+
///FCC_Info
ULONG * SAVEDS ASM FCC_Info(REG_A0 struct FeelinBase *Feelin)
{
   static ULONG Tags[] =
   {
      FA_SuperID,    (ULONG)FC_Area,
      FA_DataSize,   sizeof(struct LocalObjectData),
      FA_Dispatcher, (ULONG)FCC_Dispatcher,
      TAG_DONE
   };

   FeelinBase  = Feelin;
   DOSBase     = Feelin -> Dos;
   GfxBase     = Feelin -> Graphics;
   UtilityBase = Feelin -> Utility;

   return Tags;
}
//+