int main( int argc, char **argv )
{
char file[MAX_FILENAME_LEN + 1];
char *line, *prompt="> ";
int i;
if ( argc == 2 )
ystrncpy( file, argv[1], MAX_FILENAME_LEN );
else
yerror( "missing filename\n" );
restores( file );
prints();
restorer( file );
for( i = 0; i < status.datan; i++ )
readdata( status.dataf[i], i );
port = gp_open( "400x400" );
using_history();
stifle_history(1000);
sprintf( historyfile, "%s/%s", getenv("HOME"), HISTORYFILE );
if ( !access (historyfile, R_OK) )
if ( read_history(historyfile) )
perror( "reading history" );
while (1) {
line=readline( prompt );
if ( line ) {
add_history( line );
parser( line );
} else printf( "\n" );
}
return 0;
}
int CPDF_Object::GetInteger() const
{
CFX_AutoRestorer<int> restorer(&s_nCurRefDepth);
if (++s_nCurRefDepth > OBJECT_REF_MAX_DEPTH) {
return 0;
}
switch (m_Type) {
case PDFOBJ_BOOLEAN:
return ((CPDF_Boolean*)this)->m_bValue;
case PDFOBJ_NUMBER:
return ((CPDF_Number*)this)->GetInteger();
case PDFOBJ_REFERENCE: {
CPDF_Reference* pRef = (CPDF_Reference*)(FX_LPVOID)this;
PARSE_CONTEXT context;
FXSYS_memset32(&context, 0, sizeof(PARSE_CONTEXT));
if (pRef->m_pObjList == NULL) {
return 0;
}
CPDF_Object* pObj = pRef->m_pObjList->GetIndirectObject(pRef->m_RefObjNum, &context);
if (pObj == NULL) {
return 0;
}
return pObj->GetInteger();
}
}
return 0;
}
void with_generating(
database& db,
Lambda callback
) {
generating_helper restorer(db);
callback();
}
void with_producing(
database& db,
Lambda callback
) {
producing_helper restorer(db);
callback();
}
void CPDF_RenderContext::Render(CFX_RenderDevice* pDevice,
const CPDF_PageObject* pStopObj,
const CPDF_RenderOptions* pOptions,
const CFX_Matrix* pLastMatrix) {
for (auto& layer : m_Layers) {
CFX_RenderDevice::StateRestorer restorer(pDevice);
CPDF_RenderStatus status(this, pDevice);
if (pOptions)
status.SetOptions(*pOptions);
status.SetStopObject(pStopObj);
status.SetTransparency(layer.m_pObjectHolder->GetTransparency());
if (pLastMatrix) {
const CFX_Matrix& last_matrix = *pLastMatrix;
CFX_Matrix final_matrix = layer.m_Matrix * last_matrix;
status.SetDeviceMatrix(last_matrix);
status.Initialize(nullptr, nullptr);
status.RenderObjectList(layer.m_pObjectHolder.Get(), final_matrix);
} else {
status.Initialize(nullptr, nullptr);
status.RenderObjectList(layer.m_pObjectHolder.Get(), layer.m_Matrix);
}
if (status.GetRenderOptions().GetOptions().bLimitedImageCache) {
m_pPageCache->CacheOptimization(
status.GetRenderOptions().GetCacheSizeLimit());
}
if (status.IsStopped())
break;
}
}
bool DrawingBuffer::prepareMailbox(WebKit::WebExternalTextureMailbox* outMailbox)
{
if (!m_context || !m_contentsChanged || !m_lastColorBuffer)
return false;
m_context->makeContextCurrent();
// Resolve the multisampled buffer into the texture referenced by m_lastColorBuffer mailbox.
if (multisample())
commit();
// We must restore the texture binding since creating new textures,
// consuming and producing mailboxes changes it.
ScopedTextureUnit0BindingRestorer restorer(m_context.get(), m_activeTextureUnit, m_texture2DBinding);
// First try to recycle an old buffer.
RefPtr<MailboxInfo> nextFrontColorBuffer = getRecycledMailbox();
// No buffer available to recycle, create a new one.
if (!nextFrontColorBuffer) {
unsigned newColorBuffer = createColorTexture(m_size);
// Bad things happened, abandon ship.
if (!newColorBuffer)
return false;
nextFrontColorBuffer = createNewMailbox(newColorBuffer);
}
if (m_preserveDrawingBuffer == Discard) {
m_colorBuffer = nextFrontColorBuffer->textureId;
swap(nextFrontColorBuffer, m_lastColorBuffer);
// It appears safe to overwrite the context's framebuffer binding in the Discard case since there will always be a
// WebGLRenderingContext::clearIfComposited() call made before the next draw call which restores the framebuffer binding.
// If this stops being true at some point, we should track the current framebuffer binding in the DrawingBuffer and restore
// it after attaching the new back buffer here.
m_context->bindFramebuffer(GraphicsContext3D::FRAMEBUFFER, m_fbo);
m_context->framebufferTexture2D(GraphicsContext3D::FRAMEBUFFER, GraphicsContext3D::COLOR_ATTACHMENT0, GraphicsContext3D::TEXTURE_2D, m_colorBuffer, 0);
} else {
Extensions3D* extensions = m_context->getExtensions();
extensions->copyTextureCHROMIUM(GraphicsContext3D::TEXTURE_2D, m_colorBuffer, nextFrontColorBuffer->textureId, 0, GraphicsContext3D::RGBA, GraphicsContext3D::UNSIGNED_BYTE);
}
if (multisample() && !m_framebufferBinding)
bind();
else
restoreFramebufferBinding();
m_contentsChanged = false;
context()->bindTexture(GraphicsContext3D::TEXTURE_2D, nextFrontColorBuffer->textureId);
context()->produceTextureCHROMIUM(GraphicsContext3D::TEXTURE_2D, nextFrontColorBuffer->mailbox.name);
context()->flush();
m_context->markLayerComposited();
*outMailbox = nextFrontColorBuffer->mailbox;
m_frontColorBuffer = nextFrontColorBuffer->textureId;
return true;
}
void without_pending_transactions(
database& db,
std::vector<processed_transaction>&& pending_transactions,
Lambda callback )
{
pending_transactions_restorer restorer( db, std::move(pending_transactions) );
callback();
return;
}
Real CallableBond::NPVSpreadHelper::operator()(Real x) const
{
CallableBond::arguments* args=
dynamic_cast<CallableBond::arguments*>(bond_.engine_->getArguments());
// Pops the original value when function finishes
RestoreVal<Spread> restorer(args->spread);
args->spread=x;
bond_.engine_->calculate();
return results_->value;
}
int GlXOffscreenContext::getIntProperty(GLenum intProperty)
{
ContextRestorer restorer(!isActive());
makeActive();
int v = 0;
glGetIntegerv(intProperty, &v);
checkGlError("After GlXOffscreenContext::getIntProperty..");
return v;
}
void without_pending_transactions(
database& db,
uint32_t skip,
std::vector<signed_transaction>&& pending_transactions,
Lambda callback
) {
pending_transactions_restorer restorer(db, skip, std::move(pending_transactions));
callback();
return;
}
void with_skip_flags(
database& db,
uint32_t skip_flags,
Lambda callback )
{
node_property_object& npo = db.node_properties();
skip_flags_restorer restorer( npo, npo.skip_flags );
npo.skip_flags = skip_flags;
callback();
return;
}
void CPDF_RenderStatus::RenderSingleObject(
const CPDF_PageObject* pObj,
const CFX_AffineMatrix* pObj2Device) {
CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
if (++s_CurrentRecursionDepth > kRenderMaxRecursionDepth) {
return;
}
m_pCurObj = pObj;
if (m_Options.m_pOCContext && pObj->m_ContentMark.NotNull()) {
if (!m_Options.m_pOCContext->CheckObjectVisible(pObj)) {
return;
}
}
ProcessClipPath(pObj->m_ClipPath, pObj2Device);
if (ProcessTransparency(pObj, pObj2Device)) {
return;
}
ProcessObjectNoClip(pObj, pObj2Device);
}
bool CPDF_DataAvail::HaveResourceAncestor(CPDF_Dictionary* pDict) {
CFX_AutoRestorer<int> restorer(&s_CurrentDataAvailRecursionDepth);
if (++s_CurrentDataAvailRecursionDepth > kMaxDataAvailRecursionDepth)
return false;
CPDF_Object* pParent = pDict->GetObjectFor("Parent");
if (!pParent)
return false;
CPDF_Dictionary* pParentDict = pParent->GetDict();
if (!pParentDict)
return false;
CPDF_Object* pRet = pParentDict->GetObjectFor("Resources");
if (pRet) {
m_pPageResource = pRet;
return true;
}
return HaveResourceAncestor(pParentDict);
}
void CPDF_RenderStatus::RenderSingleObject(CPDF_PageObject* pObj,
const CFX_Matrix* pObj2Device) {
#if defined _SKIA_SUPPORT_
DebugVerifyDeviceIsPreMultiplied();
#endif
CFX_AutoRestorer<int> restorer(&s_CurrentRecursionDepth);
if (++s_CurrentRecursionDepth > kRenderMaxRecursionDepth) {
return;
}
m_pCurObj = pObj;
if (m_Options.m_pOCContext && pObj->m_ContentMark) {
if (!m_Options.m_pOCContext->CheckObjectVisible(pObj)) {
return;
}
}
ProcessClipPath(pObj->m_ClipPath, pObj2Device);
if (ProcessTransparency(pObj, pObj2Device)) {
return;
}
ProcessObjectNoClip(pObj, pObj2Device);
#if defined _SKIA_SUPPORT_
DebugVerifyDeviceIsPreMultiplied();
#endif
}
int CPDF_Object::GetInteger() const {
CFX_AutoRestorer<int> restorer(&s_nCurRefDepth);
if (++s_nCurRefDepth > kObjectRefMaxDepth)
return 0;
switch (m_Type) {
case PDFOBJ_BOOLEAN:
return AsBoolean()->m_bValue;
case PDFOBJ_NUMBER:
return AsNumber()->GetInteger();
case PDFOBJ_REFERENCE: {
const CPDF_Reference* pRef = AsReference();
PARSE_CONTEXT context;
FXSYS_memset(&context, 0, sizeof(PARSE_CONTEXT));
if (!pRef->m_pObjList)
return 0;
CPDF_Object* pObj =
pRef->m_pObjList->GetIndirectObject(pRef->GetRefObjNum(), &context);
return pObj ? pObj->GetInteger() : 0;
}
}
return 0;
}
bool DrawingBuffer::prepareMailbox(blink::WebExternalTextureMailbox* outMailbox, blink::WebExternalBitmap* bitmap)
{
if (!m_context || !m_contentsChanged)
return false;
m_context->makeContextCurrent();
// Resolve the multisampled buffer into m_colorBuffer texture.
if (m_multisampleMode != None)
commit();
if (bitmap) {
bitmap->setSize(size());
unsigned char* pixels = bitmap->pixels();
bool needPremultiply = m_attributes.alpha && !m_attributes.premultipliedAlpha;
WebGLImageConversion::AlphaOp op = needPremultiply ? WebGLImageConversion::AlphaDoPremultiply : WebGLImageConversion::AlphaDoNothing;
if (pixels)
readBackFramebuffer(pixels, size().width(), size().height(), ReadbackSkia, op);
}
// We must restore the texture binding since creating new textures,
// consuming and producing mailboxes changes it.
ScopedTextureUnit0BindingRestorer restorer(m_context, m_activeTextureUnit, m_texture2DBinding);
// First try to recycle an old buffer.
RefPtr<MailboxInfo> frontColorBufferMailbox = recycledMailbox();
// No buffer available to recycle, create a new one.
if (!frontColorBufferMailbox) {
unsigned newColorBuffer = createColorTexture(m_size);
// Bad things happened, abandon ship.
if (!newColorBuffer)
return false;
frontColorBufferMailbox = createNewMailbox(newColorBuffer);
}
if (m_preserveDrawingBuffer == Discard) {
swap(frontColorBufferMailbox->textureId, m_colorBuffer);
// It appears safe to overwrite the context's framebuffer binding in the Discard case since there will always be a
// WebGLRenderingContext::clearIfComposited() call made before the next draw call which restores the framebuffer binding.
// If this stops being true at some point, we should track the current framebuffer binding in the DrawingBuffer and restore
// it after attaching the new back buffer here.
m_context->bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
if (m_multisampleMode == ImplicitResolve)
m_context->framebufferTexture2DMultisampleEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_colorBuffer, 0, m_sampleCount);
else
m_context->framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_colorBuffer, 0);
} else {
m_context->copyTextureCHROMIUM(GL_TEXTURE_2D, m_colorBuffer, frontColorBufferMailbox->textureId, 0, GL_RGBA, GL_UNSIGNED_BYTE);
}
if (m_multisampleMode != None && !m_framebufferBinding)
bind();
else
restoreFramebufferBinding();
m_contentsChanged = false;
m_context->bindTexture(GL_TEXTURE_2D, frontColorBufferMailbox->textureId);
m_context->produceTextureCHROMIUM(GL_TEXTURE_2D, frontColorBufferMailbox->mailbox.name);
m_context->flush();
frontColorBufferMailbox->mailbox.syncPoint = m_context->insertSyncPoint();
markLayerComposited();
*outMailbox = frontColorBufferMailbox->mailbox;
m_frontColorBuffer = frontColorBufferMailbox->textureId;
return true;
}
std::pair<bool, bool> CFFL_InteractiveFormFiller::OnBeforeKeyStroke(
const CPWL_Wnd::PrivateData* pAttached,
WideString& strChange,
const WideString& strChangeEx,
int nSelStart,
int nSelEnd,
bool bKeyDown,
uint32_t nFlag) {
// Copy the private data since the window owning it may not survive.
CFFL_PrivateData privateData =
*static_cast<const CFFL_PrivateData*>(pAttached);
ASSERT(privateData.pWidget);
CFFL_FormFiller* pFormFiller = GetFormFiller(privateData.pWidget, false);
#ifdef PDF_ENABLE_XFA
if (pFormFiller->IsFieldFull(privateData.pPageView)) {
CPDFSDK_Annot::ObservedPtr pObserved(privateData.pWidget);
if (OnFull(&pObserved, privateData.pPageView, nFlag) || !pObserved)
return {true, true};
}
#endif // PDF_ENABLE_XFA
if (m_bNotifying ||
!privateData.pWidget->GetAAction(CPDF_AAction::kKeyStroke).GetDict()) {
return {true, false};
}
AutoRestorer<bool> restorer(&m_bNotifying);
m_bNotifying = true;
uint32_t nAge = privateData.pWidget->GetAppearanceAge();
uint32_t nValueAge = privateData.pWidget->GetValueAge();
CPDFSDK_FormFillEnvironment* pFormFillEnv =
privateData.pPageView->GetFormFillEnv();
CPDFSDK_FieldAction fa;
fa.bModifier = CPDFSDK_FormFillEnvironment::IsCTRLKeyDown(nFlag);
fa.bShift = CPDFSDK_FormFillEnvironment::IsSHIFTKeyDown(nFlag);
fa.sChange = strChange;
fa.sChangeEx = strChangeEx;
fa.bKeyDown = bKeyDown;
fa.bWillCommit = false;
fa.bRC = true;
fa.nSelStart = nSelStart;
fa.nSelEnd = nSelEnd;
pFormFiller->GetActionData(privateData.pPageView, CPDF_AAction::kKeyStroke,
fa);
pFormFiller->SaveState(privateData.pPageView);
CPDFSDK_Annot::ObservedPtr pObserved(privateData.pWidget);
bool action_status = privateData.pWidget->OnAAction(
CPDF_AAction::kKeyStroke, &fa, privateData.pPageView);
if (!pObserved || !IsValidAnnot(privateData.pPageView, privateData.pWidget))
return {true, true};
if (!action_status)
return {true, false};
bool bExit = false;
if (nAge != privateData.pWidget->GetAppearanceAge()) {
CPWL_Wnd* pWnd = pFormFiller->ResetPDFWindow(
privateData.pPageView, nValueAge == privateData.pWidget->GetValueAge());
if (!pWnd)
return {true, true};
privateData =
*static_cast<const CFFL_PrivateData*>(pWnd->GetAttachedData());
bExit = true;
}
if (fa.bRC) {
pFormFiller->SetActionData(privateData.pPageView, CPDF_AAction::kKeyStroke,
fa);
} else {
pFormFiller->RestoreState(privateData.pPageView);
}
if (pFormFillEnv->GetFocusAnnot() == privateData.pWidget)
return {false, bExit};
pFormFiller->CommitData(privateData.pPageView, nFlag);
return {false, true};
}
CommandBufferGLTestContext::CommandBufferGLTestContext(CommandBufferGLTestContext* shareContext)
: fContext(EGL_NO_CONTEXT), fDisplay(EGL_NO_DISPLAY), fSurface(EGL_NO_SURFACE) {
static const EGLint configAttribs[] = {
EGL_SURFACE_TYPE, EGL_PBUFFER_BIT,
EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
EGL_RED_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_BLUE_SIZE, 8,
EGL_ALPHA_SIZE, 8,
EGL_NONE
};
static const EGLint surfaceAttribs[] = {
EGL_WIDTH, 1,
EGL_HEIGHT, 1,
EGL_NONE
};
load_command_buffer_once();
if (!gfFunctionsLoadedSuccessfully) {
return;
}
fDisplay = gfGetDisplay(EGL_DEFAULT_DISPLAY);
if (EGL_NO_DISPLAY == fDisplay) {
SkDebugf("Command Buffer: Could not create EGL display.\n");
return;
}
if (!gfInitialize(fDisplay, nullptr, nullptr)) {
SkDebugf("Command Buffer: Could not initialize EGL display.\n");
this->destroyGLContext();
return;
}
EGLint numConfigs;
if (!gfChooseConfig(fDisplay, configAttribs, static_cast<EGLConfig *>(&fConfig), 1,
&numConfigs) || numConfigs != 1) {
SkDebugf("Command Buffer: Could not choose EGL config.\n");
this->destroyGLContext();
return;
}
fSurface = gfCreatePbufferSurface(fDisplay,
static_cast<EGLConfig>(fConfig),
surfaceAttribs);
if (EGL_NO_SURFACE == fSurface) {
SkDebugf("Command Buffer: Could not create EGL surface.\n");
this->destroyGLContext();
return;
}
static const EGLint contextAttribs[] = {
EGL_CONTEXT_CLIENT_VERSION, 2,
EGL_NONE
};
EGLContext eglShareContext = shareContext
? reinterpret_cast<EGLContext>(shareContext->fContext) : nullptr;
fContext = gfCreateContext(fDisplay, static_cast<EGLConfig>(fConfig), eglShareContext,
contextAttribs);
if (EGL_NO_CONTEXT == fContext) {
SkDebugf("Command Buffer: Could not create EGL context.\n");
this->destroyGLContext();
return;
}
SkScopeExit restorer(context_restorer());
if (!TLSCurrentObjects::MakeCurrent(fDisplay, fSurface, fSurface, fContext)) {
SkDebugf("Command Buffer: Could not make EGL context current.\n");
this->destroyGLContext();
return;
}
auto gl = create_command_buffer_interface();
if (!gl) {
SkDebugf("Command Buffer: Could not create CommandBuffer GL interface.\n");
this->destroyGLContext();
return;
}
if (!gl->validate()) {
SkDebugf("Command Buffer: Could not validate CommandBuffer GL interface.\n");
this->destroyGLContext();
return;
}
this->init(std::move(gl));
}
bool DrawingBuffer::prepareMailbox(WebExternalTextureMailbox* outMailbox, WebExternalBitmap* bitmap)
{
if (m_destructionInProgress) {
// It can be hit in the following sequence.
// 1. WebGL draws something.
// 2. The compositor begins the frame.
// 3. Javascript makes a context lost using WEBGL_lose_context extension.
// 4. Here.
return false;
}
ASSERT(!m_isHidden);
if (!m_contentsChanged)
return false;
if (m_newMailboxCallback)
(*m_newMailboxCallback)();
// Resolve the multisampled buffer into m_colorBuffer texture.
if (m_antiAliasingMode != None)
commit();
if (bitmap) {
bitmap->setSize(size());
unsigned char* pixels = bitmap->pixels();
bool needPremultiply = m_wantAlphaChannel && !m_premultipliedAlpha;
WebGLImageConversion::AlphaOp op = needPremultiply ? WebGLImageConversion::AlphaDoPremultiply : WebGLImageConversion::AlphaDoNothing;
if (pixels)
readBackFramebuffer(pixels, size().width(), size().height(), ReadbackSkia, op);
}
// We must restore the texture binding since creating new textures,
// consuming and producing mailboxes changes it.
ScopedTextureUnit0BindingRestorer restorer(m_gl, m_activeTextureUnit, m_texture2DBinding);
// First try to recycle an old buffer.
RefPtr<MailboxInfo> frontColorBufferMailbox = recycledMailbox();
// No buffer available to recycle, create a new one.
if (!frontColorBufferMailbox)
frontColorBufferMailbox = createNewMailbox(createTextureAndAllocateMemory(m_size));
if (m_preserveDrawingBuffer == Discard) {
std::swap(frontColorBufferMailbox->textureInfo, m_colorBuffer);
attachColorBufferToReadFramebuffer();
if (m_discardFramebufferSupported) {
// Explicitly discard framebuffer to save GPU memory bandwidth for tile-based GPU arch.
const GLenum attachments[3] = { GL_COLOR_ATTACHMENT0, GL_DEPTH_ATTACHMENT, GL_STENCIL_ATTACHMENT };
m_gl->DiscardFramebufferEXT(GL_FRAMEBUFFER, 3, attachments);
}
} else {
m_gl->CopyTextureCHROMIUM(m_colorBuffer.textureId, frontColorBufferMailbox->textureInfo.textureId, frontColorBufferMailbox->textureInfo.parameters.internalColorFormat, GL_UNSIGNED_BYTE, GL_FALSE, GL_FALSE, GL_FALSE);
}
restoreFramebufferBindings();
m_contentsChanged = false;
m_gl->ProduceTextureDirectCHROMIUM(frontColorBufferMailbox->textureInfo.textureId, frontColorBufferMailbox->textureInfo.parameters.target, frontColorBufferMailbox->mailbox.name);
const GLuint64 fenceSync = m_gl->InsertFenceSyncCHROMIUM();
m_gl->Flush();
m_gl->GenSyncTokenCHROMIUM(fenceSync, frontColorBufferMailbox->mailbox.syncToken);
frontColorBufferMailbox->mailbox.validSyncToken = true;
frontColorBufferMailbox->mailbox.allowOverlay = frontColorBufferMailbox->textureInfo.imageId != 0;
frontColorBufferMailbox->mailbox.textureTarget = frontColorBufferMailbox->textureInfo.parameters.target;
frontColorBufferMailbox->mailbox.textureSize = WebSize(m_size.width(), m_size.height());
setBufferClearNeeded(true);
// set m_parentDrawingBuffer to make sure 'this' stays alive as long as it has live mailboxes
ASSERT(!frontColorBufferMailbox->m_parentDrawingBuffer);
frontColorBufferMailbox->m_parentDrawingBuffer = this;
*outMailbox = frontColorBufferMailbox->mailbox;
m_frontColorBuffer = { frontColorBufferMailbox->textureInfo, frontColorBufferMailbox->mailbox };
return true;
}
void show_hotkeys_dialog (display & disp, config *save_config)
{
log_scope ("show_hotkeys_dialog");
const events::event_context dialog_events_context;
const int centerx = disp.w()/2;
const int centery = disp.h()/2;
const int width = 700;
const int height = disp.video().gety() < 600 ? 380 : 500;
const int xpos = centerx - width/2;
const int ypos = centery - height/2;
gui::button close_button (disp.video(), _("Close"));
std::vector<gui::button*> buttons;
buttons.push_back(&close_button);
gui::dialog_frame f(disp.video(),_("Hotkey Settings"),gui::dialog_frame::default_style,true,&buttons);
f.layout(xpos,ypos,width,height);
f.draw();
SDL_Rect clip_rect = create_rect(0, 0, disp.w (), disp.h ());
SDL_Rect text_size = font::draw_text(NULL, clip_rect, font::SIZE_LARGE,
font::NORMAL_COLOR,_("Press desired hotkey (Esc cancels)"),
0, 0);
std::vector<std::string> menu_items;
std::vector<hotkey::hotkey_item>& hotkeys = hotkey::get_hotkeys();
for(std::vector<hotkey::hotkey_item>::iterator i = hotkeys.begin(); i != hotkeys.end(); ++i) {
if(i->hidden() || !i->is_in_active_scope())
continue;
std::stringstream str,name;
name << i->get_description();
str << name.str();
str << COLUMN_SEPARATOR;
// This trick allows to display chars identical to markup characters
str << font::NULL_MARKUP << i->get_name();
menu_items.push_back(str.str());
}
std::ostringstream heading;
heading << HEADING_PREFIX << _("Action") << COLUMN_SEPARATOR << _("Binding");
menu_items.push_back(heading.str());
gui::menu::basic_sorter sorter;
sorter.set_alpha_sort(0).set_alpha_sort(1);
gui::menu menu_(disp.video(), menu_items, false, height - font::relative_size(10), -1, &sorter, &gui::menu::bluebg_style);
menu_.sort_by(0);
menu_.reset_selection();
menu_.set_width(font::relative_size(500));
menu_.set_location(xpos + font::relative_size(10), ypos + font::relative_size(10));
gui::button change_button (disp.video(), _("Change Hotkey"));
change_button.set_location(xpos + width - change_button.width () - font::relative_size(30),ypos + font::relative_size(30));
gui::button clear_button (disp.video(), _("Clear Hotkey"));
clear_button.set_location(xpos + width - clear_button.width () - font::relative_size(30),ypos + font::relative_size(80));
// gui::button save_button (disp.video(), _("Save Hotkeys"));
// save_button.set_location(xpos + width - save_button.width () - font::relative_size(30),ypos + font::relative_size(130));
escape_handler esc_hand;
for(;;) {
if (close_button.pressed() || esc_hand.escape_pressed())
{
if (save_config == NULL) {
save_hotkeys();
} else {
hotkey::save_hotkeys(*save_config);
}
break;
}
if (change_button.pressed () || menu_.double_clicked()) {
// Lets change this hotkey......
SDL_Rect dlgr = create_rect(centerx - text_size.w / 2 - 30
, centery - text_size.h / 2 - 16
, text_size.w + 60
, text_size.h + 32);
surface_restorer restorer(&disp.video(),dlgr);
gui::dialog_frame mini_frame(disp.video());
mini_frame.layout(centerx-text_size.w/2 - 20,
centery-text_size.h/2 - 6,
text_size.w+40,
text_size.h+12);
mini_frame.draw_background();
mini_frame.draw_border();
font::draw_text (&disp.video(), clip_rect, font::SIZE_LARGE,font::NORMAL_COLOR,
_("Press desired hotkey (Esc cancels)"),centerx-text_size.w/2,
centery-text_size.h/2);
disp.update_display();
SDL_Event event;
event.type = 0;
int character = 0, keycode = 0, mod = 0; // Just to avoid warning
int joystick = 0, button = 0, hat = 0, value = 0;
const int any_mod = KMOD_CTRL | KMOD_ALT | KMOD_LMETA;
while (event.type!=SDL_KEYDOWN && event.type!=SDL_JOYBUTTONDOWN && event.type!= SDL_JOYHATMOTION) SDL_PollEvent(&event);
do {
if (event.type==SDL_KEYDOWN)
{
keycode=event.key.keysym.sym;
character=event.key.keysym.unicode;
mod=event.key.keysym.mod;
};
if (event.type==SDL_JOYBUTTONDOWN) {
joystick = event.jbutton.which;
button = event.jbutton.button;
}
if (event.type==SDL_JOYHATMOTION) {
joystick = event.jhat.which;
hat = event.jhat.hat;
value = event.jhat.value;
}
SDL_PollEvent(&event);
disp.flip();
disp.delay(10);
} while (event.type!=SDL_KEYUP && event.type!=SDL_JOYBUTTONUP && event.type!=SDL_JOYHATMOTION);
restorer.restore();
disp.update_display();
if (keycode == SDLK_ESCAPE && (mod & any_mod) == 0) {
//cancel -- no action
} else {
const hotkey::hotkey_item& oldhk = hotkey::get_hotkey(character, keycode, (mod & KMOD_SHIFT) != 0,
(mod & KMOD_CTRL) != 0, (mod & KMOD_ALT) != 0, (mod & KMOD_LMETA) != 0);
hotkey::hotkey_item& newhk = hotkey::get_visible_hotkey(menu_.selection());
if(oldhk.get_id() != newhk.get_id() && !oldhk.null()) {
std::stringstream msg;
msg << " " << oldhk.get_description() << " : " << oldhk.get_name();
gui2::show_transient_message(disp.video(),_("This hotkey is already in use."),msg.str());
} else {
if (event.type == SDL_JOYHATMOTION) {
const hotkey::hotkey_item& oldhkhat = hotkey::get_hotkey(joystick, hat, value);
if(oldhkhat.get_id() != newhk.get_id() && !oldhkhat.null()) {
std::stringstream msg;
msg << " " << oldhkhat.get_description() << " : " << oldhkhat.get_name();
gui2::show_transient_message(disp.video(),_("This hotkey is already in use."),msg.str());
} else {
newhk.set_hat(joystick, hat, value);
menu_.change_item(menu_.selection(), 1, font::NULL_MARKUP + newhk.get_name());
}
} else
if (event.type == SDL_JOYBUTTONUP) {
const hotkey::hotkey_item& oldhkbtn = hotkey::get_hotkey(button, joystick);
if(oldhkbtn.get_id() != newhk.get_id() && !oldhkbtn.null()) {
std::stringstream msg;
msg << " " << oldhkbtn.get_description() << " : " << oldhkbtn.get_name();
gui2::show_transient_message(disp.video(),_("This hotkey is already in use."),msg.str());
} else {
newhk.set_button(button, joystick);
menu_.change_item(menu_.selection(), 1, font::NULL_MARKUP + newhk.get_name());
}
} else {
newhk.set_key(character, keycode, (mod & KMOD_SHIFT) != 0,
(mod & KMOD_CTRL) != 0, (mod & KMOD_ALT) != 0, (mod & KMOD_LMETA) != 0);
menu_.change_item(menu_.selection(), 1, font::NULL_MARKUP + newhk.get_name());
if ((newhk.get_id() == hotkey::HOTKEY_SCREENSHOT
|| newhk.get_id() == hotkey::HOTKEY_MAP_SCREENSHOT)
&& (mod & any_mod) == 0) {
gui2::show_transient_message(disp.video(), _("Warning"), _("Screenshot hotkeys should be combined with the Control, Alt or Meta modifiers to avoid problems."));
}
}
}
}
}
// if (save_button.pressed()) {
// if (save_config == NULL) {
// save_hotkeys();
// } else {
// hotkey::save_hotkeys(*save_config);
// }
// }
if (clear_button.pressed()) {
// clear hotkey
hotkey::hotkey_item& newhk = hotkey::get_visible_hotkey(menu_.selection());
newhk.clear_hotkey();
menu_.change_item(menu_.selection(), 1, font::NULL_MARKUP + newhk.get_name());
}
menu_.process();
events::pump();
events::raise_process_event();
events::raise_draw_event();
disp.update_display();
disp.delay(10);
}
}
