/************************************************************************
*
* ChangeManaged
* Process a changed in managed state of the child. If its
* size is out of sync with the frame, make a resize request
* to change the size of the frame.
* Note: called before ConstraintDestroy.
*
************************************************************************/
static void
ChangeManaged(
Widget wid )
{
XmFrameWidget fw = (XmFrameWidget) wid ;
Widget title_area = (fw->frame.title_area &&
XtIsManaged(fw->frame.title_area)) ?
fw->frame.title_area : (Widget) NULL;
Dimension t_w = 0;
Dimension t_h = 0;
Dimension t_bw = (title_area) ? title_area->core.border_width : 0;
Widget work_area = (fw->frame.work_area &&
XtIsManaged(fw->frame.work_area)) ?
fw->frame.work_area : (Widget) NULL;
Dimension w_w = (work_area) ? work_area->core.width : 0;
Dimension w_h = (work_area) ? work_area->core.height : 0;
Dimension w_bw = (work_area) ? work_area->core.border_width : 0;
Dimension fwWidth, fwHeight;
if (title_area)
{
/* We don't want the current size of the title object -- width/height
** may have been set on it. Because we'll be forcing it to the size we
** want (see ConfigureChildren), we must use the "natural" size here,
** so query its value now. (Use current border_width.)
*/
XtWidgetGeometry title_reply;
XtQueryGeometry (title_area, NULL, &title_reply);
t_w = (title_reply.request_mode & CWWidth) ?
title_reply.width : title_area->core.width;
t_h = (title_reply.request_mode & CWHeight) ?
title_reply.height : title_area->core.height;
}
/* need to check on initial sizing (not null) */
if (XtIsRealized((Widget)fw) || (XtWidth(fw) == 0) || (XtHeight(fw) == 0)) {
CalcFrameSize (fw, t_w, t_h, t_bw, w_w, w_h, w_bw,
&fwWidth, &fwHeight);
while (XtMakeResizeRequest ((Widget) fw,
fwWidth, fwHeight,
&fwWidth, &fwHeight) == XtGeometryAlmost)
/*EMPTY*/;
ClearShadow(fw);
}
ConfigureChildren(fw, NULL, NULL);
DrawShadow(fw);
XmeNavigChangeManaged((Widget) fw);
}
/*ARGSUSED*/
static Boolean
SetValues(
Widget cw,
Widget rw, /* unused */
Widget nw,
ArgList args, /* unused */
Cardinal *num_args ) /* unused */
{
XmFrameWidget current = (XmFrameWidget) cw ;
XmFrameWidget new_w = (XmFrameWidget) nw ;
Boolean redisplay = False;
Widget title_area = (new_w->frame.title_area &&
XtIsManaged(new_w->frame.title_area)) ?
new_w->frame.title_area : NULL;
Dimension t_w = (title_area) ? title_area->core.width : 0;
Dimension t_h = (title_area) ? title_area->core.height : 0;
Dimension t_bw = (title_area) ? title_area->core.border_width : 0;
Widget work_area = (new_w->frame.work_area &&
XtIsManaged(new_w->frame.work_area)) ?
new_w->frame.work_area : (Widget) NULL;
Dimension w_w = (work_area) ? work_area->core.width : 0;
Dimension w_h = (work_area) ? work_area->core.height : 0;
Dimension w_bw = (work_area) ? work_area->core.border_width : 0;
if (!XmRepTypeValidValue( XmRID_SHADOW_TYPE, new_w->frame.shadow_type,
(Widget) new_w))
{
new_w->frame.shadow_type = current->frame.shadow_type;
}
if (!XtIsRealized((Widget)new_w)) return False ;
if (new_w->frame.margin_width != current->frame.margin_width ||
new_w->frame.margin_height != current->frame.margin_height ||
new_w->manager.shadow_thickness != current->manager.shadow_thickness)
{
CalcFrameSize (new_w, t_w, t_h, t_bw, w_w, w_h, w_bw,
&new_w->core.width, &new_w->core.height);
}
if (new_w -> frame.shadow_type != current -> frame.shadow_type ||
new_w->frame.margin_width != current->frame.margin_width ||
new_w->frame.margin_height != current->frame.margin_height ||
new_w->manager.shadow_thickness != current->manager.shadow_thickness)
{
redisplay = True;
}
return (redisplay);
}
/** Increase size of buffer by delta elements, keeping contents intact. */
size_t BufferedFrame::ResizeBuffer(int delta) {
if (delta == 0) return frameSize_;
if (delta < 0) {
mprinterr("Internal Error: ResizeBuffer: Negative value given.\n");
return frameSize_;
}
size_t newsize = frameSize_ + CalcFrameSize( delta );
char* newbuffer = new char[ newsize ];
memcpy(newbuffer, buffer_, frameSize_);
memset(newbuffer+frameSize_, 0, newsize - frameSize_);
delete[] buffer_;
buffer_ = newbuffer;
bufferPosition_ = buffer_;
frameSize_ = newsize;
return frameSize_;
}
/** Increase size of buffer by delta elements, keeping contents intact. */
size_t BufferedFrame::ResizeBuffer(int delta) {
if (delta == 0) return frameSize_;
if (delta < 0) {
mprinterr("Internal Error: ResizeBuffer: Negative value given.\n");
return frameSize_;
}
size_t newsize = frameSize_ + CalcFrameSize( delta );
char* newbuffer = new char[ newsize + 1]; // +1 for null
std::copy(buffer_, buffer_+frameSize_, newbuffer);
std::fill(newbuffer+frameSize_, newbuffer+newsize, 0);
delete[] buffer_;
buffer_ = newbuffer;
bufferPosition_ = buffer_;
frameSize_ = newsize;
return frameSize_;
}
/************************************************************************
*
* QueryGeometry
* return width X height based on the children preferred sizes
*
************************************************************************/
static XtGeometryResult
QueryGeometry(
Widget widget,
XtWidgetGeometry *intended,
XtWidgetGeometry *desired )
{
Dimension work_width = 0, work_height = 0, work_bw = 0 ;
Dimension title_width = 0, title_height = 0, title_bw = 0 ;
XtWidgetGeometry child_pref ;
XmFrameWidget fw = (XmFrameWidget) widget ;
/* first determine what is the desired size, using the
preferred sizes of the title and the work_area, or the
current setting if no preference are given */
if (fw->frame.work_area) {
XtQueryGeometry (fw->frame.work_area, NULL, &child_pref);
if (IsWidth(&child_pref)) work_width = child_pref.width ;
else work_width = XtWidth(fw->frame.work_area);
if (IsHeight(&child_pref)) work_height = child_pref.height ;
else work_height = XtHeight(fw->frame.work_area);
if (IsBorder(&child_pref)) work_bw = child_pref.border_width ;
else work_bw = XtBorderWidth(fw->frame.work_area);
}
if (fw->frame.title_area) {
XtQueryGeometry (fw->frame.title_area, NULL, &child_pref);
if (IsWidth(&child_pref)) title_width = child_pref.width ;
else title_width = XtWidth(fw->frame.title_area);
if (IsHeight(&child_pref)) title_height = child_pref.height ;
else title_height = XtHeight(fw->frame.title_area);
if (IsBorder(&child_pref)) title_bw = child_pref.border_width ;
else title_bw = XtBorderWidth(fw->frame.title_area);
}
CalcFrameSize (fw,
title_width, title_height, title_bw,
work_width, work_height, work_bw,
&desired->width, &desired->height);
/* deal with user initial size setting */
if (!XtIsRealized(widget)) {
if (XtWidth(widget) != 0) desired->width = XtWidth(widget) ;
if (XtHeight(widget) != 0) desired->height = XtHeight(widget) ;
}
return XmeReplyToQueryGeometry(widget, intended, desired) ;
}
/** Prepare the buffer to receive organized chunks of text, i.e.
* organized in some regular fashion (e.g. an Amber Traj, which
* is 10 cols of 8.3 precision floating point numbers etc).
* \param Nelts Total expected number of elements to read.
* \param eltWidth Width in chars of each element.
* \param eltsPerLine Number of elements per line (columns).
* \param additionalBytes Any additional bytes in the frame.
* \param offsetIn Offset to be used in seeking.
* \return Size of set-up frame.
*/
size_t BufferedFrame::SetupFrameBuffer(int Nelts, int eltWidthIn, int eltsPerLine,
size_t additionalBytes, int offsetIn)
{
Ncols_ = eltsPerLine;
eltWidth_ = (size_t)eltWidthIn;
offset_ = (size_t) offsetIn;
frameSize_ = CalcFrameSize( Nelts ) + additionalBytes;
if (buffer_!=0) delete[] buffer_;
if (frameSize_ < 1)
buffer_ = 0;
else {
buffer_ = new char[ frameSize_ ];
memset(buffer_, 0, frameSize_);
}
bufferPosition_ = buffer_;
return frameSize_;
}
AppWindow :: AppWindow()
{
CreateWindow(FaTitleBar | FaTaskList | FaSysMenu | FaSizeBorder | FaMinMax);
SetCaption("FormWindow Demo"); // Set captions
SetSwitchTitle("FormWindow Demo Program");
SetIcon(icon = new wIcon(ResIcon, I_FORMDEMO)); // Set the app's icon
// This section create a menu bar and then adds items to the
// sub menu itself. It is also possible to construct the menu
// from the resource file if desired
menubar = new wMenu(this, 100, "~Form\\~Help\\");
menubar->SetSubMenuItems(SM_HELP, MI_HELP, "~Help for help...;~General help...;~Keys help...;Help ~index;");
// connect to HelpManager object
AssociateHelp();
help = ThisThread->HelpInstance();
np = new FormNoteBook(this, IdNotebook, wPointl(2, 0, DlgUnits),
wDimension(296, 150, DlgUnits), WsVisible | BkSpiralBinding);
np->SetMajorTabDimension(wDimension(42, 12, DlgUnits));
np->SetMinorTabDimension(wDimension(40, 12, DlgUnits));
wNoteBookPageList *pages = np->Pages();
data = new FormData;
forms[0] = new StringForm(pages, data);
forms[1] = new CharForm(pages, data);
forms[2] = new MLEStringForm(pages, data);
forms[3] = new DateForm(pages, data);
forms[4] = new TimeForm(pages, data);
forms[5] = new ShortForm(pages, data);
forms[6] = new LongForm(pages, data);
forms[7] = new FloatForm(pages, data);
forms[8] = new MoneyForm(pages, data);
forms[9] = new ButtonForm(pages, data);
forms[10] = new ListForm(pages, data);
ChangeFrameSize( CalcFrameSize(wDimension(310, 160, DlgUnits)) );
ChangePosition(PosCenter);
np->GotoPage((*pages)[1]);
Show();
ToTop();
}
/** Prepare the buffer to receive organized chunks of text, i.e.
* organized in some regular fashion (e.g. an Amber Traj, which
* is 10 cols of 8.3 precision floating point numbers etc).
* \param Nelts Total expected number of elements to read.
* \param eltWidth Width in chars of each element.
* \param eltsPerLine Number of elements per line (columns).
* \param additionalBytes Any additional bytes in a frame.
* \param offsetIn Offset (not part of frame) to be used in seeking.
* \return Size of set-up frame.
*/
size_t BufferedFrame::SetupFrameBuffer(int Nelts, int eltWidthIn, int eltsPerLine,
size_t additionalBytes, int offsetIn)
{
Ncols_ = eltsPerLine;
eltWidth_ = (size_t)eltWidthIn;
offset_ = (size_t) offsetIn;
frameSize_ = CalcFrameSize( Nelts ) + additionalBytes;
if (buffer_!=0) delete[] buffer_;
if (frameSize_ < 1)
buffer_ = 0;
else {
buffer_ = new char[ frameSize_ + 1 ]; // +1 for null, TODO not necessary for read?
std::fill(buffer_, buffer_ + frameSize_, 0);
}
bufferPosition_ = buffer_;
//rprintf("DEBUG: %s %i cols, eltWidth= %zu, offset= %zu, frameSize= %zu additional= %zu\n",
// Filename().base(), Ncols_, eltWidth_, offset_, frameSize_, additionalBytes);
return frameSize_;
}
/*-------------------------------------------------------------*/
BOOL MPEGHeader::ReadHeader(BYTE *pData, int nSize, int* pnOffset)
{
unsigned int i=0;
BOOL bValidHeader=FALSE;
while (i<(nSize-sizeof(m_RawMPEGHeader)))
{
// Copy header bytes
memcpy(&m_RawMPEGHeader,&pData[i],sizeof(m_RawMPEGHeader));
// Check Header
if (m_RawMPEGHeader.FrameSyncH==0xFF && m_RawMPEGHeader.FrameSyncL==0x0F)
{
// we found it
bValidHeader=TRUE;
break;
}
i++;
}
// check if we have found a valid header
if (bValidHeader==FALSE)
{
ASSERT(FALSE);
return FALSE;
}
pData+=i;
// set the offset if possible
if (pnOffset)
{
*pnOffset=i;
}
// get Xing header data
m_nFlags = 0; // clear to null incase fail
// Set SampleRate
m_nSampleRate= MPEGSamplerates[1-m_RawMPEGHeader.Version][m_RawMPEGHeader.SampleRateIndex];
// Set BitRate
m_nBitRate= MPEGBitrates[1-m_RawMPEGHeader.Version][3-m_RawMPEGHeader.Layer][m_RawMPEGHeader.BitRateIndex];
// Set Frame Size
CalcFrameSize();
// Determine offset of header
if( m_RawMPEGHeader.Version==MPEG_I )
{
// MPEG-I
if( m_RawMPEGHeader.ChannelMode != 3 )
{
// MONO
pData+=(32+4);
}
else
{
// STEREO, DUAL-CHANNEL or JOINT-STEREO
pData+=(17+4);
}
}
else
{
// MPEG-II
if( m_RawMPEGHeader.ChannelMode != 3 )
{
// MONO
pData+=(17+4);
}
else
{
// STEREO, DUAL-CHANNEL or JOINT-STEREO
pData+=(9+4);
}
}
// Check for Xing Tag
if( pData[0] != 'X' ) return TRUE;
if( pData[1] != 'i' ) return TRUE;
if( pData[2] != 'n' ) return TRUE;
if( pData[3] != 'g' ) return TRUE;
pData+=4;
m_nFlags= ExtractI4(pData);
pData+=4;
if( m_nFlags & FRAMES_FLAG )
{
m_nFrames= ExtractI4(pData); pData+=4;
}
if( m_nFlags & BYTES_FLAG )
{
m_nBytes= ExtractI4(pData); pData+=4;
}
if( m_nFlags & TOC_FLAG )
{
// Get the first 100 bytes
for(i=0;i<100;i++)
m_btToc[i] = pData[i];
// Increase buffer
pData+=100;
}
if( m_nFlags & VBR_SCALE_FLAG )
{
m_nVbrScale = ExtractI4(pData); pData+=4;
}
#ifdef DEBUG_SHOW_TOC
for(i=0;i<100;i++)
{
if( (i%10) == 0 ) printf("\n");
{
LTRACE( _T( " %3d" ), m_btToc[ i ] );
}
}
#endif
// This is a valid Xing Header
m_bIsXingHeader=TRUE;
return TRUE;
}
/************************************************************************
*
* Geometry Manager
* Take the requested geometry, calculate the needed size for
* the frame and make a request to the frames parent.
* Requests to change x, y position are always denied.
*
************************************************************************/
static XtGeometryResult
GeometryManager(
Widget w,
XtWidgetGeometry *request,
XtWidgetGeometry *reply )
{
XmFrameWidget fw = (XmFrameWidget) XtParent(w);
Widget title_area = fw->frame.title_area;
Widget work_area = fw->frame.work_area;
Dimension req_width, req_height, req_bw;
Boolean query_only = False;
Boolean almost = False;
Dimension title_width = (title_area)?title_area->core.width:0;
Dimension title_height = (title_area)?title_area->core.height:0;
Dimension title_bw = (title_area)?title_area->core.border_width:0;
Dimension work_width = (work_area)?work_area->core.width:0;
Dimension work_height = (work_area)?work_area->core.height:0;
Dimension work_bw = (work_area)?work_area->core.border_width:0;
Dimension frame_width, frame_height;
XtWidgetGeometry parent_request;
XtWidgetGeometry parent_reply;
Dimension almost_width;
Dimension almost_height;
if (fw->frame.processing_constraints)
{
fw->frame.processing_constraints = False;
request -> border_width -= 1;
}
/* Set up the calculation variables according to the */
/* contents of the requested geometry. */
if (request -> request_mode & XtCWQueryOnly)
query_only = True;
if ((request -> request_mode & CWX) || (request -> request_mode & CWY))
almost = True;
if (request -> request_mode & CWWidth) req_width = request -> width;
else req_width = w -> core.width;
if (request -> request_mode & CWHeight) req_height = request -> height;
else req_height = w -> core.height;
if (request -> request_mode & CWBorderWidth)
req_bw = request -> border_width;
else req_bw = w -> core.border_width;
if (w == title_area)
{
title_width = req_width;
title_height = req_height;
title_bw = req_bw;
}
if (w == work_area)
{
work_width = req_width;
work_height = req_height;
work_bw = req_bw;
}
/* find the frame size based on the children preferred geometry */
CalcFrameSize (fw, title_width, title_height, title_bw,
work_width, work_height, work_bw,
&frame_width, &frame_height);
parent_request.request_mode = CWWidth | CWHeight;
if (almost || query_only) parent_request.request_mode |= XtCWQueryOnly;
parent_request.width = frame_width;
parent_request.height = frame_height;
switch (XtMakeGeometryRequest ((Widget)fw,
&parent_request, &parent_reply)) {
case XtGeometryYes:
if (!almost) {
if (!query_only) {
ClearShadow(fw);
ConfigureChildren(fw, w, request);
DrawShadow(fw);
}
return (XtGeometryYes);
} else {
almost_width = request->width;
almost_height = request->height;
}
break;
case XtGeometryNo:
if (w == title_area) {
/* we got a No, try to honor the title request anyway,
by resizing the work_area child */
if (!almost) {
if (!query_only) {
ClearShadow(fw);
ConfigureChildren(fw, w, request);
DrawShadow(fw);
}
return (XtGeometryYes);
} else {
almost_width = request->width;
almost_height = request->height;
}
} else return (XtGeometryNo);
break;
case XtGeometryAlmost:
if (w == title_area) {
/* we got an Almost, try to honor the title request anyway,
by accepting the deal and resizing the work_area child */
if (!almost) {
if (!query_only) {
ClearShadow(fw);
XtMakeResizeRequest((Widget)fw, parent_reply.width,
parent_reply.height, NULL, NULL);
ConfigureChildren(fw, w, request);
}
return (XtGeometryYes);
} else {
almost_width = request->width;
almost_height = request->height;
}
} else {
/* we got an Almost, accept the deal and
compute the work_area size */
CalcWorkAreaSize (fw, &almost_width, &almost_height,
req_bw, parent_reply.width,
parent_reply.height);
}
break;
default:
return (XtGeometryNo);
break;
}
/* Fallen through to an almost condition. Clear the x and y */
/* and set the width, height, and border. */
if (reply != NULL) {
reply -> request_mode = request -> request_mode & ~(CWX | CWY);
reply -> width = almost_width;
reply -> height = almost_height;
reply -> border_width = req_bw;
if (request -> request_mode & CWSibling)
reply -> sibling = request -> sibling;
if (request -> request_mode & CWStackMode)
reply -> stack_mode = request -> stack_mode;
return (XtGeometryAlmost);
}
return (XtGeometryNo);
}
