bool EDA_Printout::OnPrintPage(int page)
/***************************************/
{
wxString msg;
msg.Printf(_("Print page %d"), page);
m_Parent->Affiche_Message(msg);
#ifdef EESCHEMA
int ii;
BASE_SCREEN * screen = m_Parent->m_CurrentScreen;
BASE_SCREEN *oldscreen = screen;
if( s_OptionPrintPage == 1 )
{
for ( ii = 1, screen = ScreenSch; ; ii++)
{
if ( ii == page ) break;
screen = (BASE_SCREEN *) screen->Pnext;
}
}
if (screen == NULL) return FALSE;
ActiveScreen = (SCH_SCREEN*) screen;
DrawPage();
ActiveScreen = (SCH_SCREEN*) oldscreen;
#endif
#ifdef PCBNEW
if ( (m_Parent->m_Ident == PCB_FRAME) || (m_Parent->m_Ident == GERBER_FRAME) )
{
if ( s_OptionPrintPage == 0 )
{
// compute layer mask from page number
m_PrintFrame->SetLayerMaskFromListSelection();
int ii, jj, mask = 1;
for ( ii = 0, jj = 0; ii < NB_LAYERS; ii++)
{
if ( s_PrintMaskLayer & mask ) jj++;
if ( jj == page )
{
s_PrintMaskLayer = mask;
break;
}
mask <<= 1;
}
if ( ii == NB_LAYERS ) return FALSE;
}
}
DrawPage();
#endif
return TRUE;
}
OSStatus DoPrintLoop(PrintingLogicPtr printJob)
{
OSStatus status = noErr;
GrafPtr currPort;
// Save the current QD grafport.
GetPort(&currPort);
// Get the current graphics context, in this case a Quickdraw grafPort,
// for drawing the page.
status = printJob->thePrPort == NULL ? -3 : noErr;
if (status == noErr) {
// Set the printing port before drawing the page.
SetPort((GrafPtr) printJob->thePrPort);
// Draw the page.
status = DrawPage(printJob);
// Restore the QD grafport.
SetPort(currPort);
}
return status;
} // DoPrintLoop
bool SCH_PRINTOUT::OnPrintPage( int page )
{
SCH_SHEET_LIST sheetList( g_RootSheet );
wxCHECK_MSG( page >= 1 && page <= (int)sheetList.size(), false,
wxT( "Cannot print invalid page number." ) );
wxCHECK_MSG( sheetList[ page - 1].LastScreen() != NULL, false,
wxT( "Cannot print page with NULL screen." ) );
wxString msg;
msg.Printf( _( "Print page %d" ), page );
m_parent->ClearMsgPanel();
m_parent->AppendMsgPanel( msg, wxEmptyString, CYAN );
SCH_SCREEN* screen = m_parent->GetScreen();
SCH_SHEET_PATH oldsheetpath = m_parent->GetCurrentSheet();
m_parent->SetCurrentSheet( sheetList[ page - 1 ] );
m_parent->GetCurrentSheet().UpdateAllScreenReferences();
m_parent->SetSheetNumberAndCount();
screen = m_parent->GetCurrentSheet().LastScreen();
DrawPage( screen );
m_parent->SetCurrentSheet( oldsheetpath );
m_parent->GetCurrentSheet().UpdateAllScreenReferences();
m_parent->SetSheetNumberAndCount();
return true;
}
bool BOARD_PRINTOUT_CONTROLLER::OnPrintPage( int aPage )
{
LSET lset = m_PrintParams.m_PrintMaskLayer;
// compute layer mask from page number if we want one page per layer
if( m_PrintParams.m_OptionPrintPage == 0 ) // One page per layer
{
// This sequence is TBD, call a different
// sequencer if needed, such as Seq(). Could not find documentation on
// page order.
LSEQ seq = lset.UIOrder();
// aPage starts at 1, not 0
if( unsigned( aPage-1 ) < seq.size() )
m_PrintParams.m_PrintMaskLayer = LSET( seq[aPage-1] );
}
if( !m_PrintParams.m_PrintMaskLayer.any() )
return false;
// In Pcbnew we can want the layer EDGE always printed
if( m_PrintParams.m_Flags == 1 )
m_PrintParams.m_PrintMaskLayer.set( Edge_Cuts );
DrawPage();
m_PrintParams.m_PrintMaskLayer = lset;
return true;
}
void main(void)
{
while ( ++num_items < MAX_PAGES ) selection_mem[num_items] = 0;
while ( !IS_PLAYER_SCRIPT_CONTROL_ON(GetPlayerIndex()) ) WAIT(1000);
//TERMINATE_ALL_SCRIPTS_WITH_THIS_NAME("modmanager");
while ( TRUE )
{
WAIT(0);
SET_SLEEP_MODE_ACTIVE(TRUE);
PRINT_MAIN_LOGO("GTA IV Mission Mod Pack v2.0", 0.30, 0.05);
PRINT_DESC(0.28, 0.11, "Created by rodd1981 (c) www.facebook.com/gtamodz");
MenuSetup();
if (page != page_check )
{
SetupPage();
}
DrawPage();
Nav();
/*
if (IS_GAME_KEYBOARD_KEY_JUST_PRESSED(KEY_F11))
{
TERMINATE_THIS_SCRIPT();
}
*/
}
}
void Redraw()
{
XClearWindow(disp, win);
MarkMargins();
DrawPage(GetCurrentPage());
}
// set and display next in list codepage
void
BF_GUI_Text::NextCodePage()
{
iCodePage = (iCodePage < CP_KOI) ? iCodePage + 1 : CP_UTF8;
poStatus->SetCodePage(iCodePage);
ClearView();
DrawPage();
};
void
BF_GUI_Text::Find(char *pc_Sample, uint32 i_StartLine, uint32 i_StartCol)
{
uint32 iColumn = i_StartCol;
BString *poString;
char cSample[256];
bool bFound = false;
BF_GUI_MessageBox *po_Message;
ClearMatch();
if (pc_Sample == NULL)
{
FromUtf8(poMatch->String(),cSample);
}
else
{
FromUtf8(pc_Sample,cSample);
}
for(int32 i = i_StartLine; i < ploString->CountItems();i++)
{
poString = (BString *) ploString->ItemAt(i);
if (poString->FindFirst(cSample,iColumn) != B_ERROR)
{
iMatchLine = i;
bFound = true;
break;
};
iColumn = 0;
};
if (bFound)
{
if (pc_Sample != NULL)
{
if (poMatch != NULL) delete(poMatch);
poMatch = new BString(pc_Sample);
};
bDrawSel = true;
BRect oRect = Bounds();
float y = iMatchLine * poSysSetup->oFontNode.fHeight;
ScrollTo(oRect.left,y);
iStartSel = iColumn;
DrawPage();
}
else
{
bDrawSel = false;
if (i_StartLine)
{
po_Message = new BF_GUI_MessageBox(BRect(30,30,300,150),"Error","Not more samles found!",Parent(),"Ok");
}
else
{
po_Message = new BF_GUI_MessageBox(BRect(30,30,300,150),"Error","The sample is not found in this file!",Parent(),"Ok");
}
Parent()->AddChild(po_Message);
};
};
bool BOARD_PRINTOUT_CONTROLLER::OnPrintPage( int aPage )
{
// in gerbview, draw layers are always printed on separate pages
// because handling negative objects when using only one page is tricky
m_PrintParams.m_Flags = aPage;
DrawPage();
return true;
}
void
BF_GUI_Text::ClearMatch( void )
{
if(bDrawSel)
{
bDrawSel = false;
ClearView();
DrawPage();
};
}
void Window_UseSkillBase::DrawContentBase() const{
DrawDollsWithIcon(CAMPDOLL_GAUGE_TYPE_HP_AND_TP);
switch(phaze){
case WND_USESKILL_PHAZE_SKILLSELECT:
useSkillManager.DrawList(
frameArea.x + contentArea.x + 320,
frameArea.y + contentArea.y + 80,
presetColorIndex);
useSkillManager.DrawListFocus(
frameArea.x + contentArea.x + 320,
frameArea.y + contentArea.y + 80,
pSkin, activeCount, false);
break;
case WND_USESKILL_PHAZE_TARGETSELECT:
useSkillManager.DrawList(
frameArea.x + contentArea.x + 320,
frameArea.y + contentArea.y + 80,
presetColorIndex);
useSkillManager.DrawListFocus(
frameArea.x + contentArea.x + 320,
frameArea.y + contentArea.y + 80,
pSkin, activeCount, true);
switch(useSkillManager.GetCntSkillID()){
case ASKILL_REPAIR:
case ASKILL_RESTART:
case ASKILL_TUNING:
case ASKILL_ENCHANT:
case SKILL_REPAIR:
case SKILL_FASTREPAIR:
case SKILL_HEAL:
DrawFocusForDollsIcon(activeCount,
s_doll.index, false);
break;
case SKILL_WIDEREPAIR:
case SKILL_WIDEHEAL:
for(int n=0; n<MAX_BATTLEDOLL; n++){
if(GetDollIsEnabled(n)){
DrawFocusForDollsIcon(activeCount,
n, false);
}
}
break;
}
break;
case WND_USESKILL_PHAZE_SHOWINFO:
break;
}
useSkillManager.DrawCntSkillAccount(
frameArea.x + contentArea.x + 320,
frameArea.y + contentArea.y + 420,
GetPresetColor(presetColorIndex, COLORSET_COLOR_NORMAL));
// ページ数の描画
DrawPage();
}
/***********************************************************************
OnNextPage : public
desc : 다음 페이지 넘기기 버튼을 눌렀을 때
arg : none
ret : none
************************************************************************/
void ZMonsterBookInterface::OnNextPage( void)
{
// 보여줄 페이지 번호를 구한다
if ( m_nCurrentPageNum == m_nTotalPageNum)
m_nCurrentPageNum = 0;
else
m_nCurrentPageNum++;
// 페이지를 그린다
DrawPage();
}
/***********************************************************************
OnPrevPage : public
desc : 이전 페이지 넘기기 버튼을 눌렀을 때
arg : none
ret : none
************************************************************************/
void ZMonsterBookInterface::OnPrevPage( void)
{
// 보여줄 페이지 번호를 구한다
if ( m_nCurrentPageNum == 0)
m_nCurrentPageNum = m_nTotalPageNum;
else
m_nCurrentPageNum--;
// 페이지를 그린다
DrawPage();
}
void CBatmonContainer::Draw(const TRect& aRect) const
{
CWindowGc& gc=SystemGc();
gc.SetPenColor(TRgb::Color4K(0x048));
gc.SetPenStyle(CGraphicsContext::ESolidPen);
gc.SetBrushColor(TRgb::Color4K(0x000));
gc.SetBrushStyle(CGraphicsContext::ESolidBrush);
TRect rect=Rect();
gc.DrawRect(rect);
DrawTitle();
DrawStatus();
DrawExitMark();
DrawPage();
}
bool BOARD_PRINTOUT_CONTROLLER::OnPrintPage( int aPage )
{
#ifdef PCBNEW
LAYER_NUM layers_count = NB_PCB_LAYERS;
#else
LAYER_NUM layers_count = NB_LAYERS;
#endif
LAYER_MSK mask_layer = m_PrintParams.m_PrintMaskLayer;
// compute layer mask from page number if we want one page per layer
if( m_PrintParams.m_OptionPrintPage == 0 ) // One page per layer
{
int jj;
LAYER_NUM ii;
for( ii = FIRST_LAYER, jj = 0; ii < layers_count; ++ii )
{
LAYER_MSK mask = GetLayerMask( ii );
if( mask_layer & mask )
jj++;
if( jj == aPage )
{
m_PrintParams.m_PrintMaskLayer = mask;
break;
}
}
}
if( m_PrintParams.m_PrintMaskLayer == 0 )
return false;
#ifdef PCBNEW
// In Pcbnew we can want the layer EDGE always printed
if( m_PrintParams.m_Flags == 1 )
m_PrintParams.m_PrintMaskLayer |= EDGE_LAYER;
#endif
DrawPage();
m_PrintParams.m_PrintMaskLayer = mask_layer;
return true;
}
//---------------------------------------------------------------------------
// 印刷の実行
int __fastcall TPrintDlgBox::Execute(void)
{
if( (!mColCount) || (!mRowCount) ) return FALSE;
int r = FALSE;
if( PrintDialog->Execute() == TRUE ){
TForm *pActive = Screen->ActiveForm;
if( pActive != NULL ) pActive->Enabled = FALSE;
mAbort = 0;
CWaitCursor tw;
Printer()->Title = "MMANA";
Printer()->BeginDoc();
Printer()->Canvas->Font->Name = "ＭＳ ゴシック";
mRC = Printer()->Canvas->ClipRect;
if( InitSetup(Printer()->Canvas) == FALSE ){
mAbort = 1;
}
tw.Delete();
if( !mAbort ){
Show();
for( mPage = 0; mPage < mPageMax; mPage++ ){ // 印刷ループ
if( mPage ) Printer()->NewPage();
DispPageStat();
Application->ProcessMessages();
if( mAbort ) break;
DrawRect();
Application->ProcessMessages();
if( mAbort ) break;
DrawPage();
Application->ProcessMessages();
if( mAbort ) break;
}
}
tw.Wait();
if( mAbort ){
Printer()->Abort();
}
else {
Printer()->EndDoc();
r = TRUE;
}
if( pActive != NULL ) pActive->Enabled = TRUE;
Visible = FALSE;
}
return r;
}
/*------------------------------------------------------------------------------
Function:
DoPrintLoop
Parameters:
Description:
DoPrintLoop calculates which pages to print and executes the print
loop, calling DrawPage for each page.
------------------------------------------------------------------------------*/
OSStatus DoPrintLoop(PrintingLogicPtr printJob)
{
OSStatus status = noErr, tempErr;
CGContextRef printingContext;
// Note, we don't have to worry about the number of copies. The printing
// manager handles this. So we just iterate through the document from the
// first page to be printed, to the last.
// Note, we don't have to deal with the classic Printing Manager's
// 128-page boundary limit.
// Set up a page for printing. Under the classic Printing Manager, applications
// could provide a page rect different from the one in the print record to achieve
// scaling. This is no longer recommended and on Mac OS X, the PageRect argument
// is ignored.
// Now you are ready to request the printing context
status = PMSessionGetGraphicsContext (printJob->printSession,
kPMGraphicsContextCoreGraphics, (void **) &printingContext);
if (status == noErr) {
// Draw the page.
status = DrawPage(printJob,printingContext);
}
// Only report a printing error once we have completed the print loop. This
// ensures that every PMBeginXXX call that returns no error is followed by
// a matching PMEndXXX call, so the Printing Manager can release all temporary
// memory and close properly.
tempErr = PMSessionError(printJob->printSession);
if(status == noErr)
status = tempErr;
if (status == kPMCancel)
status = noErr;
return status;
} // DoPrintLoop
bool BOARD_PRINTOUT_CONTROLER::OnPrintPage( int page )
{
int layers_count = NB_LAYERS;
if( m_Parent->IsType( GERBER_FRAME ) )
layers_count = 32;
int mask_layer = m_PrintParams.m_PrintMaskLayer;
// compute layer mask from page number if we want one page per layer
if( m_PrintParams.m_OptionPrintPage == 0 ) // One page per layer
{
int ii, jj, mask = 1;
for( ii = 0, jj = 0; ii < layers_count; ii++ )
{
if( mask_layer & mask )
jj++;
if( jj == page )
{
m_PrintParams.m_PrintMaskLayer = mask;
break;
}
mask <<= 1;
}
}
if( m_PrintParams.m_PrintMaskLayer == 0 )
return false;
// In Pcbnew we can want the layer EDGE always printed
if( m_PrintParams.m_Flags == 1 )
m_PrintParams.m_PrintMaskLayer |= EDGE_LAYER;
DrawPage();
m_PrintParams.m_PrintMaskLayer = mask_layer;
return true;
}
/***********************************************************************
OnCreate : public
desc : 몬스터 도감 보이기
arg : none
ret : none
************************************************************************/
void ZMonsterBookInterface::OnCreate( void)
{
// Get resource pointer
ZIDLResource* pResource = ZApplication::GetGameInterface()->GetIDLResource();
// 변수 초기화
m_nTotalPageNum = 0;
m_nCurrentPageNum = 0;
// 퀘스트에 필요한 정보 로딩
LoadMonsterBookInfo();
// 로비 UI 감추기
CCWidget* pWidget = pResource->FindWidget( "Lobby");
if ( pWidget)
pWidget->Show( false);
// 페이지를 그린다
DrawPage();
// 몬스터 도감 보이기
pWidget = pResource->FindWidget( "MonsterBook");
if ( pWidget)
pWidget->Show( true);
// 스트립 이미지 애니메이션
CCPicture* pPicture = (CCPicture*)pResource->FindWidget( "MonsterBook_StripBottom");
if( pPicture)
pPicture->SetAnimation( 0, 1000.0f);
pPicture = (CCPicture*)pResource->FindWidget( "MonsterBook_StripTop");
if( pPicture)
pPicture->SetAnimation( 1, 1000.0f);
}
bool BOARD_PRINTOUT_CONTROLLER::OnPrintPage( int aPage )
{
LSET lset = m_PrintParams.m_PrintMaskLayer;
int pageCount = lset.count();
wxString layer;
LAYER_ID extractLayer;
// compute layer mask from page number if we want one page per layer
if( m_PrintParams.m_OptionPrintPage == 0 ) // One page per layer
{
// This sequence is TBD, call a different
// sequencer if needed, such as Seq(). Could not find documentation on
// page order.
LSEQ seq = lset.UIOrder();
// aPage starts at 1, not 0
if( unsigned( aPage-1 ) < seq.size() )
m_PrintParams.m_PrintMaskLayer = LSET( seq[aPage-1] );
}
if( !m_PrintParams.m_PrintMaskLayer.any() )
return false;
extractLayer = m_PrintParams.m_PrintMaskLayer.ExtractLayer();
if( extractLayer == UNDEFINED_LAYER )
layer = _( "Multiple Layers" );
else
layer = LSET::Name( extractLayer );
// In Pcbnew we can want the layer EDGE always printed
if( m_PrintParams.m_Flags == 1 )
m_PrintParams.m_PrintMaskLayer.set( Edge_Cuts );
DrawPage( layer, aPage, pageCount );
m_PrintParams.m_PrintMaskLayer = lset;
return true;
}
static int teletext_header_update(unsigned int dwPageCode)
{
char szOldClock[8];
if (context_tele.status != TELETEXT_STARTED)
{
return AM_TT_ERR_NOT_START;
}
if (LOWWORD(dwPageCode) == context_tele.wPageIndex)
{
GetDisplayHeader(&context_tele.sCurrPage, FALSE);
if (context_tele.auto_page_status == TRUE)
{
teletext_set_codepage(VTCODEPAGE_NONE);
if (context_tele.TtxCodepage >= VTCODEPAGE_ENGLISH && context_tele.TtxCodepage < VTCODEPAGE_LASTONE)
{
SetCodepage(context_tele.TtxCodepage);
}
}
TELETEXT_DRAW(&context_tele, ({
DrawPage(&context_tele.sCurrPage, 0/*VTDF_HEADERONLY*/, VTDoubleProfile);
}));
HRESULT MuPDFDoc::UpdatePage(int pageNumber, unsigned char *bitmap, int x, int y, int width, int height, bool invert)
{
int index = FindPageInCache(pageNumber);
if (index < 0)
{
//TODO: get rid of this side effect!!!
HRESULT result = GotoPage(pageNumber);
if (FAILED(result))
{
return result;
}
return DrawPage(bitmap, x, y, width, height, invert);
}
fz_device *dev = nullptr;
fz_pixmap *pixmap = nullptr;
fz_var(dev);
fz_var(pixmap);
PageCache *pageCache = &m_pages[m_currentPage];
fz_try(m_context)
{
fz_interactive *idoc = fz_interact(m_document);
// Call fz_update_page now to ensure future calls yield the
// changes from the current state
if (idoc)
fz_update_page(idoc, pageCache->page);
if (!pageCache->pageList)
{
/* Render to list */
pageCache->pageList = fz_new_display_list(m_context);
dev = fz_new_list_device(m_context, pageCache->pageList);
fz_run_page_contents(m_document, pageCache->page, dev, fz_identity, nullptr);
}
if (!pageCache->annotList)
{
if (dev)
{
fz_free_device(dev);
dev = nullptr;
}
pageCache->annotList = fz_new_display_list(m_context);
dev = fz_new_list_device(m_context, pageCache->annotList);
for (fz_annot *annot = fz_first_annot(m_document, pageCache->page); annot; annot = fz_next_annot(m_document, annot))
fz_run_annot(m_document, pageCache->page, annot, dev, fz_identity, nullptr);
}
fz_bbox rect;
rect.x0 = x;
rect.y0 = y;
rect.x1 = x + width;
rect.y1 = y + height;
pixmap = fz_new_pixmap_with_bbox_and_data(m_context, fz_device_bgr, rect, bitmap);
//
fz_matrix ctm = CalcConvertMatrix();
fz_bbox bbox = fz_round_rect(fz_transform_rect(ctm, pageCache->mediaBox));
/* Now, adjust ctm so that it would give the correct page width
* heights. */
float xscale = (float)width/(float)(bbox.x1-bbox.x0);
float yscale = (float)height/(float)(bbox.y1-bbox.y0);
ctm = fz_concat(ctm, fz_scale(xscale, yscale));
bbox = fz_round_rect(fz_transform_rect(ctm, pageCache->mediaBox));
if (dev)
{
fz_free_device(dev);
dev = nullptr;
}
fz_annot *annot;
while (idoc && (annot = fz_poll_changed_annot(idoc, pageCache->page)))
{
fz_bbox abox = fz_round_rect(fz_transform_rect(ctm, fz_bound_annot(m_document, annot)));
abox = fz_intersect_bbox(abox, rect);
if (!fz_is_empty_bbox(abox))
{
fz_clear_pixmap_rect_with_value(m_context, pixmap, 0xff, abox);
dev = fz_new_draw_device_with_bbox(m_context, pixmap, abox);
if (pageCache->pageList)
fz_run_display_list(pageCache->pageList, dev, ctm, abox, nullptr);
if (pageCache->annotList)
fz_run_display_list(pageCache->annotList, dev, ctm, abox, nullptr);
fz_free_device(dev);
dev = nullptr;
if (invert)
fz_invert_pixmap_rect(pixmap, abox);
}
}
}
fz_always(m_context)
{
if (dev)
{
fz_free_device(dev);
dev = nullptr;
}
if (pixmap)
{
fz_drop_pixmap(m_context, pixmap);
}
}
fz_catch(m_context)
{
return E_FAIL;
}
return S_OK;
}
void
BF_GUI_Text::Draw(BRect oRect)
{
DrawPage();
}
