void AtlasToolLevel::OnMouseMove(int x, int y)
{
if (!m_AnimViewer)
{
return;
}
int deltaX = x - m_MouseMovePos.X;
int deltaY = y - m_MouseMovePos.Y;
m_MouseMovePos.X = x;
m_MouseMovePos.Y = y;
if (ANIM_STATE_MOVE_ATLAS == m_State)
{
if (EMB_RIGHT == m_BtnId)
{
m_AnimViewer->SetPosition(core::position2df(m_AnimViewer->GetPosition().X + deltaX, m_AnimViewer->GetPosition().Y + deltaY));
}
else
{
RestoreState();
}
}
else if (ANIM_STATE_MOVE_FRAME == m_State)
{
if (EMB_LEFT == m_BtnId)
{
FrameDef frame;
if (m_AnimViewer->SetFrameOffset(m_AnimViewer->GetFrameOffset().X + deltaX / m_AnimViewer->GetScale().X,
m_AnimViewer->GetFrameOffset().Y + deltaY / m_AnimViewer->GetScale().Y, frame))
{
m_OnFrameUpdatedSignal(m_AnimViewer->GetCurrentFrame(), frame);
}
}
else
{
RestoreState();
}
}
else if (m_AnimViewer->CheckFrameViewCollision(x, y))
{
m_OnChangeCursorSignal(3); // Cursor hand
}
else
{
ChangeCursorByState(m_State);
}
}
//=======================================
void OpenGL::DrawText(char* text, glfont::GLFont& font, float x, float y, float color[3])
{
OpenGLState state = SaveState();
//glColor3f(color[0], color[1], color[2]);
// Set the text position
//glLoadIdentity();
//glRasterPos2f(x, y);
//glutBitmapString(GLUT_BITMAP_HELVETICA_18, reinterpret_cast<unsigned char *>(text));
glEnable(GL_TEXTURE_2D);
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glPushMatrix();
font.Begin();
font.DrawString(text, 0.003F, x, y, color, color);
glPopMatrix();
RestoreState(state);
}
//=======================================
void OpenGL::DrawImage(GLuint texture, float x, float y, float z)
{
OpenGLState state = SaveState();
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
glEnable(GL_TEXTURE_2D);
glLoadIdentity();
glBindTexture(GL_TEXTURE_2D, texture);
glPushMatrix();
glTranslatef(x, y, z); // position of texture.
glScalef( 0.1f, 0.1f, 0.1f );
glColor4f( 1.0f, 1.0f, 1.0f, 1.0f );
glNormal3f( 0.0f, 0.0f, 1.0f );
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 0.0f); glVertex2f(0.0f, 0.0f);
glTexCoord2f(0.0f, 1.0f); glVertex2f(0.0f, -1.0f);
glTexCoord2f(1.0f, 1.0f); glVertex2f(-1.0f, -1.0f);
glTexCoord2f(1.0f, 0.0f); glVertex2f(-1.0f, 0.0f);
glEnd();
glPopMatrix();
RestoreState(state);
}
void CLuaHandleSynced::RecvFromSynced(lua_State *srcState, int args)
{
SELECT_UNSYNCED_LUA_STATE();
#if ((LUA_MT_OPT & LUA_STATE) && (LUA_MT_OPT & LUA_MUTEX))
if (!SingleState() && srcState != L) { // Sim thread sends to unsynced --> delay it
DelayRecvFromSynced(srcState, args);
return;
}
// Draw thread, delayed already, execute it
#endif
static const LuaHashString cmdStr("RecvFromSynced");
//LUA_CALL_IN_CHECK(L); -- not valid here
if (!cmdStr.GetRegistryFunc(L))
return; // the call is not defined
lua_insert(L, 1); // place the function
// call the routine
SetAllowChanges(false);
SetHandleSynced(L, false);
lua_State* L_Prev = ForceUnsyncedState();
RunCallIn(cmdStr, args, 0);
RestoreState(L_Prev);
SetHandleSynced(L, true);
SetAllowChanges(true);
}
BOOL CCmdCalendarDate::DoIt(void)
{
m_BeforeState.m_fFrameInUse = SameFrame();
m_BeforeState.m_fGraphicInUse = SameGraphic();
UpdateOnPageState(&m_BeforeState);
return RestoreState(&m_AfterState);
}
void LFGGroupState::StopBoot()
{
m_bootVotes.clear();
m_bootVictim.Clear();
m_bootReason.clear();
m_bootCancelTime = 0;
RestoreState();
}
FX_BOOL CGdiPrinterDriver::StartDIBits(const CFX_DIBSource* pSource,
int bitmap_alpha,
FX_DWORD color,
const CFX_AffineMatrix* pMatrix,
FX_DWORD render_flags,
void*& handle,
int alpha_flag,
void* pIccTransform,
int blend_type) {
if (bitmap_alpha < 255 || pSource->HasAlpha() ||
(pSource->IsAlphaMask() && (pSource->GetBPP() != 1 || !m_bSupportROP))) {
return FALSE;
}
CFX_FloatRect unit_rect = pMatrix->GetUnitRect();
FX_RECT full_rect = unit_rect.GetOutterRect();
if (FXSYS_fabs(pMatrix->b) < 0.5f && pMatrix->a != 0 &&
FXSYS_fabs(pMatrix->c) < 0.5f && pMatrix->d != 0) {
FX_BOOL bFlipX = pMatrix->a < 0;
FX_BOOL bFlipY = pMatrix->d > 0;
return StretchDIBits(pSource, color,
bFlipX ? full_rect.right : full_rect.left,
bFlipY ? full_rect.bottom : full_rect.top,
bFlipX ? -full_rect.Width() : full_rect.Width(),
bFlipY ? -full_rect.Height() : full_rect.Height(),
NULL, 0, alpha_flag, pIccTransform, blend_type);
}
if (FXSYS_fabs(pMatrix->a) < 0.5f && FXSYS_fabs(pMatrix->d) < 0.5f) {
CFX_DIBitmap* pTransformed =
pSource->SwapXY(pMatrix->c > 0, pMatrix->b < 0);
if (pTransformed == NULL) {
return FALSE;
}
FX_BOOL ret = StretchDIBits(
pTransformed, color, full_rect.left, full_rect.top, full_rect.Width(),
full_rect.Height(), NULL, 0, alpha_flag, pIccTransform, blend_type);
delete pTransformed;
return ret;
}
if (pSource->GetBPP() == 1) {
CFX_DIBitmap* pTransformed = Transform1bppBitmap(pSource, pMatrix);
if (pIccTransform == NULL) {
return FALSE;
}
SaveState();
CFX_PathData path;
path.AppendRect(0, 0, 1.0f, 1.0f);
SetClip_PathFill(&path, pMatrix, WINDING);
FX_BOOL ret = StretchDIBits(
pTransformed, color, full_rect.left, full_rect.top, full_rect.Width(),
full_rect.Height(), NULL, 0, alpha_flag, pIccTransform, blend_type);
RestoreState();
delete pTransformed;
handle = NULL;
return ret;
}
return FALSE;
}
/* Constructor */
CDlgItemProperties::CDlgItemProperties(wxWindow* parent) :
wxDialog( parent, ID_ANYDIALOG, wxEmptyString, wxDefaultPosition,
wxSize( 503,480 ), wxDEFAULT_DIALOG_STYLE|wxRESIZE_BORDER ) {
CBOINCBaseFrame* pFrame = wxGetApp().GetFrame();
wxASSERT(pFrame);
if (!pFrame) return;
SetSizeHints( wxDefaultSize, wxDefaultSize );
SetExtraStyle( GetExtraStyle() | wxWS_EX_VALIDATE_RECURSIVELY );
m_bSizer1 = new wxBoxSizer( wxVERTICAL );
m_scrolledWindow = new wxScrolledWindow( this, wxID_ANY, wxDefaultPosition, wxDefaultSize, wxHSCROLL|wxVSCROLL );
m_scrolledWindow->SetScrollRate( 5, 5 );
wxBoxSizer* m_bSizer2;
m_bSizer2 = new wxBoxSizer( wxVERTICAL );
m_gbSizer = new wxGridBagSizer( 0, 0 );
m_gbSizer->SetCols(2);
m_gbSizer->AddGrowableCol( 1 );
m_gbSizer->SetFlexibleDirection( wxBOTH );
m_gbSizer->SetNonFlexibleGrowMode( wxFLEX_GROWMODE_SPECIFIED );
m_bSizer2->Add( m_gbSizer, 1, wxEXPAND, 5 );
m_scrolledWindow->SetSizer( m_bSizer2 );
m_scrolledWindow->Layout();
m_bSizer2->Fit( m_scrolledWindow );
m_bSizer1->Add( m_scrolledWindow, 1, wxEXPAND | wxALL, 5 );
m_btnClose = new wxButton( this, wxID_OK, _("&Close"), wxDefaultPosition, wxDefaultSize, 0 );
m_btnClose->SetDefault();
m_bSizer1->Add( m_btnClose, 0, wxALIGN_BOTTOM|wxALIGN_CENTER_HORIZONTAL|wxALL, 5 );
SetSizer( m_bSizer1 );
Layout();
Centre( wxBOTH );
m_current_row=0;
int currentTabView = pFrame->GetCurrentViewPage();
switch(currentTabView) {
case VW_PROJ:
m_strBaseConfigLocation = wxString(wxT("/DlgProjectProperties/"));
break;
case VW_TASK:
m_strBaseConfigLocation = wxString(wxT("/DlgTaskProperties/"));
break;
default:
m_strBaseConfigLocation = wxString(wxT("/DlgProperties/"));
break;
}
RestoreState();
}
void EditablePagedLevel::OnMouseUp( int btn, int x, int y )
{
//int deltaX = x - m_MouseEvtPos.X;
//int deltaY = y - m_MouseEvtPos.Y;
if (EMB_LEFT == btn && LEVEL_STATE_MOVE_OBJECT == m_State)
{
RestoreState();
m_SelectedObject.reset();
}
else if (EMB_RIGHT == btn)
{
RestoreState();
}
m_MouseEvtPos.X = x;
m_MouseEvtPos.Y = y;
m_BtnId = EMB_NONE;
}
//=======================================
// Draws the overlay to screen
void OpenGL::Render()
{
OpenGLState state = SaveState();
// Draw our scene
//DrawScene();
draw_event_.Invoke();
RestoreState(state);
}
wxHtmlParser::~wxHtmlParser()
{
while (RestoreState()) {}
DestroyDOMTree();
WX_CLEAR_ARRAY(m_HandlersStack);
WX_CLEAR_HASH_SET(wxHtmlTagHandlersSet, m_HandlersSet);
delete m_entitiesParser;
delete m_Source;
}
HRESULT _stdcall CMyTreeView::DragLeave(void)
{
RestoreState();
KillTimer(m_hTreeView,DRAGEXPAND_TIMER_ID);
m_pDropTargetHelper->DragLeave();
return S_OK;
}
FX_BOOL CFX_QuartzDeviceDriver::DrawPath(const CFX_PathData* pathData,
const CFX_AffineMatrix* matrix,
const CFX_GraphStateData* graphState,
FX_DWORD fillArgb,
FX_DWORD strokeArgb,
int fillMode,
int alpha_flag,
void* pIccTransform,
int blend_type
)
{
SaveState();
CGBlendMode mode = GetCGBlendMode(blend_type);
if (mode != kCGBlendModeNormal) {
CGContextSetBlendMode(_context, mode);
}
CGAffineTransform m = CGAffineTransformIdentity;
if (matrix) {
m = CGAffineTransformMake(matrix->GetA(), matrix->GetB(), matrix->GetC(), matrix->GetD(), matrix->GetE(), matrix->GetF());
}
m = CGAffineTransformConcat(m, _foxitDevice2User);
CGContextConcatCTM(_context, m);
int pathMode = 0;
if (graphState && strokeArgb) {
CGContextSetMiterLimit(_context, graphState->m_MiterLimit);
FX_FLOAT lineWidth = getLineWidth(graphState, m);
setStrokeInfo(graphState, strokeArgb, lineWidth);
pathMode |= 4;
}
if (fillMode && fillArgb) {
setFillInfo(fillArgb);
if ((fillMode & 3) == FXFILL_WINDING) {
pathMode |= 1;
} else if ((fillMode & 3) == FXFILL_ALTERNATE) {
pathMode |= 2;
}
}
setPathToContext(pathData);
if (fillMode & FXFILL_FULLCOVER) {
CGContextSetShouldAntialias(_context, false);
}
if (pathMode == 4) {
CGContextStrokePath(_context);
} else if (pathMode == 1) {
CGContextFillPath(_context);
} else if (pathMode == 2) {
CGContextEOFillPath(_context);
} else if (pathMode == 5) {
CGContextDrawPath(_context, kCGPathFillStroke);
} else if (pathMode == 6) {
CGContextDrawPath(_context, kCGPathEOFillStroke);
}
RestoreState(FALSE);
return TRUE;
}
//*************************************************************************************
void CBCGPFullScreenImpl::ShowFullScreen()
{
if (!m_bFullScreen)
{
ShowFullScreen (m_pImpl->m_pFrame);
}
else
{
RestoreState (m_pImpl->m_pFrame);
}
}
BOOL CPaletteBar::Reset(WPARAM /*wParam*/, LPARAM /*lParam*/, LRESULT* pLResult)
{
TRACE(_T("TBN_RESET\n"));
// User has pressed the reset button
// restore the state of the toolbar to the state it was before customization
RestoreState(HKEY_CURRENT_USER,_T("Software\\Microsoft\\VC70\\Samples\\CtrlDemo"),_T("Palette Tool Bar"));
*pLResult = TRUE;
return TRUE;
}
void OculusRiftView::Draw()
{
// if not initilized assume a reset has occured and device is still valid
if(!initialized)
Init(device);
SaveState();
SetState();
device->SetFVF(D3DFVF_TEXVERTEX);
if(!swap_eyes)
{
device->SetTexture(0, leftTexture);
device->SetTexture(1, rightTexture);
}
else
{
device->SetTexture(0, rightTexture);
device->SetTexture(1, leftTexture);
}
device->SetRenderTarget(0, screenSurface);
device->SetStreamSource(0, screenVertexBuffer, 0, sizeof(TEXVERTEX));
UINT iPass, cPasses;
viewEffect->SetTechnique("ViewShader");
///// difference from StereoView::
viewEffect->SetFloatArray("LensCenter", LensCenter,2);
viewEffect->SetFloatArray("LensShift", LensShift,2);
viewEffect->SetFloatArray("ScreenCenter", ScreenCenter,2);
viewEffect->SetFloatArray("Scale", Scale,2);
viewEffect->SetFloatArray("ScaleIn", ScaleIn,2);
viewEffect->SetFloatArray("HmdWarpParam", HmdWarpParam,4);
/////
viewEffect->Begin(&cPasses, 0);
for(iPass = 0; iPass < cPasses; iPass++)
{
viewEffect->BeginPass(iPass);
device->DrawPrimitive(D3DPT_TRIANGLEFAN, 0, 2);
viewEffect->EndPass();
}
viewEffect->End();
device->StretchRect(screenSurface, NULL, backBuffer, NULL, D3DTEXF_NONE);
RestoreState();
}
void CPrinterDC::DeleteDC(void)
{
// First delete any selected resources.
Cleanup();
// Restore DC to inital settings.
RestoreState(m_iState);
// Finally free up the HDC.
::DeleteDC(m_hDC);
m_hDC = NULL;
}
void EditablePagedLevel::OnMouseMove( int x, int y )
{
#ifdef USE_INVOKER
if (NeedInvoke())
{
BeginInvoke(std::bind(&EditablePagedLevel::OnMouseMove, this, x, y));
}
else
#endif
{
int deltaX = x - m_MouseMovePos.X;
int deltaY = y - m_MouseMovePos.Y;
m_MouseMovePos.X = x;
m_MouseMovePos.Y = y;
if (LEVEL_STATE_MOVE_OBJECT == m_State)
{
if (EMB_LEFT == m_BtnId && m_SelectedObject)
{
m_SelectedObject->SetPosition(m_SelectedObject->GetPosition() + core::position2df((float)deltaX, (float)deltaY));
}
else
{
RestoreState();
m_SelectedObject.reset();
}
}
else if (LEVEL_STATE_MOVE_LEVEL == m_State)
{
if (EMB_RIGHT == m_BtnId)
{
Scroll((float)deltaX, (float)deltaY);
}
else
{
RestoreState();
}
}
}
}
void wxGLAPI::glEnd()
{
#if wxUSE_OPENGL_EMULATION
bool formerColors = SetState( GL_COLOR_ARRAY, s_colorsUsed );
bool formerNormals = SetState( GL_NORMAL_ARRAY, s_normalsUsed );
bool formerTexCoords = SetState( GL_TEXTURE_COORD_ARRAY, s_texCoordsUsed );
bool formerVertex = glIsEnabled(GL_VERTEX_ARRAY);
if( !formerVertex )
glEnableClientState(GL_VERTEX_ARRAY);
if ( s_colorsUsed )
glColorPointer( 4, GL_FLOAT, 0, &s_colors[0] );
if ( s_normalsUsed )
glNormalPointer( GL_FLOAT, 0, &s_normals[0] );
if ( s_texCoordsUsed )
glTexCoordPointer( 2, GL_FLOAT, 0, &s_texCoords[0] );
glVertexPointer(3, GL_FLOAT, 0, &s_vertices[0]);
glDrawArrays( s_mode, 0, s_vertices.size() / 3 );
if ( s_colorsUsed != formerColors )
RestoreState( GL_COLOR_ARRAY, formerColors );
if ( s_normalsUsed != formerNormals )
RestoreState( GL_NORMAL_ARRAY, formerColors );
if ( s_texCoordsUsed != formerTexCoords )
RestoreState( GL_TEXTURE_COORD_ARRAY, formerColors );
if( !formerVertex )
glDisableClientState(GL_VERTEX_ARRAY);
s_mode = 0xFF;
#else
::glEnd();
#endif
}
void TaskToolbar::SetOrientation(bool horizontal)
{
if (horizontal_ == horizontal)
return;
CWnd* parent= GetParent();
int id= GetDlgCtrlID();
DestroyWindow();
Create(parent, id, !horizontal);
horizontal_ = horizontal;
RestoreState(REGISTRY_SECTION_TOOLBAR, horizontal ? REG_STATE : REG_STATE_VERT);
}
void CDPR::RestoreStateF(char * fn)
{
FILE * ff;
ff = fopen(fn,"rb");
if (ff)
{
RestoreState(ff);
fclose(ff);
printf("%%DPR-I-RESTST: DPR state restored from %s\n",fn);
}
else
{
printf("%%DPR-F-NOREST: DPR could not be restored from %s\n",fn);
}
}
uint64 AllocNewProcessStack(L4_TABLE* l4t, uint64 entryPoint) {
BackUpState();
uint64 firstPage;
Offsets* off = (Offsets*) malloc(sizeof(Offsets));
int i, j;
for (i = 11; i < 15 ; i++) {
for (j = 0; j < 512; j++) {
off->L4 = 0;
off->L3 = 0;
off->L2 = i;
off->L1 = j;
//first page will be the last one added
firstPage = AddPage(l4t, off, 1, 1);
}
}
uint64_t addr = firstPage + PAGE_SIZE - sizeof(stack_frame);
stack_frame* frame = (stack_frame*)addr;
frame->gs = 0x001;
frame->fs = 0x002;
frame->r15 = 0x003;
frame->r14 = 0x004;
frame->r13 = 0x005;
frame->r12 = 0x006;
frame->r11 = 0x007;
frame->r10 = 0x008;
frame->r9 = 0x009;
frame->r8 = 0x00A;
frame->rsi = 0x00B;
frame->rdi = 0x00C;
frame->rbp = 0x00D;
frame->rdx = 0x00E;
frame->rcx = 0x00F;
frame->rbx = 0x010;
frame->rax = 0x011;
frame->rip = (uint64)entryPoint;
frame->cs = 0x008;
frame->eflags = 0x202;
frame->rsp = (30 * 0x100000);
frame->ss = 0x000;
frame->base = 0x000;
RestoreState();
return (30 * 0x100000) - sizeof(frame);
}
void CViewTransfers::DemandLoadView() {
wxASSERT(!m_bViewLoaded);
CTaskViewBase::DemandLoadView(ID_TASK_TRANSFERSVIEW, DEFAULT_TASK_FLAGS,
ID_LIST_TRANSFERSVIEW, DEFAULT_LIST_MULTI_SEL_FLAGS);
CTaskItemGroup* pGroup = NULL;
CTaskItem* pItem = NULL;
wxASSERT(m_pTaskPane);
wxASSERT(m_pListPane);
// Setup View
pGroup = new CTaskItemGroup(_("Commands"));
m_TaskGroups.push_back(pGroup);
pItem = new CTaskItem(_("Retry Now"), _("Click 'Retry now' to transfer the file now"),
ID_TASK_TRANSFERS_RETRYNOW);
pGroup->m_Tasks.push_back(pItem);
pItem = new CTaskItem(_("Abort Transfer"),
_("Click 'Abort transfer' to delete the file from the transfer queue. "
"This will prevent you from being granted credit for this result."),
ID_TASK_TRANSFERS_ABORT);
pGroup->m_Tasks.push_back(pItem);
// Create Task Pane Items
m_pTaskPane->UpdateControls();
// Create List Pane Items
AddColumn(COLUMN_PROJECT, _T("Project"), wxLIST_FORMAT_LEFT, 125);
AddColumn(COLUMN_FILE, _T("File"), wxLIST_FORMAT_LEFT, 205);
AddColumn(COLUMN_PROGRESS, _T("Progress"), wxLIST_FORMAT_CENTRE, 60);
AddColumn(COLUMN_SIZE, _T("Size"), wxLIST_FORMAT_LEFT, 80);
AddColumn(COLUMN_TIME, _T("Elapsed Time"), wxLIST_FORMAT_LEFT, 80);
AddColumn(COLUMN_SPEED, _T("Speed"), wxLIST_FORMAT_LEFT, 80);
AddColumn(COLUMN_STATUS, _T("Status"), wxLIST_FORMAT_LEFT, 150);
m_iProgressColumn = COLUMN_PROGRESS;
// Needed by static sort routine;
MyCViewTransfers = this;
m_funcSortCompare = CompareViewTransferItems;
RestoreState();
UpdateSelection();
}
void FreeL4(L4_TABLE* l4t){
BackUpState();
int i;
for(i=0; i < 512; i++){
L4_ENTRY entry = l4t->table[i];
if(entry.p != 0){
entry.p = 0;
FreeL3((L3_TABLE*)(entry.addr * PAGE_SIZE));
}
}
free((void*)l4t);
RestoreState();
}
bool TaskToolbar::Create(CWnd* parent, UINT id, UINT rebar_band_id, bool vertical)
{
rebar_band_id_ = rebar_band_id;
bool ok= false;
if (Create(parent, id, vertical))
{
horizontal_ = !vertical;
RestoreState(REGISTRY_SECTION_TOOLBAR, vertical ? REG_STATE_VERT : REG_STATE);
ok = true;
}
return ok;
}
bool ViewerToolBar::Create(CWnd* parent, UINT id)
{
// rebar_band_id_ = rebar_band_id;
small_icons_ = AfxGetApp()->GetProfileInt(REGISTRY_SECTION_TOOLBAR, REG_ICONS, 0) == 0;
int bmp_id= small_icons_ ? IDB_VIEWER_TOOLBAR : IDB_VIEWER_TOOLBAR_BIG;
Derived::Params p;
if (small_icons_)
p.arrow_down_img_id = IDR_ARROW_DOWN_IMG;
else
p.arrow_down_img_id = IDR_ARROW_DOWN_IMG;
if (!Derived::Create(parent, tb_buttons, commands, bmp_id, &p))
return false;
SetOnIdleUpdateState(true);
CSize s= Derived::Size();
SetWindowPos(0, 0, 0, s.cx, s.cy, SWP_NOZORDER | SWP_NOACTIVATE);
SetDlgCtrlID(id);
//SetPadding(4, 4);
//if (IsWhistlerLookAvailable())
// SetPadding(0, -2); // btn with down arrow section inflates total buttons height
//if (!Derived::Create(tb_buttons, commands, bmp_id, 0, parent, id))
// return false;
//// img list for disabled images
//CreateDisabledImageList(bmp_id, saturation, lightness);
//ModifyStyle(0, CCS_ADJUSTABLE);
RestoreState(REGISTRY_SECTION_TOOLBAR, REG_STATE);
CRect rect;
GetWindowRect(rect);
SetWindowPos(0, 0, 0, rect.Width() + 8, rect.Height(), SWP_NOZORDER | SWP_NOACTIVATE | SWP_NOMOVE);
return true;
}
// JCS, There may be a more efficient method but I can't find it
// because using the DoFinal/DoUpdate functions directly calls
// Store/Restore at inappropriate times and scribbles over stored
// data
// This is the only way I've found to both generate a hash value
// and get this in the correctly updated state
EXPORT_C TPtrC8 CHMAC::Hash(const TDesC8& aMessage)
{
TPtrC8 ptr(KNullDesC8());
TPtrC8 finalPtr(KNullDesC8());
StoreState();
if (iDigest)
{
ptr.Set(iDigest->Final(aMessage));
iDigest->Update(iOuterPad);
finalPtr.Set(iDigest->Final(ptr));
}
RestoreState();
iDigest->Update(aMessage);
return (finalPtr);
}
wx28HtmlParser::~wx28HtmlParser()
{
while (RestoreState()) {}
DestroyDOMTree();
if (m_HandlersStack)
{
wxList& tmp = *m_HandlersStack;
wxList::iterator it, en;
for( it = tmp.begin(), en = tmp.end(); it != en; ++it )
delete (wxHashTable*)*it;
tmp.clear();
}
delete m_HandlersStack;
m_HandlersHash.Clear();
WX_CLEAR_LIST(wxList, m_HandlersList);
delete m_entitiesParser;
}
wxHtmlParser::~wxHtmlParser()
{
#if defined(__INTEL_COMPILER) && 1 /* VDM auto patch */
# pragma ivdep
# pragma swp
# pragma unroll
# pragma prefetch
# if 0
# pragma simd noassert
# endif
#endif /* VDM auto patch */
while (RestoreState()) {}
DestroyDOMTree();
WX_CLEAR_ARRAY(m_HandlersStack);
WX_CLEAR_HASH_SET(wxHtmlTagHandlersSet, m_HandlersSet);
delete m_entitiesParser;
delete m_Source;
}
CPWL_Wnd* CFFL_ListBox::ResetPDFWindow(CPDFSDK_PageView* pPageView,
FX_BOOL bRestoreValue) {
if (bRestoreValue)
SaveState(pPageView);
DestroyPDFWindow(pPageView);
CPWL_Wnd* pRet = NULL;
if (bRestoreValue) {
RestoreState(pPageView);
pRet = GetPDFWindow(pPageView, FALSE);
} else
pRet = GetPDFWindow(pPageView, TRUE);
m_pWidget->UpdateField();
return pRet;
}
