void CTestList::WinKeyL(const TKeyEvent &aKey,const TTime& aTime)
{
if (aKey.iModifiers&EModifierFunc)
{
switch(aKey.iCode)
{
case EKeyLeftArrow:
AdjustSize(-Xmove,0,aKey.iModifiers);
break;
case EKeyRightArrow:
AdjustSize(Xmove,0,aKey.iModifiers);
break;
case EKeyUpArrow:
AdjustSize(0,-Ymove,aKey.iModifiers);
break;
case EKeyDownArrow:
AdjustSize(0,Ymove,aKey.iModifiers);
break;
default:
goto not_used;
}
}
else
goto not_used;
return;
not_used:
CListWindow::WinKeyL(aKey,aTime);
}
void
JXWidget::FitToEnclosure
(
const JBoolean fitHoriz,
const JBoolean fitVert
)
{
const JRect frame = GetFrame();
const JPoint oldPt = frame.topLeft();
const JRect enclBounds = (GetEnclosure())->GetBounds();
JCoordinate dx=0, dy=0, dw=0, dh=0;
if (fitHoriz)
{
dx = enclBounds.left - oldPt.x;
dw = enclBounds.width() - frame.width();
}
if (fitVert)
{
dy = enclBounds.top - oldPt.y;
dh = enclBounds.height() - frame.height();
}
Move(dx,dy);
AdjustSize(dw,dh);
}
void
JXWidget::EnclosingBoundsResized
(
const JCoordinate dwb,
const JCoordinate dhb
)
{
JCoordinate dx = 0;
JCoordinate dw = 0;
if (itsHSizing == kFixedRight)
{
dx = dwb;
}
else if (itsHSizing == kHElastic)
{
dw = dwb;
}
JCoordinate dy = 0;
JCoordinate dh = 0;
if (itsVSizing == kFixedBottom)
{
dy = dhb;
}
else if (itsVSizing == kVElastic)
{
dh = dhb;
}
Move(dx,dy);
AdjustSize(dw,dh);
}
bool CLogFile::Close()
{
AdjustSize();
try
{
CString strLine;
CStdioFile file;
int retrycounter = 10;
// try to open the file for about two seconds - some other TSVN process might be
// writing to the file and we just wait a little for this to finish
while (!file.Open(m_logfile.GetWinPath(), CFile::typeText | CFile::modeWrite | CFile::modeCreate) && retrycounter)
{
retrycounter--;
Sleep(200);
}
if (retrycounter == 0)
return false;
for (std::list<CString>::const_iterator it = m_lines.begin(); it != m_lines.end(); ++it)
{
file.WriteString(*it);
file.WriteString(_T("\n"));
}
file.Close();
}
catch (CFileException* pE)
{
TRACE("CFileException loading autolist regex file\n");
pE->Delete();
return false;
}
return true;
}
JXMenuBar::JXMenuBar
(
JXContainer* enclosure,
const HSizingOption hSizing,
const VSizingOption vSizing,
const JCoordinate x,
const JCoordinate y,
const JCoordinate w,
const JCoordinate h
)
:
JXWidget(enclosure, hSizing, vSizing, x,y, w,h),
itsOverflowMenu(NULL),
itsIgnoreWidthChangedCount(0)
{
itsMenus = new JPtrArray<JXMenu>(JPtrArrayT::kForgetAll);
assert( itsMenus != NULL );
SetBorderWidth(kJXDefaultBorderWidth);
JXDockManager* dockMgr;
if (JXGetDockManager(&dockMgr))
{
Move(JXDocktab::kWidth, 0);
AdjustSize(-JXDocktab::kWidth, 0);
JXDocktab* tab =
new JXDocktab(enclosure,
hSizing == kFixedRight ? kFixedRight : kFixedLeft,
vSizing, x, y, JXDocktab::kWidth, h);
assert( tab != NULL );
}
}
void COXMulticlipboardDlg::RemovePocket(int nPocket)
{
//the function remove pocket from
//the collection, actually destroying
//the window and deleting COXClipPocket object
if (nPocket>m_pPockets.GetUpperBound())
return;
COXClipPocket* pPocket=(COXClipPocket*) m_pPockets.GetAt(nPocket);
if (m_pPockets.GetUpperBound())
{
pPocket->DestroyWindow();
delete pPocket;
m_pPockets.RemoveAt(nPocket);
if (m_nCurrentPocket>=nPocket)
m_nCurrentPocket--;
}
else
pPocket->SetData(NULL,NULL);
//one pocket less - we have to adjust ths size
AdjustSize(PtrToUint(m_pPockets.GetUpperBound()));
}
void HKWidgetLabel::SetProperty(const char *pProperty, const char *pValue)
{
if(!MFString_CaseCmp(pProperty, "text"))
SetText(pValue);
else if(!MFString_CaseCmp(pProperty, "text_colour"))
SetTextColour(HKWidget_GetColourFromString(pValue));
else if(!MFString_CaseCmp(pProperty, "text_height"))
SetTextHeight(MFString_AsciiToFloat(pValue));
else if(!MFString_CaseCmp(pProperty, "text_shadowDepth"))
SetShadowDepth(MFString_AsciiToFloat(pValue));
else if(!MFString_CaseCmp(pProperty, "text_font"))
{
if(bOwnFont)
MFFont_Release(pFont);
pFont = MFFont_Create(pValue);
bOwnFont = true;
if(bAutoTextHeight)
textHeight = MFFont_GetFontHeight(pFont);
AdjustSize();
}
else if(!MFString_CaseCmp(pProperty, "text_align"))
SetTextJustification((MFFontJustify)HKWidget_GetEnumValue(pValue, sJustifyKeys));
else
HKWidget::SetProperty(pProperty, pValue);
}
/* InsertValue insert value into the binary heap
* the array is reallocated if necessary (allocated changed
* with respect to the new size )
* filled is incremented by 1 */
void InsertValue( BinarySort * tree , Decomposition *decomp )
{ int indice = 0;
while ( tree -> array[indice] != NULL )
{ if ( decomp -> value <= tree->array[indice]->value )
{
indice = indice * 2 + 1;
printf("%s\r\n", "indice * 2 + 1");
} else
{
indice = indice * 2 + 2;
printf("%s\r\n", "indice * 2 + 2");
}
while( tree -> allocated <= indice )
{
printf("%s\r\n", "Allocation");
printf("%s%d\r\n", "Alloué avant: ",tree->allocated);
tree=AdjustSize( tree );
printf("%s%d\r\n", "Alloué après : ",tree->allocated);
}
}
//printf("%s\r\n", "Fin while");
tree -> array[indice] = decomp;
printf("%s%d%s%d\r\n","je rajoute a l'indice ", indice, " la valeur ", decomp->value );
//printf("%d\r\n",decomp->value);
printf("%d\r\n",tree->filled);
tree->filled++;
printf("%d\r\n",tree->filled);
}
void
JXWidget::SetSize
(
const JCoordinate w,
const JCoordinate h
)
{
AdjustSize(w - itsFrameG.width(), h - itsFrameG.height());
}
/*#define MMSGBOX_W 400
#define MMSGBOX_X (MGetWorkspaceWidth()/2-MMSGBOX_W/2)
#define MMSGBOX_H 140
#define MMSGBOX_Y (MGetWorkspaceHeight()/2-MMSGBOX_H/2)
#define MMSGBOX_OK_W 80
#define MMSGBOX_OK_H 32
*/
bool MMsgBox::OnShow(void)
{
AdjustSize();
if(m_pOK!=NULL && m_pOK->IsVisible()==true)
m_pOK->SetFocus();
else if(m_pCancel!=NULL) m_pCancel->SetFocus();
return true;
}
void AutoHideBar::ShowAnimate(Ctrl *c)
{
if (c == ctrl) return;
if (popup.IsPopUp()) popup.Close();
Rect target = Ctrl::GetScreenRect();
Size sz = c->GetStdSize();
switch (GetAlign()) {
case DockTabBar::LEFT:
sz.cy = target.Height();
target.left = target.right;
break;
case DockTabBar::TOP:
sz.cx = target.Width();
target.top = target.bottom;
break;
case DockTabBar::RIGHT:
sz.cy = target.Height();
target.right = target.left;
break;
case DockTabBar::BOTTOM:
sz.cx = target.Width();
target.bottom = target.top;
break;
};
if (IsVert())
sz.cx = min(sz.cx, GetParent()->GetSize().cx / 2);
else
sz.cy = min(sz.cy, GetParent()->GetSize().cy / 2);
Rect init = target;
AdjustSize(init, Size(5, 5));
AdjustSize(target, sz);
c->SetRect(sz);
c->SizePos();
popup << *(ctrl = c);
c->Show();
popup.SetRect(target);
popup.PopUp(GetParent(), false, true, false, false);
Animate(popup, target, GUIEFFECT_SLIDE);
}
LRESULT CPreviewFileDialog::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
if(message==WM_WINDOWPOSCHANGING || message==WM_SIZE){
if(AdjustSize()){
Invalidate();
}
}
LRESULT lRes=CFileDialog::WindowProc(message, wParam, lParam);
return lRes;
}
bool wxStaticLine::Create(wxWindow *parent,
wxWindowID id,
const wxPoint& pos,
const wxSize& sizeOrig,
long style,
const wxString &name)
{
wxSize size = AdjustSize(sizeOrig);
if ( !CreateControl(parent, id, pos, size, style, wxDefaultValidator, name) )
return false;
return MSWCreateControl(_T("STATIC"), wxEmptyString, pos, size);
}
void AutoHideBar::ShowWindow()
{
DockWindow* hiddenwindow = reinterpret_cast<DockWindow*>(tabs[active].dock);
if(!hiddenwindow->IsOpen())
{
Size s = hiddenwindow->GetSizeHint();
Rect r = GetScreenRect();
Rect rr = r;
switch(layout)
{
case LAYOUT_LEFT:
rr.left = r.right;
s.cy = r.GetHeight();
#if defined(PLATFORM_X11)
rr.right += 1;
#endif
break;
case LAYOUT_TOP:
rr.top = r.bottom;
s.cx = r.GetWidth();
#if defined(PLATFORM_X11)
rr.bottom += 1;
#endif
break;
case LAYOUT_RIGHT:
rr.right = r.left;
s.cy = r.GetHeight();
#if defined(PLATFORM_X11)
rr.left -= 1;
#endif
break;
case LAYOUT_BOTTOM:
rr.bottom = r.top;
s.cx = r.GetWidth();
#if defined(PLATFORM_X11)
rr.top -= 1;
#endif
break;
}
popup.SetRect(rr);
popup.Add(hiddenwindow->SizePos());
hiddenwindow->Ctrl::Show();
popup.PopUp(GetOwner(), false, true, false, false);
ctrl = hiddenwindow;
Ctrl::ProcessEvents();
AdjustSize(rr, s);
Animate(popup, rr, GUIEFFECT_SLIDE);
}
}
Button::Button()
: mHasMouse(false),
mKeyPressed(false),
mMousePressed(false),
mAlignment(Graphics::CENTER),
mSpacing(4)
{
SetFocusable(true);
AdjustSize();
SetFrameSize(1);
addMouseListener(this);
addKeyListener(this);
addFocusListener(this);
}
void
GLFitParameterTable::PrintOnPage
(
JPagePrinter& p,
JCoordinate* height
)
{
const JSize origWidth = GetBoundsWidth();
JSize printWidth = JSize(p.GetPageWidth() * 0.9);
AdjustSize(printWidth - origWidth, 0);
// SetSize(printWidth, GetBoundsHeight());
AdjustColWidth(printWidth);
itsColHeaderWidget->PrintOnPage(p);
p.ShiftOrigin(0, itsColHeaderWidget->GetBoundsHeight());
TableDraw(p, GetBounds());
AdjustSize(origWidth - printWidth, 0);
// SetSize(origWidth, GetBoundsHeight());
*height = GetBoundsHeight() + itsColHeaderWidget->GetBoundsHeight();
}
bool wxStaticLine::Create(wxWindow *parent,
wxWindowID id,
const wxPoint &pos,
const wxSize &size,
long style,
const wxString &name)
{
if ( !wxControl::Create(parent, id, pos, size, style, wxDefaultValidator, name) )
return false;
wxSize sizeReal = AdjustSize(size);
if ( sizeReal != size )
SetSize(sizeReal);
return true;
}
/* InsertValue insert value into the binary heap
* the array is reallocated if necessary (allocated changed
* with respect to the new size )
* filled is incremented by 1 */
void InsertValue( BinarySort * tree , Decomposition *decomp )
{ int indice = 0;
while ( tree -> array[indice] != NULL )
{ if ( decomp -> value <= tree->array[indice]->value )
{
indice = indice * 2 + 1;
} else
{
indice = indice * 2 + 2;
}
while( tree -> allocated <= indice )
{
tree=AdjustSize( tree );
}
}
tree -> array[indice] = decomp;
tree -> filled++;
}
CThreadPool::CThreadPool(DWORD dwNum ) : _lThreadNum(0), _lRunningNum(0) ,m_exit(false)
{
InitializeCriticalSection(&_csThreadVector);
InitializeCriticalSection(&_csWorkQueue);
_EventComplete = CreateEvent(0, false, false, NULL);
_EventEnd = CreateEvent(0, true, false, NULL);
_EventActive = CreateEvent(0, true, true, NULL);
_EventFinished = CreateEvent(0, true, false, NULL);
_SemaphoreCall = CreateSemaphore(0, 0, 0x7FFFFFFF, NULL);
_SemaphoreDel = CreateSemaphore(0, 0, 0x7FFFFFFF, NULL);
assert(_SemaphoreCall != INVALID_HANDLE_VALUE);
assert(_EventComplete != INVALID_HANDLE_VALUE);
assert(_EventEnd != INVALID_HANDLE_VALUE);
assert(_EventActive != INVALID_HANDLE_VALUE);
assert(_EventFinished != INVALID_HANDLE_VALUE);
assert(_SemaphoreDel != INVALID_HANDLE_VALUE);
AdjustSize(dwNum <= 0 ? 4 : dwNum);
}
MMsgBox::MMsgBox(const char* szMessage, MWidget* pParent, MListener* pListener, MMsgBoxType nType)
: MFrame(MGetString(MSID_MESSAGE), pParent, (pListener==NULL)?pParent:pListener)
{
// m_pMessage = new MLabel(szMessage, this, this);
m_pMessage = new MTextArea(255, szMessage, this, this);
m_pMessage->SetEditable(false);
m_pOK = NULL;
m_pCancel = NULL;
if(nType!=MT_NOTDECIDED)
SetType(nType);
m_bResizable = false;
AdjustSize();
Show(false);
}
bool wxStaticLine::Create( wxWindow *parent,
wxWindowID id,
const wxPoint &pos,
const wxSize &size,
long style,
const wxString &name )
{
if ( !CreateBase( parent, id, pos, size, style, wxDefaultValidator, name ) )
return false;
// this is ugly but it's better than nothing:
// use a thin static box to emulate static line
wxSize sizeReal = AdjustSize( size );
// m_statbox = new wxStaticBox( parent, id, wxT(""), pos, sizeReal, style, name );
return true;
}
bool wxStaticLine::Create(
wxWindow* pParent
, wxWindowID vId
, const wxPoint& rPos
, const wxSize& rSize
, long lStyle
, const wxString& rsName
)
{
wxSize vSize = AdjustSize(rSize);
if ( !CreateControl( pParent
,vId
,rPos
,vSize
,lStyle
,wxDefaultValidator
,rsName
))
return FALSE;
if (!OS2CreateControl( wxT("STATIC")
,SS_FGNDFRAME
,rPos
,rSize
,rsName
))
return FALSE;
wxColour vColour;
vColour.Set(wxString(wxT("GREY")));
LONG lColor = (LONG)vColour.GetPixel();
::WinSetPresParam( m_hWnd
,PP_FOREGROUNDCOLOR
,sizeof(LONG)
,(PVOID)&lColor
);
return TRUE;
} // end of wxStaticLine::Create
void AutoHideBar::HideAnimate(Ctrl *c)
{
ASSERT(ctrl);
// If the popup has a child popup active then reset timer and keep the popup visible
Vector<Ctrl *> wins = Ctrl::GetTopCtrls();
for(int i = 0; i < wins.GetCount(); i++) {
if (wins[i]->IsPopUp() && wins[i]->GetOwner() == &popup) {
KillSetTimeCallback(autohide_timeout, THISBACK1(HideAnimate, ctrl), TIMEID_HIDE_TIMEOUT);
return;
}
}
DockTabBar::KillCursor();
#ifdef PLATFORM_WIN32
Rect r = popup.GetRect();
AdjustSize(r, -r.GetSize());
Animate(popup, r, GUIEFFECT_SLIDE);
#endif
popup.Close();
ctrl->Remove();
ctrl = NULL;
}
/* buffer allocation */
void *mb_alloc(int myid, int isize) {
register BufferHandle *tmp, *tmpnext;
register unsigned adjusted_size;
thr_mtx_lock(BufferLock[myid]);
adjusted_size = AdjustSize(isize) + BUF_HEADER_SIZE;
tmp = SysBuffer[myid];
while (tmp!=NULL && (tmp->free==0 || tmp->size<adjusted_size))
tmp = tmp->next;
if (tmp==NULL && UsrBuffer[myid]!=NULL) {
tmp = UsrBuffer[myid];
while (tmp!=NULL && (tmp->free==0 || tmp->size<adjusted_size))
tmp = tmp->next;
}
if (tmp==NULL) {
thr_mtx_unlock(BufferLock[myid]);
return NULL;
}
tmp->free = 0;
if (tmp->size >= adjusted_size + MinFragment) { /* need split */
tmpnext = (BufferHandle*)(((char*)tmp)+adjusted_size);
tmpnext->pre = tmp;
tmpnext->next = tmp->next;
if (tmpnext->next)
tmpnext->next->pre=tmpnext;
tmpnext->free = 1;
tmpnext->size = tmp->size-adjusted_size;
tmp->size = adjusted_size;
tmp->next = tmpnext;
}
thr_mtx_unlock(BufferLock[myid]);
return (((char*)tmp)+BUF_HEADER_SIZE);
}
void
CMLineIndexTable::AdjustToText()
{
const JFontManager* fontMgr = GetFontManager();
JFont font = itsText->GetCurrentFont();
const JSize lineCount = itsText->IsEmpty() ? 0 : itsText->GetLineCount();
const JString lineCountStr = GetLongestLineText(lineCount);
const JSize lineHeight = font.GetLineHeight();
const JSize lineNumberWidth = font.GetStringWidth(lineCountStr);
SetColWidth(kBreakpointColumn, lineHeight);
SetColWidth(kExecPointColumn, lineHeight);
SetColWidth(kLineNumberColumn, lineNumberWidth + 2*kMarginWidth);
SetAllRowHeights(lineHeight);
const JSize origRowCount = GetRowCount();
if (origRowCount < lineCount)
{
AppendRows(lineCount - origRowCount, lineHeight);
}
else if (origRowCount > lineCount)
{
RemovePrevRows(origRowCount, origRowCount - lineCount);
}
const JCoordinate tableWidth = GetBoundsWidth();
const JCoordinate apWidth = GetApertureWidth();
if (tableWidth != apWidth)
{
AdjustSize(tableWidth-apWidth, 0);
itsText->Place(GetFrameWidth(), 0);
itsText->AdjustSize(apWidth-tableWidth, 0);
}
ScrollTo(0, itsVScrollbar->GetValue());
UpdateBreakpoints();
}
void CPreviewFileDialog::OnInitDone()
{
CWnd *pWnd = GetDlgItem(IDC_STATIC_RECT);
if(pWnd)
{
CRect cr ;
pWnd->GetWindowRect(&cr);
ScreenToClient(&cr);
cr.top = cr.bottom+15;
cr.bottom = cr.top+17;
cr.left += 40;
checkBox.Create("&Preview",WS_CHILD|WS_VISIBLE|WS_TABSTOP|BS_AUTOCHECKBOX,cr,this,IDC_CHECK_PREVIEW);
checkBox.SetFont(GetFont());
checkBox.SetCheck(m_bPreview);
cr=PreviewRect;
cr.top = PreviewRect.bottom+15;
cr.bottom = cr.top+20;
imageInfo.Create("Image info",WS_CHILD|WS_VISIBLE|SS_CENTER,cr,this,IDC_IMAGEINFO);
imageInfo.SetFont(GetFont());
AdjustSize();
}
}
int AttachGalley(OBJECT hd, OBJECT *inners, OBJECT *suspend_pt)
{ OBJECT hd_index; /* the index of hd in the enclosing galley */
OBJECT hd_inners; /* inner galleys of hd, if unsized */
OBJECT dest; /* the target @Galley hd empties into */
OBJECT dest_index; /* the index of dest */
OBJECT target; /* the target indefinite containing dest */
OBJECT target_index; /* the index of target */
OBJECT target_galley; /* the body of target, made into a galley */
OBJECT tg_inners; /* inner galleys of target_galley */
BOOLEAN need_precedes = FALSE;/* true if destination lies before galley */
OBJECT recs; /* list of recursive definite objects */
OBJECT link, y = nilobj; /* for scanning through the components of hd */
CONSTRAINT c; /* temporary variable holding a constraint */
OBJECT env, n1, tmp, zlink, z, sym; /* placeholders and temporaries */
BOOLEAN was_sized; /* true if sized(hd) initially */
int dim; /* the galley direction */
FULL_LENGTH perp_back, perp_fwd;
OBJECT why, junk;
debug2(DGA, D, "[ AttachGalley(Galley %s into %s)",
SymName(actual(hd)), SymName(whereto(hd)));
ifdebug(DGA, DD, DebugGalley(hd, nilobj, 4));
assert( Up(hd) != hd, "AttachGalley: no index!" );
Parent(hd_index, Up(hd));
assert( type(hd_index) == UNATTACHED, "AttachGalley: not UNATTACHED!" );
hd_inners = tg_inners = nilobj;
was_sized = sized(hd);
dim = gall_dir(hd);
for(;;)
{
/*************************************************************************/
/* */
/* Search for a destination for hd. If hd is unsized, search for */
/* inner galleys preceding it first of all, then for receptive objects */
/* following it, possibly in inner galleys. If no luck, exit. */
/* If hd is sized, search only for receptive objects in the current */
/* galley below the current spot, and fail if cannot find any. */
/* */
/*************************************************************************/
sym = whereto(hd);
if( sized(hd) )
{
/* sized galley case: search on from current spot */
target_index = SearchGalley(Up(hd_index), sym, TRUE, FALSE, TRUE, TRUE);
if( target_index == nilobj )
{
/* search failed to find any new target, so kill the galley */
for( link = Down(hd); link != hd; link = NextDown(link) )
{ Child(y, link);
if( type(y) == SPLIT ) Child(y, DownDim(y, dim));
if( is_definite(type(y)) ) break;
}
if( link != hd )
Error(19, 1, "galley %s deleted from here (no target)",
WARN, &fpos(y), SymName(actual(hd)));
if( hd_inners != nilobj ) DisposeObject(hd_inners), hd_inners=nilobj;
if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners=nilobj;
KillGalley(hd, FALSE);
*inners = nilobj;
debug0(DGA, D, "] AttachGalley returning ATTACH_KILLED");
return ATTACH_KILLED;
}
else if( actual(actual(target_index)) == InputSym )
{
/* search found input object, so suspend on that */
DeleteNode(hd_index);
Link(target_index, hd);
*inners = nilobj;
debug0(DGA, D, "] AttachGalley returning ATTACH_INPUT");
return ATTACH_INPUT;
}
}
else /* unsized galley, either backwards or normal */
{
if( foll_or_prec(hd) == GALL_PREC )
{ target_index= SearchGalley(Up(hd_index), sym, FALSE, TRUE,TRUE,FALSE);
need_precedes = FALSE;
}
else
{ target_index = SearchGalley(Up(hd_index), sym, FALSE,TRUE,FALSE,FALSE);
need_precedes = (target_index != nilobj);
if( target_index == nilobj )
target_index = SearchGalley(Up(hd_index), sym, TRUE,TRUE,TRUE,FALSE);
}
/* if no luck, exit without error */
if( target_index == nilobj )
{ *inners = nilobj;
debug0(DGA, D, "] AttachGalley returning ATTACH_NOTARGET");
return ATTACH_NOTARGET;
}
}
assert( type(target_index) == RECEPTIVE, "AttachGalley: target_index!" );
target = actual(target_index);
assert( type(target) == CLOSURE, "AttachGalley: target!" );
/* set target_galley to the expanded value of target */
debug1(DYY, D, "[ EnterErrorBlock(FALSE) (expanding target %s)",
SymName(actual(target)));
EnterErrorBlock(FALSE);
New(target_galley, HEAD);
force_gall(target_galley) = FALSE;
enclose_obj(target_galley) = limiter(target_galley) = nilobj;
ClearHeaders(target_galley);
opt_components(target_galley) = opt_constraints(target_galley) = nilobj;
gall_dir(target_galley) = external_hor(target) ? COLM : ROWM;
FposCopy(fpos(target_galley), fpos(target));
actual(target_galley) = actual(target);
whereto(target_galley) = ready_galls(target_galley) = nilobj;
foll_or_prec(target_galley) = GALL_FOLL;
must_expand(target_galley) = FALSE;
sized(target_galley) = FALSE;
/* get perpendicular constraint (none if horizontal galley) */
if( dim == ROWM )
{
Constrained(target, &c, 1-dim, &junk);
if( !constrained(c) )
Error(19, 2, "receptive symbol %s has unconstrained width",
FATAL, &fpos(target), SymName(actual(target)));
debug2(DSC, DD, "Constrained( %s, 1-dim ) = %s",
EchoObject(target), EchoConstraint(&c));
if( !FitsConstraint(0, 0, c) )
{ debug0(DGA, D, " reject: target_galley horizontal constraint is -1");
y = nilobj;
goto REJECT;
}
}
else /* actually unused */
SetConstraint(c, MAX_FULL_LENGTH, MAX_FULL_LENGTH, MAX_FULL_LENGTH);
debug1(DGA, DDD, " expanding %s", EchoObject(target));
tmp = CopyObject(target, no_fpos);
Link(target_galley, tmp);
env = DetachEnv(tmp);
debug4(DGM, D, " external_ver(%s) = %s, external_hor(%s) = %s",
SymName(actual(target)), bool(external_ver(target)),
SymName(actual(target)), bool(external_hor(target)));
SizeGalley(target_galley, env,
external_ver(target) || external_hor(target),
threaded(target), non_blocking(target_index),
trigger_externs(target_index), &save_style(target),
&c, whereto(hd), &dest_index, &recs, &tg_inners,
enclose_obj(hd) != nilobj ? CopyObject(enclose_obj(hd), no_fpos):nilobj);
debug1(DGA, DD, " SizeGalley tg_inners: %s", DebugInnersNames(tg_inners));
if( recs != nilobj ) ExpandRecursives(recs);
dest = actual(dest_index);
if( underline(dest) == UNDER_UNDEF ) underline(dest) = UNDER_OFF;
/* verify that hd satisfies any horizontal constraint on dest */
if( dim == ROWM )
{
debug1(DGA, DDD, " checking hor fit of hd in %s",SymName(actual(dest)));
Constrained(dest, &c, 1-dim, &junk);
debug3(DSC, DD, "Constrained( %s, %s ) = %s",
EchoObject(dest), dimen(1-dim), EchoConstraint(&c));
assert( constrained(c), "AttachGalley: dest unconstrained!" );
if( !FitsConstraint(0, 0, c) )
{ debug0(DGA, D, " reject: hd horizontal constraint is -1");
y = nilobj;
goto REJECT;
}
}
/* manifest and size the galley if not done yet */
if( !sized(hd) )
{
debug2(DYY, D, "[ EnterErrorBlock(TRUE) (sizing galley %s into %s)",
SymName(actual(hd)), SymName(whereto(hd)));
EnterErrorBlock(TRUE);
n1 = nilobj;
Child(y, Down(hd));
env = DetachEnv(y);
/*** threaded() only defined in ROWM case
SizeGalley(hd, env, TRUE, threaded(dest), non_blocking(target_index),
TRUE, &save_style(dest), &c, nilobj, &n1, &recs, &hd_inners);
*** */
SizeGalley(hd, env, TRUE, dim == ROWM ? threaded(dest) : FALSE,
non_blocking(target_index), TRUE, &save_style(dest), &c, nilobj,
&n1, &recs, &hd_inners, nilobj);
debug1(DGA,DD," SizeGalley hd_inners: %s", DebugInnersNames(hd_inners));
if( recs != nilobj ) ExpandRecursives(recs);
if( need_precedes ) /* need an ordering constraint */
{ OBJECT index1, index2;
New(index1, PRECEDES);
New(index2, FOLLOWS);
blocked(index2) = FALSE;
tmp = MakeWord(WORD, STR_EMPTY, no_fpos);
Link(index1, tmp); Link(index2, tmp);
Link(Up(hd_index), index1);
Link(Down(hd), index2);
debug0(DGA, D, " inserting PRECEDES and FOLLOWS");
}
LeaveErrorBlock(TRUE);
debug0(DYY, D, "] LeaveErrorBlock(TRUE) (finished sizing galley)");
}
if( dim == ROWM )
{ if( !FitsConstraint(back(hd, 1-dim), fwd(hd, 1-dim), c) )
{ debug3(DGA, D, " reject: hd %s,%s does not fit target_galley %s",
EchoLength(back(hd, 1-dim)), EchoLength(fwd(hd, 1-dim)),
EchoConstraint(&c));
Error(19, 3, "too little horizontal space for galley %s at %s",
WARN, &fpos(hd), SymName(actual(hd)), SymName(actual(dest)));
goto REJECT;
}
}
/* check status of first component of hd */
debug0(DGA, DDD, " now ready to attach; hd =");
ifdebug(DGA, DDD, DebugObject(hd));
for( link = Down(hd); link != hd; link = NextDown(link) )
{
Child(y, link);
debug1(DGA, DDD, " examining %s", EchoIndex(y));
if( type(y) == SPLIT ) Child(y, DownDim(y, dim));
switch( type(y) )
{
case EXPAND_IND:
case SCALE_IND:
case COVER_IND:
case GALL_PREC:
case GALL_FOLL:
case GALL_FOLL_OR_PREC:
case GALL_TARG:
case CROSS_PREC:
case CROSS_FOLL:
case CROSS_FOLL_OR_PREC:
case CROSS_TARG:
case PAGE_LABEL_IND:
break;
case PRECEDES:
case UNATTACHED:
if( was_sized )
{ /* SizeGalley was not called, so hd_inners was not set by it */
if( hd_inners == nilobj ) New(hd_inners, ACAT);
Link(hd_inners, y);
}
break;
case RECEPTIVE:
goto SUSPEND;
case RECEIVING:
goto SUSPEND;
case FOLLOWS:
Child(tmp, Down(y));
if( Up(tmp) == LastUp(tmp) )
{ link = pred(link, CHILD);
debug0(DGA, DD, " disposing FOLLOWS");
DisposeChild(NextDown(link));
break;
}
Parent(tmp, Up(tmp));
assert(type(tmp) == PRECEDES, "Attach: PRECEDES!");
switch( CheckComponentOrder(tmp, target_index) )
{
case CLEAR: DeleteNode(tmp);
link = pred(link, CHILD);
DisposeChild(NextDown(link));
break;
case PROMOTE: break;
case BLOCK: debug0(DGA, DD, "CheckContraint: BLOCK");
goto SUSPEND;
case CLOSE: debug0(DGA, D, " reject: CheckContraint");
goto REJECT;
}
break;
case GAP_OBJ:
underline(y) = underline(dest);
if( !join(gap(y)) ) seen_nojoin(hd) = TRUE;
break;
case BEGIN_HEADER:
case END_HEADER:
case SET_HEADER:
case CLEAR_HEADER:
/* do nothing until actually promoted out of here */
underline(y) = underline(dest);
break;
case CLOSURE:
case CROSS:
case FORCE_CROSS:
case NULL_CLOS:
case PAGE_LABEL:
underline(y) = underline(dest);
break;
case WORD:
case QWORD:
case ONE_COL:
case ONE_ROW:
case WIDE:
case HIGH:
case HSHIFT:
case VSHIFT:
case HMIRROR:
case VMIRROR:
case HSCALE:
case VSCALE:
case HCOVER:
case VCOVER:
case HCONTRACT:
case VCONTRACT:
case HLIMITED:
case VLIMITED:
case HEXPAND:
case VEXPAND:
case START_HVSPAN:
case START_HSPAN:
case START_VSPAN:
case HSPAN:
case VSPAN:
case ROTATE:
case BACKGROUND:
case SCALE:
case KERN_SHRINK:
case INCGRAPHIC:
case SINCGRAPHIC:
case PLAIN_GRAPHIC:
case GRAPHIC:
case LINK_SOURCE:
case LINK_DEST:
case LINK_DEST_NULL:
case LINK_URL:
case ACAT:
case HCAT:
case VCAT:
case ROW_THR:
case COL_THR:
underline(y) = underline(dest);
if( dim == ROWM )
{
/* make sure y is not joined to a target below (vertical only) */
for( zlink = NextDown(link); zlink != hd; zlink = NextDown(zlink) )
{ Child(z, zlink);
switch( type(z) )
{
case RECEPTIVE:
if( non_blocking(z) )
{ zlink = PrevDown(zlink);
DeleteNode(z);
}
else
{ y = z;
goto SUSPEND;
}
break;
case RECEIVING:
if( non_blocking(z) )
{ zlink = PrevDown(zlink);
while( Down(z) != z )
{ Child(tmp, Down(y));
if( opt_components(tmp) != nilobj )
{ DisposeObject(opt_components(tmp));
opt_components(tmp) = nilobj;
debug3(DOG, D, "AttachGalley(%s) de-optimizing %s %s",
SymName(actual(hd)), SymName(actual(tmp)), "(join)");
}
DetachGalley(tmp);
KillGalley(tmp, FALSE);
}
DeleteNode(z);
}
else
{ y = z;
goto SUSPEND;
}
break;
case GAP_OBJ:
if( !join(gap(z)) ) zlink = PrevDown(hd);
break;
default: break;
}
}
/* if HCAT, try vertical hyphenation (vertical galleys only) */
if( type(y) == HCAT ) VerticalHyphenate(y);
}
/* check availability of parallel space for the first component */
why = nilobj;
Constrained(dest, &c, dim, &why);
debug3(DGF, DD, " dest parallel Constrained(%s, %s) = %s",
EchoObject(dest), dimen(dim), EchoConstraint(&c));
if( !FitsConstraint(back(y, dim), fwd(y, dim), c) )
{ BOOLEAN scaled;
/* if forcing galley doesn't fit, try scaling first component */
scaled = FALSE;
if( force_gall(hd) && size(y, dim) > 0 )
{ int scale_factor;
scale_factor = ScaleToConstraint(back(y,dim), fwd(y,dim), &c);
if( scale_factor > 0.5 * SF )
{ char num1[20], num2[20];
sprintf(num1, "%.1fc", (float) size(y, dim) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( dim == ROWM )
Error(19, 4, "%s object too high for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
else
Error(19, 5, "%s object too wide for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
y = InterposeScale(y, scale_factor, dim);
scaled = TRUE;
}
}
/* otherwise we must reject, and warn the user */
if( !scaled )
{ char num1[20], num2[20];
debug3(DGA, D, " reject: vsize %s,%s in %s; y=",
EchoLength(back(y, dim)), EchoLength(fwd(y, dim)),
EchoConstraint(&c));
ifdebug(DGA, D, DebugObject(y));
if( size(y, dim) > 0 )
{ sprintf(num1, "%.1fc", (float) size(y, dim) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( dim == ROWM )
Error(19, 12, "%s object too high for %s space; will try elsewhere",
WARN, &fpos(y), num1, num2);
else
Error(19, 13, "%s object too wide for %s space; will try elsewhere",
WARN, &fpos(y), num1, num2);
}
goto REJECT;
}
}
/* check availability of perpendicular space for first component */
if( dim == ROWM )
{ perp_back = back(hd, 1-dim); perp_fwd = fwd(hd, 1-dim);
}
else
{ perp_back = back(y, 1-dim); perp_fwd = fwd(y, 1-dim);
}
Constrained(dest, &c, 1-dim, &junk);
debug3(DGF, DD, " dest perpendicular Constrained(%s, %s) = %s",
EchoObject(dest), dimen(1-dim), EchoConstraint(&c));
if( !FitsConstraint(perp_back, perp_fwd, c) )
{ BOOLEAN scaled;
/* if forcing galley doesn't fit, try scaling first component */
scaled = FALSE;
if( force_gall(hd) && perp_back + perp_fwd > 0 )
{ int scale_factor;
scale_factor = ScaleToConstraint(perp_back, perp_fwd, &c);
if( scale_factor > 0.5 * SF )
{ char num1[20], num2[20];
sprintf(num1, "%.1fc", (float) (perp_back + perp_fwd) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( 1-dim == ROWM )
Error(19, 6, "%s object too high for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
else
Error(19, 7, "%s object too wide for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
y = InterposeScale(y, scale_factor, 1-dim);
scaled = TRUE;
}
}
/* otherwise we must reject, and warn the user */
if( !scaled )
{
debug3(DGA, D, " reject: vsize %s,%s in %s; y=",
EchoLength(perp_back), EchoLength(perp_fwd),
EchoConstraint(&c));
ifdebug(DGA, D, DebugObject(y));
goto REJECT;
}
}
/* dest seems OK, so perform its size adjustments */
debug0(DSA, D, "calling AdjustSize from AttachGalley (a)");
AdjustSize(dest, back(y, dim), fwd(y, dim), dim);
debug0(DSA, D, "calling AdjustSize from AttachGalley (b)");
AdjustSize(dest, perp_back, perp_fwd, 1-dim);
/* now check parallel space for target_galley in target */
Constrained(target, &c, dim, &why);
debug3(DGF, DD, " target parallel Constrained(%s, %s) = %s",
EchoObject(target), dimen(dim), EchoConstraint(&c));
Child(z, LastDown(target_galley)); /* works in all cases? */
assert( !is_index(type(z)), "AttachGalley: is_index(z)!" );
assert( back(z, dim)>=0 && fwd(z, dim)>=0, "AttachGalley: z size!" );
if( !FitsConstraint(back(z, dim), fwd(z, dim), c) )
{ BOOLEAN scaled;
debug2(DGA, D, " why = %d %s", (int) why, EchoObject(why));
debug2(DGA, D, " limiter = %d %s", (int) limiter(hd),
EchoObject(limiter(hd)));
/* if forcing galley doesn't fit, try scaling z */
scaled = FALSE;
if( force_gall(hd) && size(z, dim) > 0 && limiter(hd) != why )
{ int scale_factor;
scale_factor = ScaleToConstraint(back(z,dim), fwd(z,dim), &c);
if( scale_factor > 0.5 * SF )
{ char num1[20], num2[20];
sprintf(num1, "%.1fc", (float) size(z, dim) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( dim == ROWM )
Error(19, 8, "%s object too high for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
else
Error(19, 9, "%s object too wide for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
z = InterposeWideOrHigh(z, dim);
z = InterposeScale(z, scale_factor, dim);
scaled = TRUE;
}
}
if( !scaled )
{ char num1[20], num2[20];
limiter(hd) = why;
debug3(DGA, D, " set limiter(%s) = %d %s", SymName(actual(hd)),
(int) limiter(hd), EchoObject(limiter(hd)));
debug3(DGA, D, " reject: size was %s,%s in %s; y =",
EchoLength(back(z, dim)), EchoLength(fwd(z, dim)),
EchoConstraint(&c));
ifdebug(DGA, D, DebugObject(y));
if( size(z, dim) > 0 )
{ sprintf(num1, "%.1fc", (float) size(z, dim) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( dim == ROWM )
Error(19, 14, "%s object too high for %s space; will try elsewhere",
WARN, &fpos(y), num1, num2);
else
Error(19, 15, "%s object too wide for %s space; will try elsewhere",
WARN, &fpos(y), num1, num2);
}
goto REJECT;
}
}
limiter(hd) = why;
debug3(DGA, D, " set limiter(%s) = %d %s", SymName(actual(hd)),
(int) limiter(hd), EchoObject(limiter(hd)));
/* now check perpendicular space for target_galley in target */
Constrained(target, &c, 1-dim, &junk);
debug3(DGF, DD, " target perpendicular Constrained(%s, %s) = %s",
EchoObject(target), dimen(1-dim), EchoConstraint(&c));
Child(z, LastDown(target_galley)); /* works in all cases? */
assert( !is_index(type(z)), "AttachGalley: is_index(z)!" );
assert( back(z, 1-dim)>=0 && fwd(z, 1-dim)>=0,
"AttachGalley: z size (perpendicular)!" );
if( !FitsConstraint(back(z, 1-dim), fwd(z, 1-dim), c) )
{ BOOLEAN scaled;
/* if forcing galley doesn't fit, try scaling z */
scaled = FALSE;
if( force_gall(hd) && size(z, 1-dim) > 0 )
{ int scale_factor;
scale_factor = ScaleToConstraint(back(z,1-dim), fwd(z,1-dim), &c);
if( scale_factor > 0.5 * SF )
{ char num1[20], num2[20];
sprintf(num1, "%.1fc", (float) size(z, 1-dim) / CM);
sprintf(num2, "%.1fc", (float) bfc(c) / CM);
if( 1-dim == ROWM )
Error(19, 10, "%s object too high for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
else
Error(19, 11, "%s object too wide for %s space; %s inserted",
WARN, &fpos(y), num1, num2, KW_SCALE);
z = InterposeWideOrHigh(z, 1-dim);
z = InterposeScale(z, scale_factor, 1-dim);
scaled = TRUE;
}
}
if( !scaled )
{
debug3(DGA, D, " reject: size was %s,%s in %s; y =",
EchoLength(back(z, 1-dim)), EchoLength(fwd(z, 1-dim)),
EchoConstraint(&c));
ifdebug(DGA, D, DebugObject(y));
goto REJECT;
}
}
/* target seems OK, so adjust sizes and accept */
if( external_hor(target) )
{
/* don't adjust any sizes, none to adjust */
debug0(DSA, D, "not calling AdjustSize from AttachGalley (c)");
}
else if( external_ver(target) )
{
/* adjust perp size only, to galley size */
debug0(DSA, D, "calling AdjustSize from AttachGalley (d)");
AdjustSize(target, back(target_galley, 1-dim),
fwd(target_galley, 1-dim), 1-dim);
}
else
{
/* adjust both directions, using z (last component) */
Child(z, LastDown(target_galley));
debug0(DSA, D, "AttachGalley AdjustSize using z =");
ifdebug(DSA, D, DebugObject(z));
debug0(DSA, D, "calling AdjustSize from AttachGalley (e)");
AdjustSize(target, back(z, dim), fwd(z, dim), dim);
debug0(DSA, D, "calling AdjustSize from AttachGalley (f)");
AdjustSize(target, back(z, 1-dim), fwd(z, 1-dim), 1-dim);
}
goto ACCEPT;
default:
assert1(FALSE, "AttachGalley:", Image(type(y)));
break;
} /* end switch */
} /* end for */
/* null galley: promote whole galley without expanding the target */
debug0(DGA, D, " null galley");
if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners = nilobj;
DisposeObject(target_galley);
LeaveErrorBlock(FALSE);
debug0(DYY, D, "] LeaveErrorBlock(FALSE) (null galley)");
/* kill off any null objects within the galley, then transfer it */
/* don't use Promote() since it does extra unwanted things here */
for( link = Down(hd); link != hd; link = NextDown(link) )
{ Child(y, link);
switch( type(y) )
{
case GAP_OBJ:
case CLOSURE:
case CROSS:
case FORCE_CROSS:
case NULL_CLOS:
case PAGE_LABEL:
link = PrevDown(link);
debug1(DGA, D, " null galley, disposing %s", Image(type(y)));
DisposeChild(NextDown(link));
break;
default:
break;
}
}
TransferLinks(NextDown(hd), hd, Up(target_index));
/* attach hd temporarily to target_index */
MoveLink(Up(hd), target_index, PARENT);
assert( type(hd_index) == UNATTACHED, "AttachGalley: type(hd_index)!" );
DeleteNode(hd_index);
/* return; only hd_inners needs to be flushed now */
*inners = hd_inners;
debug0(DGA, D, "] AttachGalley returning ATTACH_NULL");
return ATTACH_NULL;
REJECT:
/* reject first component */
/* debug1(DGA, D, " reject %s", EchoObject(y)); */
debug0(DGA, D, " reject first component");
LeaveErrorBlock(TRUE);
debug0(DYY, D, "] LeaveErrorBlock(TRUE) (REJECT)");
if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners = nilobj;
DisposeObject(target_galley);
if( foll_or_prec(hd) == GALL_PREC && !sized(hd) )
{
/* move to just before the failed target */
MoveLink(Up(hd_index), Up(target_index), PARENT);
}
else
{
/* move to just after the failed target */
MoveLink(Up(hd_index), NextDown(Up(target_index)), PARENT);
}
continue;
SUSPEND:
/* suspend at first component */
debug1(DGA, D, " suspend %s", EchoIndex(y));
blocked(y) = TRUE;
LeaveErrorBlock(FALSE);
debug0(DYY, D, "] LeaveErrorBlock(FALSE) (SUSPEND)");
if( tg_inners != nilobj ) DisposeObject(tg_inners), tg_inners = nilobj;
DisposeObject(target_galley);
MoveLink(Up(hd_index), Up(target_index), PARENT);
if( was_sized )
{ /* nothing new to flush if suspending and already sized */
if( hd_inners != nilobj ) DisposeObject(hd_inners), hd_inners=nilobj;
*inners = nilobj;
}
else
{ /* flush newly discovered inners if not sized before */
*inners = hd_inners;
}
debug0(DGA, D, "] AttachGalley returning ATTACH_SUSPEND");
*suspend_pt = y;
return ATTACH_SUSPEND;
ACCEPT:
/* accept first component; now committed to the attach */
debug3(DGA, D, " accept %s %s %s", Image(type(y)), EchoObject(y),
EchoFilePos(&fpos(y)));
LeaveErrorBlock(TRUE);
debug0(DYY, D, "] LeaveErrorBlock(TRUE) (ACCEPT)");
/* attach hd to dest */
MoveLink(Up(hd), dest_index, PARENT);
assert( type(hd_index) == UNATTACHED, "AttachGalley: type(hd_index)!" );
DeleteNode(hd_index);
/* move first component of hd into dest */
/* nb Interpose must be done after all AdjustSize calls */
if( dim == ROWM && !external_ver(dest) )
Interpose(dest, VCAT, hd, y);
else if( dim == COLM && !external_hor(dest) )
{ Interpose(dest, ACAT, y, y);
Parent(junk, Up(dest));
assert( type(junk) == ACAT, "AttachGalley: type(junk) != ACAT!" );
StyleCopy(save_style(junk), save_style(dest));
adjust_cat(junk) = padjust(save_style(junk));
}
debug1(DGS, D, "calling Promote(hd, %s) from AttachGalley/ACCEPT",
link == hd ? "hd" : "NextDown(link)");
Promote(hd, link == hd ? hd : NextDown(link), dest_index, TRUE);
/* move target_galley into target */
/* nb Interpose must be done after all AdjustSize calls */
if( !(external_ver(target) || external_hor(target)) )
{ Child(z, LastDown(target_galley));
Interpose(target, VCAT, z, z);
}
debug0(DGS, D, "calling Promote(target_galley) from AttachGalley/ACCEPT");
Promote(target_galley, target_galley, target_index, TRUE);
DeleteNode(target_galley);
assert(Down(target_index)==target_index, "AttachGalley: target_ind");
if( blocked(target_index) ) blocked(dest_index) = TRUE;
DeleteNode(target_index);
/* return; both tg_inners and hd_inners need to be flushed now; */
/* if was_sized, hd_inners contains the inners of the first component; */
/* otherwise it contains the inners of all components, from SizeGalley */
if( tg_inners == nilobj ) *inners = hd_inners;
else if( hd_inners == nilobj ) *inners = tg_inners;
else
{ TransferLinks(Down(hd_inners), hd_inners, tg_inners);
DeleteNode(hd_inners);
*inners = tg_inners;
}
debug0(DGA, D, "] AttachGalley returning ATTACH_ACCEPT");
ifdebug(DGA, D,
if( dim == COLM && !external_hor(dest) )
{ OBJECT z;
Parent(z, Up(dest));
debug2(DGA, D, " COLM dest_encl on exit = %s %s",
Image(type(z)), EchoObject(z));
}
)
return ATTACH_ACCEPT;
} /* end for */
__declspec(dllexport) void download (HWND parent,
int string_size,
char *variables,
stack_t **stacktop)
{
static char buf[1024];
static char url[1024];
static char filename[1024];
int wasen=0;
HWND hwndL=0;
HWND hwndB=0;
static char szDownloading[32];//= "Downloading %s";
static char szConnecting[32];//= "Connecting ...";
static char szSecond[32];//= "second";
static char szMinute[32];//= "minute";
static char szHour[32];//= "hour";
static char szPlural[32];//= "s";
static char szProgress[128];//= "%dkB (%d%%) of %dkB @ %d.%01dkB/s";
static char szRemaining[128];//= " (%d %s%s remaining)";
g_parent = parent;
EXDLL_INIT();
popstring(url);
if (!lstrcmpi(url, "/TRANSLATE")) {
popstring(szDownloading);
popstring(szConnecting);
popstring(szSecond);
popstring(szMinute);
popstring(szHour);
popstring(szPlural);
popstring(szProgress);
popstring(szRemaining);
popstring(url);
}
else {
lstrcpy(szDownloading, "Downloading %s");
lstrcpy(szConnecting, "Connecting ...");
lstrcpy(szSecond, "second");
lstrcpy(szMinute, "minute");
lstrcpy(szHour, "hour");
lstrcpy(szPlural, "s");
lstrcpy(szProgress, "%dkB (%d%%) of %dkB @ %d.%01dkB/s");
lstrcpy(szRemaining, " (%d %s%s remaining)");
}
lstrcpyn(buf, url, 10);
if (!lstrcmpi(buf, "/TIMEOUT=")) {
g_timeout_ms=my_atoi(url+9);
popstring(url);
}
popstring(filename);
HANDLE hFile = CreateFile(filename,GENERIC_WRITE,FILE_SHARE_READ,NULL,CREATE_ALWAYS,0,NULL);
if (hFile == INVALID_HANDLE_VALUE) {
wsprintf (buf, "Unable to open %s", filename);
setuservariable(INST_0, buf);
} else {
if (g_parent)
{
g_childwnd=FindWindowEx(g_parent,NULL,"#32770",NULL);
hwndL=GetDlgItem(g_childwnd,1016);
hwndB=GetDlgItem(g_childwnd,1027);
if (hwndL && IsWindowVisible(hwndL)) ShowWindow(hwndL,SW_HIDE);
else hwndL=NULL;
if (hwndB && IsWindowVisible(hwndB)) ShowWindow(hwndB,SW_HIDE);
else hwndB=NULL;
wasen=EnableWindow(GetDlgItem(g_parent,IDCANCEL),1);
lpWndProcOld = (void *) GetWindowLong(g_parent,GWL_WNDPROC);
SetWindowLong(g_parent,GWL_WNDPROC,(long)ParentWndProc);
g_dialog = CreateDialog((HINSTANCE)hModule,
MAKEINTRESOURCE(IDD_DIALOG1),
g_childwnd,
DownloadDialogProc);
if (g_dialog)
{
GetWindowRect(g_dialog,&cr);
ScreenToClient(g_dialog,(LPPOINT)&cr);
ScreenToClient(g_dialog,((LPPOINT)&cr)+1);
GetWindowRect(GetDlgItem(g_childwnd,1016),&r);
ScreenToClient(g_childwnd,(LPPOINT)&r);
ScreenToClient(g_childwnd,((LPPOINT)&r)+1);
SetWindowPos(g_dialog,0,r.left,r.top,r.right-r.left,cr.bottom-cr.top,SWP_NOACTIVATE|SWP_NOZORDER);
AdjustSize(IDC_STATIC2);
AdjustSize(IDC_PROGRESS1);
ShowWindow(g_dialog,SW_SHOWNA);
char *p=filename;
while (*p) p++;
while (*p != '\\' && p != filename) p=CharPrev(filename,p);
wsprintf(buf,szDownloading, p+1);
SetDlgItemText(g_childwnd,1006,buf);
SetDlgItemText (g_dialog, IDC_STATIC2, szConnecting);
}
}
g_hwndProgressBar = GetDlgItem (g_dialog, IDC_PROGRESS1);
JNL_HTTPGet *get;
char *error=NULL;
{
WSADATA wsaData;
WSAStartup(MAKEWORD(1, 1), &wsaData);
static char buf[8192]="";
char *p=NULL;
HKEY hKey;
if (RegOpenKeyEx(HKEY_CURRENT_USER,"Software\\Microsoft\\Windows\\CurrentVersion\\Internet Settings",0,KEY_READ,&hKey) == ERROR_SUCCESS)
{
DWORD l = 4;
DWORD t;
DWORD v;
if (RegQueryValueEx(hKey,"ProxyEnable",NULL,&t,(unsigned char *)&v,&l) == ERROR_SUCCESS && t == REG_DWORD && v)
{
l=8192;
if (RegQueryValueEx(hKey,"ProxyServer",NULL,&t,(unsigned char *)buf,&l ) == ERROR_SUCCESS && t == REG_SZ)
{
p=strstr(buf,"http=");
if (!p) p=buf;
else {
p+=5;
}
char *tp=strstr(p,";");
if (tp) *tp=0;
char *p2=strstr(p,"=");
if (p2) p=0; // we found the wrong proxy
}
}
buf[8192-1]=0;
RegCloseKey(hKey);
}
DWORD start_time=GetTickCount();
get=new JNL_HTTPGet(JNL_CONNECTION_AUTODNS,16384,(p&&p[0])?p:NULL);
int st;
int has_printed_headers = 0;
int cl;
int len;
int sofar = 0;
DWORD last_recv_time=start_time;
get->addheader ("User-Agent: NSISDL/1.2 (Mozilla)");
get->addheader ("Accept: */*");
get->connect (url);
while (1) {
if (g_dialog)
{
MSG msg;
while (PeekMessage(&msg,g_dialog,0,0,PM_REMOVE))
{
TranslateMessage(&msg);
DispatchMessage(&msg);
}
}
Sleep(25);
if (g_cancelled) break;
st = get->run ();
if (st == -1) {
error=get->geterrorstr();
break;
} else if (st == 1) {
if (sofar < cl)
error="download incomplete";
break;
} else {
if (get->get_status () == 0) {
// progressFunc ("Connecting ...", 0);
if (last_recv_time+g_timeout_ms < GetTickCount())
{
error = "Timed out on connecting.";
break;
}
} else if (get->get_status () == 1) {
progress_callback("Reading headers", 0);
if (last_recv_time+g_timeout_ms < GetTickCount())
{
error = "Timed out on getting headers.";
break;
}
} else if (get->get_status () == 2) {
if (! has_printed_headers) {
has_printed_headers = 1;
last_recv_time=GetTickCount();
cl = get->content_length ();
if (cl == 0) {
error = "Server did not specify content length.";
break;
} else if (g_dialog) {
SendMessage(g_hwndProgressBar, PBM_SETRANGE, 0, MAKELPARAM(0,30000));
g_file_size=cl;
}
}
while ((len = get->bytes_available ()) > 0) {
if (len > 8192)
len = 8192;
len = get->get_bytes (buf, len);
if (len > 0) {
last_recv_time=GetTickCount();
DWORD dw;
WriteFile(hFile,buf,len,&dw,NULL);
sofar += len;
int time_sofar=(GetTickCount()-start_time)/1000;
int bps=sofar/(time_sofar?time_sofar:1);
int remain=MulDiv(time_sofar,cl,sofar) - time_sofar;
char *rtext=szSecond;
if (remain >= 60)
{
remain/=60;
rtext=szMinute;
if (remain >= 60)
{
remain/=60;
rtext=szHour;
}
}
wsprintf (buf,
szProgress,
sofar/1024,
MulDiv(100,sofar,cl),
cl/1024,
bps/1024,((bps*10)/1024)%10
);
if (remain) wsprintf(buf+lstrlen(buf),szRemaining,
remain,
rtext,
remain==1?"":szPlural
);
progress_callback(buf, sofar);
} else {
if (sofar < cl)
error = "Server aborted.";
break;
}
}
if (GetTickCount() > last_recv_time+g_timeout_ms)
{
error = "Downloading timed out.";
break;
}
} else {
error = "Bad response status.";
break;
}
}
}
WSACleanup();
}
CloseHandle(hFile);
if (g_parent)
{
if (g_dialog) DestroyWindow(g_dialog);
if (lpWndProcOld)
SetWindowLong(g_parent,GWL_WNDPROC,(long)lpWndProcOld);
if (g_childwnd)
{
if (hwndB) ShowWindow(hwndB,SW_SHOWNA);
if (hwndL) ShowWindow(hwndL,SW_SHOWNA);
}
if (wasen) EnableWindow(GetDlgItem(g_parent,IDCANCEL),0);
}
if (g_cancelled) {
setuservariable(INST_0, "cancel");
DeleteFile(filename);
} else if (error == NULL) {
setuservariable(INST_0, "success");
} else {
DeleteFile(filename);
setuservariable(INST_0, error);
}
delete get;
}
}
void HKWidgetLabel::SetText(MFString text)
{
this->text = text;
AdjustSize();
}
//////////////////
// Calculate size/positions for a row or column group This is the main
// algorithm. If a window is given, it's used to get the min/max size and
// desired size for TOFIT types.
//
void CWinMgr::CalcGroup(WINRECT* pGroup, CWnd* pWnd) {
// If this bombs, most likely the first entry in your map is not a group!
ASSERT(pGroup && pGroup->IsGroup());
ASSERT(pWnd);
// adjust total avail by margins
CRect rcTotal = pGroup->GetRect();
int w,h;
if (pGroup->GetMargins(w,h)) {
w = min(abs(w), rcTotal.Width()/2);
h = min(abs(h), rcTotal.Height()/2);
rcTotal.DeflateRect(w,h);
}
BOOL bRow = pGroup->IsRowGroup(); // Is this a row group?
// Running height or width: start with total
int hwRemaining = bRow ? rcTotal.Height() : rcTotal.Width();
// First, set all rects to their minimum sizes.
// This ensures that each rect gets its min size.
CWinGroupIterator it;
for (it=pGroup; it; it.Next()) {
WINRECT* wrc = it;
SIZEINFO szi;
OnGetSizeInfo(szi, wrc, pWnd);
int hwMin = bRow ? szi.szMin.cy : szi.szMin.cx;
hwMin = min(hwMin, hwRemaining); // truncate
wrc->SetHeightOrWidth(hwMin, bRow); // set
hwRemaining -= hwMin; // decrement remaining height/width
ASSERT(hwRemaining>=0);
}
// Now adjust all rects upward to desired size. Save REST rect for last.
WINRECT* pRestRect = NULL;
for (it=pGroup; it; it.Next()) {
WINRECT* wrc = it;
if (wrc->Type()==WRCT_REST) {
ASSERT(pRestRect==NULL); // can only be one REST rect!
pRestRect = wrc; // remember it
} else {
AdjustSize(wrc, bRow, hwRemaining, pWnd);
}
}
ASSERT(hwRemaining>=0);
// Adjust REST rect if any
if (pRestRect) {
AdjustSize(pRestRect, bRow, hwRemaining, pWnd);
ASSERT(hwRemaining==0);
}
// All the sizes of the entries have been calculated, including
// groups (but not their children). Now move all the rects so they're
// adjacent to one another, without altering sizes.
PositionRects(pGroup, rcTotal, bRow);
// Finally, descend recursively into each subgroup.
for (it=pGroup; it; it.Next()) {
WINRECT* wrc = it;
if (wrc->IsGroup())
CalcGroup(wrc, pWnd); // recurse!
}
}