/**************************************************************************
Layout Tab Items
**************************************************************************/
static void LayoutTabItems(Object *obj, struct Register_DATA *data)
{
WORD extra_space;
WORD fitwidth;
WORD x = 0;
WORD y = - data->tab_height;
WORD item_width; /* from vertical line left to v l right */
int i;
int tabs_on_bottom = 0;
item_width = (_width(obj) - data->total_hspacing) / data->columns;//data->numitems;
extra_space = (_width(obj) - data->total_hspacing) % data->columns;//data->numitems;
D(bug("LayoutTabItems(%lx) : width = %d, mwidth = %d, max item width = %d, remainder = %d\n",
obj, _width(obj), _mwidth(obj), item_width, extra_space));
for (i = 0; i < data->numitems; i++)
{
struct RegisterTabItem *ri = &data->items[i];
if (i % data->columns == 0)
{
x = INTERTAB - 1;
if (i > data->active && !tabs_on_bottom)
{
y = _height(obj) - muiAreaData(obj)->mad_InnerBottom;
tabs_on_bottom = 1;
} else y += data->tab_height;
}
ri->x1 = x;
ri->x2 = ri->x1 + item_width - 1;
if (extra_space > 0)
{
ri->x2++;
extra_space--;
}
fitwidth = ri->x2 - ri->x1 + 1 - TEXTSPACING;
x += fitwidth + TEXTSPACING + INTERTAB;
ri->y1 = y;
ri->y2 = y + data->tab_height - 1;
}
}
/**************************************************************************
Set the coordinates
**************************************************************************/
static void SetHardCoord(Object *obj, struct Register_DATA *data)
{
struct MUI_AreaData *adata = muiAreaData(obj);
const struct MUI_FrameSpec_intern *frame;
//adata->mad_InnerLeft = REGISTER_FRAMEX;
//adata->mad_InnerTop = data->tab_height * (1 + data->active/data->columns) + REGISTER_FRAMETOP;
//adata->mad_InnerRight = REGISTER_FRAMEX;
//adata->mad_InnerBottom = data->tab_height * (data->rows - 1 - data->active/data->columns) + REGISTER_FRAMEBOTTOM;
frame = &muiGlobalInfo(obj)->mgi_Prefs->frames[MUIV_Frame_Group];
adata->mad_InnerLeft = frame->innerLeft + 1;
adata->mad_InnerTop = data->tab_height * (1 + data->active/data->columns)
+ frame->innerTop;
adata->mad_InnerRight = frame->innerRight + 1;
adata->mad_InnerBottom =
data->tab_height * (data->rows - 1 - data->active/data->columns)
+ frame->innerBottom + 1;
/* D(bug("Hardcoord %p top=%ld bottom=%ld\n", obj, adata->mad_HardITop, adata->mad_HardIBottom)); */
}
IPTR Register__MUIM_Setup(struct IClass *cl, Object *obj, struct MUIP_Setup *msg)
{
struct Register_DATA *data = INST_DATA(cl, obj);
WORD i, h = 0;
if (!DoSuperMethodA(cl, obj, (Msg)msg))
{
return FALSE;
}
_font(obj) = zune_font_get(obj, MUIV_Font_Title);
data->fonth = _font(obj)->tf_YSize;
data->fontb = _font(obj)->tf_Baseline;
h = 0;
i = data->fonth + REGISTERTAB_EXTRA_HEIGHT;
h = (i > h) ? i : h;
data->tab_height = h;
data->ty = data->fontb + 1 + (data->tab_height - data->fonth) / 2;
/* D(bug("Register_Setup : data->height=%d\n", data->tab_height)); */
for(i = 0; i < data->numitems; i++)
{
data->items[i].textlen = strlen(data->items[i].text);
}
data->total_hspacing = (data->columns + 1) * INTERTAB - 2;
/* D(bug("Register_AskMinMax : data->total_hspacing = %d\n", data->total_hspacing)); */
data->min_width = data->total_hspacing * 3;
data->def_width = data->total_hspacing;
if (!(muiGlobalInfo(obj)->mgi_Prefs->register_truncate_titles))
{
struct RastPort temprp;
int i;
WORD textpixmax;
InitRastPort(&temprp);
SetFont(&temprp, _font(obj));
textpixmax = 0;
for(i = 0; i < data->numitems; i++)
{
WORD textpix = TextLength(&temprp, data->items[i].text, data->items[i].textlen);
textpixmax = MAX(textpix, textpixmax);
}
data->def_width += (textpixmax + TEXTSPACING + 1) * data->numitems;
data->def_width = MAX(data->min_width, data->def_width);
DeinitRastPort(&temprp);
}
SetHardCoord(obj,data);
muiAreaData(obj)->mad_Flags |= (MADF_INNERLEFT | MADF_INNERTOP | MADF_INNERRIGHT | MADF_INNERBOTTOM);
DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
return TRUE;
}
/**************************************************************************
Render tab bar
**************************************************************************/
static void RenderRegisterTab(struct IClass *cl, Object *obj, ULONG flags)
{
struct Register_DATA *data = INST_DATA(cl, obj);
WORD tabx;
/*
* Erase / prepare for drawing
*/
if (flags & MADF_DRAWOBJECT)
{
DoMethod(obj, MUIM_DrawParentBackground, data->left, data->top,
data->framewidth, data->tab_height - 1, data->left, data->top, 0);
}
else
{
/* draw parent bg over oldactive */
IPTR method;
WORD old_left, old_top, old_width, old_height;
struct RegisterTabItem *ri = &data->items[data->oldactive];
if (data->oldactive >= data->columns) method = MUIM_DrawBackground;
else method = MUIM_DrawParentBackground;
old_left = _left(obj) + ri->x1 - 2;
old_top = _top(obj) + ri->y1;
old_width = ri->x2 - ri->x1 + 5;
old_height = data->tab_height - 1;
DoMethod(obj, method, old_left, old_top,
old_width, old_height, old_left, old_top, 0);
SetDrMd(_rp(obj), JAM1);
SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
RectFill(_rp(obj), old_left, old_top + old_height, old_left + old_width, old_top + old_height);
}
SetDrMd(_rp(obj), JAM1);
SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
SetFont(_rp(obj), _font(obj));
SetSoftStyle(_rp(obj), FS_NORMAL, AskSoftStyle(_rp(obj)));
/*
* Draw new graphics
*/
/* register frame */
if (flags & MADF_DRAWOBJECT || (data->active / data->columns != data->oldactive / data->columns))
{
int i,y,tabs_on_bottom = 0;
SetAPen(_rp(obj), _pens(obj)[MPEN_SHINE]);
RectFill(_rp(obj), data->left,
data->top + data->tab_height - 1,
data->left,
data->top + data->tab_height + data->frameheight - 1);
y = data->top + data->tab_height - 1;
for (i=0; i<data->rows; i++)
{
if (!tabs_on_bottom && (i > data->active/data->columns))
{
y = _bottom(obj) - muiAreaData(obj)->mad_InnerBottom + data->tab_height;
tabs_on_bottom = 1;
}
RectFill(_rp(obj), data->left + 1, y, data->left + data->framewidth - 2, y);
y += data->tab_height;
}
SetAPen(_rp(obj), _pens(obj)[MPEN_SHADOW]);
RectFill(_rp(obj), data->left + data->framewidth - 1,
data->top + data->tab_height - 1,
data->left + data->framewidth - 1,
data->top + data->tab_height + data->frameheight - 1);
RectFill(_rp(obj), data->left + 1,
data->top + data->tab_height + data->frameheight - 1,
data->left + data->framewidth - 2,
data->top + data->tab_height + data->frameheight - 1);
for(i = 0, tabx = 0; i < data->numitems; i++)
{
RenderRegisterTabItem(cl, obj, i);
}
}
else
{
/* If active register has been changed and is on same row we simply draw both registers only */
RenderRegisterTabItem(cl, obj, data->active);
RenderRegisterTabItem(cl, obj, data->oldactive);
}
}
/**************************************************************************
MUIM_HandleEvent
**************************************************************************/
IPTR Numericbutton__MUIM_HandleEvent(struct IClass *cl, Object *obj, struct MUIP_HandleEvent *msg)
{
struct Numericbutton_DATA *data = INST_DATA(cl, obj);
if (!msg->imsg)
{
return 0;
}
switch(msg->imsg->Class)
{
case IDCMP_MOUSEBUTTONS:
switch(msg->imsg->Code)
{
case SELECTDOWN:
if (_between(_left(obj), msg->imsg->MouseX, _right(obj)) &&
_between(_top(obj), msg->imsg->MouseY, _bottom(obj)) &&
(muiAreaData(obj)->mad_Flags & MADF_CANDRAW) &&
!data->popwin)
{
data->knob_clickoffset_x = msg->imsg->MouseX - _mleft(obj);
if (MakePopupWin(obj, data))
{
DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR)&data->ehn);
data->ehn.ehn_Events |= IDCMP_MOUSEMOVE;
DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR)&data->ehn);
return 0;
}
}
break;
case SELECTUP:
case MENUUP:
case MIDDLEUP:
default:
if (data->popwin)
{
KillPopupWin(obj, data);
if ((msg->imsg->Code == SELECTUP))
{
set(obj, MUIA_Numeric_Value, data->knob_val);
}
return 0;
}
break;
} /* switch(msg->imsg->Code) */
break;
case IDCMP_MOUSEMOVE:
if (data->popwin)
{
DrawKnob(obj, data, FALSE);
return 0;
}
break;
} /* switch(msg->imsg->Class) */
return 0;
}
static void DrawKnob(Object *obj, struct Numericbutton_DATA *data, BOOL force)
{
struct RastPort *rp, *saverp;
LONG x, val, pixeloffset, textlen, pixellen;
STRPTR text;
pixeloffset = data->popwin->MouseX - data->pop_innerx - 2 - data->knob_clickoffset_x;
val = DoMethod(obj, MUIM_Numeric_ScaleToValue, 0,
data->pop_innerw - data->knob_width, pixeloffset);
data->knob_left = data->pop_innerx + pixeloffset;
data->knob_top = data->pop_innery;
data->knob_val = val;
if (!force && (data->knob_left == data->knob_prev_left))
{
return;
}
data->knob_prev_left = data->knob_left;
if (data->knob_left < data->pop_innerx)
{
data->knob_left = data->pop_innerx;
}
else if (data->knob_left > data->pop_innerx + data->pop_innerw - data->knob_width)
{
data->knob_left = data->pop_innerx + data->pop_innerw - data->knob_width;
}
saverp = _rp(obj);
_rp(obj) = rp = data->popwin->RPort;
SetABPenDrMd(rp, _pens(obj)[MPEN_SHINE], 0, JAM1);
RectFill(rp, data->knob_left, data->knob_top,
data->knob_left, data->knob_top + data->knob_height - 1);
RectFill(rp, data->knob_left + 1, data->knob_top,
data->knob_left + data->knob_width - 1, data->knob_top);
SetAPen(rp, _pens(obj)[MPEN_SHADOW]);
RectFill(rp, data->knob_left + data->knob_width - 1, data->knob_top + 1,
data->knob_left + data->knob_width - 1, data->knob_top + data->knob_height - 1);
RectFill(rp, data->knob_left + 1, data->knob_top + data->knob_height - 1,
data->knob_left + data->knob_width - 2, data->knob_top + data->knob_height - 1);
if (data->knob_bg)
{
#warning "Ugly hack?"
struct IBox old_mad_Box = muiAreaData(obj)->mad_Box;
muiAreaData(obj)->mad_Box.Left = data->knob_left + 1;
muiAreaData(obj)->mad_Box.Top = data->knob_top + 1;
muiAreaData(obj)->mad_Box.Width = data->knob_width - 2;
muiAreaData(obj)->mad_Box.Height = data->knob_height - 2;
zune_imspec_draw(data->knob_bg, muiRenderInfo(obj),
data->knob_left + 1,
data->knob_top + 1,
data->knob_width - 2,
data->knob_height - 2,
0,
0,
0);
muiAreaData(obj)->mad_Box = old_mad_Box;
}
else
{
SetAPen(rp, _pens(obj)[MPEN_BACKGROUND]);
RectFill(rp, data->knob_left + 1, data->knob_top + 1,
data->knob_left + data->knob_width - 2,
data->knob_top + data->knob_height - 2);
}
SetFont(rp, _font(obj));
text = (STRPTR)DoMethod(obj, MUIM_Numeric_Stringify, val);
textlen = strlen(text);
pixellen = TextLength(_rp(obj), text, textlen);
SetAPen(rp, _pens(obj)[MPEN_TEXT]);
Move(rp, data->knob_left + 2 + (data->knob_width - 4 - pixellen) / 2,
data->knob_top + 1 + rp->TxBaseline);
Text(rp, text, textlen);
SetAPen(rp, _pens(obj)[MPEN_BACKGROUND]);
if (data->knob_left - 1 >= data->pop_innerx)
{
RectFill(rp, data->pop_innerx, data->pop_innery,
data->knob_left - 1, data->pop_innery + data->pop_innerh - 1);
}
x = data->knob_left + data->knob_width;
if (x <= data->pop_innerx + data->pop_innerw - 1)
{
RectFill(rp, x, data->pop_innery,
data->pop_innerx + data->pop_innerw - 1,
data->pop_innery + data->pop_innerh - 1);
}
_rp(obj) = saverp;
}
SEE ALSO
INTERNALS
HISTORY
*****************************************************************************/
{
AROS_LIBFUNC_INIT
if (muiRenderInfo(obj) && (_flags(obj) & MADF_SETUP) && _win(obj))
{
if (muiAreaData(obj)->mad_hiehn.ehn_Events)
{
DoMethod(_win(obj), MUIM_Window_RemEventHandler, (IPTR)&muiAreaData(obj)->mad_hiehn);
}
muiAreaData(obj)->mad_hiehn.ehn_Events &= ~flags;
if (muiAreaData(obj)->mad_hiehn.ehn_Events)
{
DoMethod(_win(obj), MUIM_Window_AddEventHandler, (IPTR)&muiAreaData(obj)->mad_hiehn);
}
}
else
{
muiAreaData(obj)->mad_hiehn.ehn_Events &= ~flags;
}
AROS_LIBFUNC_EXIT
} /* MUIA_RejectIDCMP */
IPTR Prop__MUIM_Setup(struct IClass *cl, Object *obj, struct MUIP_Setup *msg)
{
struct Prop_DATA *data = INST_DATA(cl, obj);
ULONG rc = DoSuperMethodA(cl, obj, (Msg)msg);
if (!rc) return 0;
DoMethod(_win(obj),MUIM_Window_AddEventHandler,(IPTR)&data->ehn);
data->buffer = NULL;
data->temp = NULL;
data->mapbuffer = NULL;
data->maptemp = NULL;
data->tmprp = NULL;
if (!data->usewinborder)
{
data->gadgetid = DoMethod(_win(obj),MUIM_Window_AllocGadgetID);
if (data->horiz == TRUE)
{
data->minwidth = 6;
data->minheight = 6;
data->maxwidth = MUI_MAXMAX;
data->maxheight = MUI_MAXMAX;
data->defwidth = 50;
data->defheight = 6;
}
else
{
data->minwidth = 6;
data->minheight = 6;
data->maxwidth = MUI_MAXMAX;
data->maxheight = MUI_MAXMAX;
data->defwidth = 6;
data->defheight = 50;
}
struct MUI_AreaData *adata = muiAreaData(obj);
struct MUI_ImageSpec_intern *spec = adata->mad_Background;
if (spec)
{
if (spec->type == IST_BITMAP)
{
struct dt_node *node = spec->u.bitmap.dt;
if (node)
{
if (node->mode == MODE_PROP)
{
set(obj, MUIA_Frame, MUIV_Frame_None);
if (data->horiz == TRUE)
{
data->minheight = node->img_horizontalcontainer->h >> 1;
data->defheight = data->minheight;
data->maxheight = data->minheight;
}
else
{
data->minwidth = node->img_verticalcontainer->w >> 1;
data->defwidth = data->minwidth;
data->maxwidth = data->minwidth;
}
}
}
IPTR Get(struct IClass *cl, Object *obj, struct opGet *msg)
{
struct InstData *data = (struct InstData *)INST_DATA(cl, obj);
IPTR ti_Data;
switch(msg->opg_AttrID)
{
case MUIA_Font:
ti_Data = (IPTR)(data->Font ? data->Font : muiAreaData(obj)->mad_Font);
break;
case MUIA_ControlChar:
ti_Data = (IPTR)data->CtrlChar;
break;
case MUIA_String_AttachedList:
ti_Data = (IPTR)data->ForwardObject;
break;
case MUIA_String_BufferPos:
ti_Data = (IPTR)data->BufferPos;
break;
case MUIA_String_Acknowledge:
case MUIA_String_Contents:
ti_Data = (IPTR)data->Contents;
break;
case MUIA_String_DisplayPos:
ti_Data = (IPTR)data->DisplayPos;
break;
case MUIA_String_Format:
ti_Data = (IPTR)data->Alignment;
break;
case MUIA_String_Integer:
StrToLong(data->Contents, (ULONG *)&ti_Data);
break;
case MUIA_String_MaxLen:
ti_Data = (IPTR)data->MaxLength;
break;
case MUIA_String_Reject:
ti_Data = (IPTR)data->Reject;
break;
case MUIA_String_Secret:
ti_Data = isFlagSet(data->Flags, FLG_Secret) ? TRUE : FALSE;
break;
case MUIA_String_EditHook:
ti_Data = (IPTR)data->EditHook;
break;
case MUIA_String_AdvanceOnCR:
ti_Data = isFlagSet(data->Flags, FLG_AdvanceOnCr) ? TRUE : FALSE;
break;
case MUIA_BetterString_KeyUpFocus:
ti_Data = (IPTR)data->KeyUpFocus;
break;
case MUIA_BetterString_KeyDownFocus:
ti_Data = (IPTR)data->KeyDownFocus;
break;
case MUIA_BetterString_SelectSize:
ti_Data = isFlagSet(data->Flags, FLG_BlockEnabled) ? data->BlockStop-data->BlockStart : 0;
break;
case MUIA_BetterString_StayActive:
ti_Data = isFlagSet(data->Flags, FLG_StayActive) ? TRUE : FALSE;
break;
case MUIA_BetterString_NoInput:
ti_Data = isFlagSet(data->Flags, FLG_NoInput) ? TRUE : FALSE;
break;
case MUIA_BetterString_InactiveContents:
ti_Data = (IPTR)data->InactiveContents;
break;
case MUIA_BetterString_NoShortcuts:
ti_Data = isFlagSet(data->Flags, FLG_NoShortcuts) ? TRUE : FALSE;
break;
case MUIA_BetterString_SelectOnActive:
{
if((data->SelectOnActive == TRUE && isFlagClear(data->Flags, FLG_ForceSelectOff)) ||
isFlagSet(data->Flags, FLG_ForceSelectOn))
{
ti_Data = TRUE;
}
else
ti_Data = FALSE;
}
break;
case MUIA_Version:
ti_Data = LIB_VERSION;
break;
case MUIA_Revision:
ti_Data = LIB_REVISION;
break;
default:
return DoSuperMethodA(cl, obj, (Msg)msg);
break;
}
*msg->opg_Storage = ti_Data;
return TRUE;
}
