void DesignerActionManager::polishActions() const
{
QList<ActionInterface* > actions = Utils::filtered(designerActions(),
[](ActionInterface *action) { return action->type() != ActionInterface::ContextMenu; });
Core::Context qmlDesignerFormEditorContext(Constants::C_QMLFORMEDITOR);
Core::Context qmlDesignerNavigatorContext(Constants::C_QMLNAVIGATOR);
Core::Context qmlDesignerUIContext;
qmlDesignerUIContext.add(qmlDesignerFormEditorContext);
qmlDesignerUIContext.add(qmlDesignerNavigatorContext);
for (auto *action : actions) {
if (!action->menuId().isEmpty()) {
const QString id =
QString("QmlDesigner.%1").arg(QString::fromLatin1(action->menuId()));
Core::Command *cmd = Core::ActionManager::registerAction(action->action(), id.toLatin1().constData(), qmlDesignerUIContext);
cmd->setDefaultKeySequence(action->action()->shortcut());
cmd->setDescription(action->action()->toolTip());
action->action()->setToolTip(cmd->action()->toolTip());
action->action()->setShortcut(cmd->action()->shortcut());
action->action()->setShortcutContext(Qt::WidgetShortcut); //Hack to avoid conflicting shortcuts. We use the Core::Command for the shortcut.
}
}
}
Handle<Entity> newEntity(core::Context &context, World &world, const GCTP_TYPEINFO &typeinfo, const _TCHAR *name, const _TCHAR *srcfilename)
{
if(srcfilename) context.load(srcfilename);
Pointer<Entity> ret = context.create(typeinfo, name).lock();
if(ret) {
if(srcfilename) ret->setUp(srcfilename);
ret->enter(world);
}
return ret.get();
}
void calculateContext()
{
Core::Context context;
if (m_Actions & Constants::MoveUpDown)
context.add(Constants::C_BASIC_MOVE);
if (m_Actions & Constants::AddRemove)
context.add(Constants::C_BASIC_ADDREMOVE);
m_Context->setContext(context);
}
Handle<Entity> newEntity(core::Context &context, World &world, const char *classname, const _TCHAR *name, const _TCHAR *srcfilename)
{
if(srcfilename) {
if(!context.load(srcfilename)) return Handle<Entity>();
}
Pointer<Entity> ret = context.create(classname, name).lock();
if(ret) {
if(srcfilename) ret->setUp(srcfilename);
ret->enter(world);
}
return ret;
}
bool Action::isScriptable(const Core::Context &context) const
{
if (context == m_context && m_scriptableMap.contains(m_action->action()))
return m_scriptableMap.value(m_action->action());
for (int i = 0; i < context.size(); ++i) {
if (QAction *a = m_contextActionMap.value(context.at(i), 0)) {
if (m_scriptableMap.contains(a) && m_scriptableMap.value(a))
return true;
}
}
return false;
}
void ProjectTree::updateContext()
{
Core::Context oldContext;
oldContext.add(m_lastProjectContext);
Core::Context newContext;
if (m_currentProject) {
newContext.add(m_currentProject->projectContext());
newContext.add(m_currentProject->projectLanguages());
m_lastProjectContext = newContext;
} else {
m_lastProjectContext = Core::Context();
}
Core::ICore::updateAdditionalContexts(oldContext, newContext);
}
void X86MasterAnalyzer::detectCallingConvention(core::Context &context, const core::ir::calling::CalleeId &calleeId) const {
auto architecture = context.image()->architecture();
auto setConvention = [&](const char *name) {
context.conventions()->setConvention(calleeId, architecture->getCallingConvention(QLatin1String(name)));
};
switch (architecture->bitness()) {
case 16:
setConvention("cdecl16");
break;
case 32:
setConvention("cdecl32");
break;
case 64:
setConvention("amd64");
break;
}
}
void Action::addOverrideAction(QAction *action, const Core::Context &context, bool scriptable)
{
if (Utils::HostOsInfo::isMacHost())
action->setIconVisibleInMenu(false);
if (isEmpty())
m_action->initialize(action);
if (context.isEmpty()) {
m_contextActionMap.insert(0, action);
} else {
for (int i = 0; i < context.size(); ++i) {
int k = context.at(i);
if (m_contextActionMap.contains(k))
qWarning("%s", qPrintable(msgActionWarning(action, k, m_contextActionMap.value(k, 0))));
m_contextActionMap.insert(k, action);
}
}
m_scriptableMap[action] = scriptable;
setCurrentContext(m_context);
}
static int Embed(int argc, char **argv)
{
Core::Context *ncx = initNidiumJS();
JSContext *cx = ncx->getNJS()->getJSContext();
if (argc <= 1) {
printf("$ %s <path> [prefix] [> out]\n", argv[0]);
return 1;
}
DIR *dir = opendir(argv[1]);
if (!dir) {
fprintf(stderr, "Can't open dir %s\n", argv[1]);
}
JS_BeginRequest(cx);
JSNFS *nfs = new JSNFS(cx);
bool ok;
if (argc == 3) {
std::string prefix = "/";
prefix += argv[2];
fprintf(stderr, "Create prefix %s...\n", prefix.c_str());
nfs->mkdir(prefix.c_str(), strlen(prefix.c_str()));
ok = listdir(nfs, dir, argv[1], strlen(argv[1]));
} else {
ok = listdir(nfs, dir, argv[1], strlen(argv[1]));
}
nfs->save(DIR2NFS_OUTPUT);
JS_EndRequest(cx);
delete ncx;
return ok ? 0 : 1;
}
void X86MasterAnalyzer::detectCallingConvention(core::Context &context, const core::ir::calling::CalleeId &calleeId) const {
const auto &platform = context.image()->platform();
auto architecture = platform.architecture();
auto setConvention = [&](const char *name) {
context.conventions()->setConvention(calleeId, architecture->getCallingConvention(QLatin1String(name)));
};
switch (architecture->bitness()) {
case 16:
setConvention("cdecl16");
break;
case 32:
setConvention("cdecl32");
break;
case 64:
if (platform.operatingSystem() == core::image::Platform::Windows) {
setConvention("microsoft64");
} else {
setConvention("amd64");
}
break;
}
}
void Shortcut::setCurrentContext(const Core::Context &context)
{
foreach (int ctxt, m_context) {
if (context.contains(ctxt)) {
if (!m_shortcut->isEnabled()) {
m_shortcut->setEnabled(true);
emit activeStateChanged();
}
return;
}
}
if (m_shortcut->isEnabled()) {
m_shortcut->setEnabled(false);
emit activeStateChanged();
}
return;
}
void TableView::addContext(const Core::Context &context)
{
Core::Context current = d->m_Context->context();
current.add(context);
d->m_Context->setContext(current);
}
Material_test::Material_test(Core::Context &ctx)
: App(ctx)
, m_timer(0.f)
, m_cube_entity(get_world())
, m_plane_entity(get_world())
, m_camera_entity(get_world())
, m_camera(m_camera_entity, ctx.get_width(), ctx.get_height())
{
namespace Mat_utils = ::Test::Material_test_utils;
ctx.set_title("Material Renderer");
// ** Setup Entities ** //
{
// Move cube up so its not intersecting with plane.
{
m_cube_entity.set_name("Material Test Cube");
const Core::Transform cube_trans(
math::vec3_init(0.f, scene_cube_scale * 0.5f, 0.f),
math::vec3_init(scene_cube_scale),
math::quat_init()
);
Core::Entity_component::set_transform(m_cube_entity, cube_trans);
}
// Scale up plane
{
m_plane_entity.set_name("Material Test Plane");
const Core::Transform scaled_up(
math::vec3_zero(),
math::vec3_init(scene_plane_scale, 1.f, scene_plane_scale),
math::quat_init()
);
Core::Entity_component::set_transform(m_plane_entity, scaled_up);
}
// Back and up for the camera.
{
m_camera_entity.set_name("Material Test Camera");
Core::Entity_component::set_transform(
m_camera_entity,
Common::Orbit_transform(0.f,
camera_tilt,
camera_distance,
camera_height)
);
}
}
// ** Create Materials ** //
{
// Creates the material and stores it in the out.
auto add_material = [](const Core::Shader &shd,
const Core::Texture &tex,
const uint32_t index,
Core::Material *out)
{
char name[256];
memset(name, 0, sizeof(name));
sprintf(name, "test_material_%02d", index);
Core::Material material(name);
material.set_shader(shd);
if(tex)
{
material.set_map_01(tex);
}
*out = material;
};
uint32_t curr_mat = 0;
assert(curr_mat < Mat_utils::max_materials());
add_material(Shader_factory::get_fullbright(), Texture_factory::get_dev_green(), curr_mat, &m_materials[curr_mat]);
++curr_mat;
assert(curr_mat < Mat_utils::max_materials());
add_material(Shader_factory::get_fullbright(), Texture_factory::get_dev_red(), curr_mat, &m_materials[curr_mat]);
++curr_mat;
assert(curr_mat < Mat_utils::max_materials());
add_material(Shader_factory::get_fullbright(), Texture_factory::get_dev_squares(), curr_mat, &m_materials[curr_mat]);
++curr_mat;
assert(curr_mat < Mat_utils::max_materials());
add_material(Shader_factory::get_fullbright(), Texture_factory::get_dev_squares_large(), curr_mat, &m_materials[curr_mat]);
++curr_mat;
assert(curr_mat < Mat_utils::max_materials());
add_material(Shader_factory::get_fullbright(), Texture_factory::get_dev_colored_squares(), curr_mat, &m_materials[curr_mat]);
++curr_mat;
assert(curr_mat < Mat_utils::max_materials());
add_material(Shader_factory::get_noise(), Core::Texture(), curr_mat, &m_materials[curr_mat]);
++curr_mat;
assert(curr_mat == Mat_utils::max_materials());
}
// ** Create Renderers And Attach ** //
{
{
uint32_t mat_id = 0;
assert(mat_id < Mat_utils::max_materials());
const Core::Material_renderer cube_material_renderer(m_materials[mat_id], Model_factory::get_unit_cube());
assert(cube_material_renderer);
Core::Entity_component::set_renderer(m_cube_entity, cube_material_renderer);
}
{
uint32_t mat_id = 1;
assert(mat_id < Mat_utils::max_materials());
const Core::Material_renderer plane_material_renderer(m_materials[mat_id], Model_factory::get_unit_plane());
assert(plane_material_renderer);
Core::Entity_component::set_renderer(m_plane_entity, plane_material_renderer);
}
}
}
void FormEditorW::setupActions()
{
Core::ActionManager *am = Core::ICore::actionManager();
Core::Command *command;
//menus
Core::ActionContainer *medit =
am->actionContainer(Core::Constants::M_EDIT);
Core::ActionContainer *mtools =
am->actionContainer(Core::Constants::M_TOOLS);
Core::ActionContainer *mformtools =
am->createMenu(M_FORMEDITOR);
mformtools->menu()->setTitle(tr("For&m Editor"));
mtools->addMenu(mformtools);
//overridden actions
bindShortcut(am->registerAction(m_fwm->actionUndo(), Core::Constants::UNDO, m_contexts), m_fwm->actionUndo());
bindShortcut(am->registerAction(m_fwm->actionRedo(), Core::Constants::REDO, m_contexts), m_fwm->actionRedo());
bindShortcut(am->registerAction(m_fwm->actionCut(), Core::Constants::CUT, m_contexts), m_fwm->actionCut());
bindShortcut(am->registerAction(m_fwm->actionCopy(), Core::Constants::COPY, m_contexts), m_fwm->actionCopy());
bindShortcut(am->registerAction(m_fwm->actionPaste(), Core::Constants::PASTE, m_contexts), m_fwm->actionPaste());
bindShortcut(am->registerAction(m_fwm->actionSelectAll(), Core::Constants::SELECTALL, m_contexts), m_fwm->actionSelectAll());
m_actionPrint = new QAction(this);
bindShortcut(am->registerAction(m_actionPrint, Core::Constants::PRINT, m_contexts), m_actionPrint);
connect(m_actionPrint, SIGNAL(triggered()), this, SLOT(print()));
//'delete' action. Do not set a shortcut as Designer handles
// the 'Delete' key by event filter. Setting a shortcut triggers
// buggy behaviour on Mac (Pressing Delete in QLineEdit removing the widget).
command = am->registerAction(m_fwm->actionDelete(), Core::Id("FormEditor.Edit.Delete"), m_contexts);
bindShortcut(command, m_fwm->actionDelete());
command->setAttribute(Core::Command::CA_Hide);
medit->addAction(command, Core::Constants::G_EDIT_COPYPASTE);
m_actionGroupEditMode = new QActionGroup(this);
m_actionGroupEditMode->setExclusive(true);
connect(m_actionGroupEditMode, SIGNAL(triggered(QAction*)), this, SLOT(activateEditMode(QAction*)));
m_modeActionSeparator = new QAction(this);
m_modeActionSeparator->setSeparator(true);
command = am->registerAction(m_modeActionSeparator, Core::Id("FormEditor.Sep.ModeActions"), m_contexts);
medit->addAction(command, Core::Constants::G_EDIT_OTHER);
m_toolActionIds.push_back(Core::Id("FormEditor.WidgetEditor"));
createEditModeAction(m_actionGroupEditMode, m_contexts, am, medit,
tr("Edit Widgets"), m_toolActionIds.back(),
EditModeWidgetEditor, QLatin1String("widgettool.png"), tr("F3"));
m_toolActionIds.push_back(Core::Id("FormEditor.SignalsSlotsEditor"));
createEditModeAction(m_actionGroupEditMode, m_contexts, am, medit,
tr("Edit Signals/Slots"), m_toolActionIds.back(),
EditModeSignalsSlotEditor, QLatin1String("signalslottool.png"), tr("F4"));
m_toolActionIds.push_back(Core::Id("FormEditor.BuddyEditor"));
createEditModeAction(m_actionGroupEditMode, m_contexts, am, medit,
tr("Edit Buddies"), m_toolActionIds.back(),
EditModeBuddyEditor, QLatin1String("buddytool.png"));
m_toolActionIds.push_back(Core::Id("FormEditor.TabOrderEditor"));
createEditModeAction(m_actionGroupEditMode, m_contexts, am, medit,
tr("Edit Tab Order"), m_toolActionIds.back(),
EditModeTabOrderEditor, QLatin1String("tabordertool.png"));
//tool actions
m_toolActionIds.push_back(Core::Id("FormEditor.LayoutHorizontally"));
const QString horizLayoutShortcut = osMac ? tr("Meta+H") : tr("Ctrl+H");
addToolAction(m_fwm->actionHorizontalLayout(), am, m_contexts,
m_toolActionIds.back(), mformtools, horizLayoutShortcut);
m_toolActionIds.push_back(Core::Id("FormEditor.LayoutVertically"));
const QString vertLayoutShortcut = osMac ? tr("Meta+L") : tr("Ctrl+L");
addToolAction(m_fwm->actionVerticalLayout(), am, m_contexts,
m_toolActionIds.back(), mformtools, vertLayoutShortcut);
m_toolActionIds.push_back(Core::Id("FormEditor.SplitHorizontal"));
addToolAction(m_fwm->actionSplitHorizontal(), am, m_contexts,
m_toolActionIds.back(), mformtools);
m_toolActionIds.push_back(Core::Id("FormEditor.SplitVertical"));
addToolAction(m_fwm->actionSplitVertical(), am, m_contexts,
m_toolActionIds.back(), mformtools);
m_toolActionIds.push_back(Core::Id("FormEditor.LayoutForm"));
addToolAction(m_fwm->actionFormLayout(), am, m_contexts,
m_toolActionIds.back(), mformtools);
m_toolActionIds.push_back(Core::Id("FormEditor.LayoutGrid"));
const QString gridShortcut = osMac ? tr("Meta+G") : tr("Ctrl+G");
addToolAction(m_fwm->actionGridLayout(), am, m_contexts,
m_toolActionIds.back(), mformtools, gridShortcut);
m_toolActionIds.push_back(Core::Id("FormEditor.LayoutBreak"));
addToolAction(m_fwm->actionBreakLayout(), am, m_contexts,
m_toolActionIds.back(), mformtools);
m_toolActionIds.push_back(Core::Id("FormEditor.LayoutAdjustSize"));
const QString adjustShortcut = osMac ? tr("Meta+J") : tr("Ctrl+J");
addToolAction(m_fwm->actionAdjustSize(), am, m_contexts,
m_toolActionIds.back(), mformtools, adjustShortcut);
m_toolActionIds.push_back(Core::Id("FormEditor.SimplifyLayout"));
addToolAction(m_fwm->actionSimplifyLayout(), am, m_contexts,
m_toolActionIds.back(), mformtools);
createSeparator(this, am, m_contexts, mformtools, Core::Id("FormEditor.Menu.Tools.Separator1"));
addToolAction(m_fwm->actionLower(), am, m_contexts,
Core::Id("FormEditor.Lower"), mformtools);
addToolAction(m_fwm->actionRaise(), am, m_contexts,
Core::Id("FormEditor.Raise"), mformtools);
// Commands that do not go into the editor toolbar
createSeparator(this, am, m_contexts, mformtools, Core::Id("FormEditor.Menu.Tools.Separator2"));
#if QT_VERSION >= 0x050000
m_actionPreview = m_fwm->action(QDesignerFormWindowManagerInterface::DefaultPreviewAction);
#else
m_actionPreview = m_fwm->actionDefaultPreview();
#endif
QTC_ASSERT(m_actionPreview, return);
addToolAction(m_actionPreview, am, m_contexts,
Core::Id("FormEditor.Preview"), mformtools, tr("Alt+Shift+R"));
// Preview in style...
#if QT_VERSION >= 0x050000
m_actionGroupPreviewInStyle = m_fwm->actionGroup(QDesignerFormWindowManagerInterface::StyledPreviewActionGroup);
#else
m_actionGroupPreviewInStyle = m_fwm->actionGroupPreviewInStyle();
#endif
Core::ActionContainer *previewAC = createPreviewStyleMenu(am, m_actionGroupPreviewInStyle);
m_previewInStyleMenu = previewAC->menu();
mformtools->addMenu(previewAC);
setPreviewMenuEnabled(false);
// Form settings
createSeparator(this, am, m_contexts, medit, Core::Id("FormEditor.Edit.Separator2"), Core::Constants::G_EDIT_OTHER);
createSeparator(this, am, m_contexts, mformtools, Core::Id("FormEditor.Menu.Tools.Separator3"));
m_actionSwitchSource = new QAction(tr("Switch Source/Form"), this);
connect(m_actionSwitchSource, SIGNAL(triggered()), this, SLOT(switchSourceForm()));
// Switch form/source in editor/design contexts.
Core::Context switchContexts = m_contexts;
switchContexts.add(Core::Constants::C_EDITORMANAGER);
addToolAction(m_actionSwitchSource, am, switchContexts, Core::Id("FormEditor.FormSwitchSource"), mformtools,
tr("Shift+F4"));
createSeparator(this, am, m_contexts, mformtools, Core::Id("FormEditor.Menu.Tools.Separator4"));
#if QT_VERSION >= 0x050000
QAction *actionFormSettings = m_fwm->action(QDesignerFormWindowManagerInterface::FormWindowSettingsDialogAction);
#else
QAction *actionFormSettings = m_fwm->actionShowFormWindowSettingsDialog();
#endif
addToolAction(actionFormSettings, am, m_contexts, Core::Id("FormEditor.FormSettings"), mformtools);
createSeparator(this, am, m_contexts, mformtools, Core::Id("FormEditor.Menu.Tools.Separator5"));
m_actionAboutPlugins = new QAction(tr("About Qt Designer plugins...."), this);
addToolAction(m_actionAboutPlugins, am, m_contexts,
Core::Id("FormEditor.AboutPlugins"), mformtools);
connect(m_actionAboutPlugins, SIGNAL(triggered()), m_fwm,
#if QT_VERSION >= 0x050000
SLOT(showPluginDialog())
#else
SLOT(aboutPlugins())
#endif
);
m_actionAboutPlugins->setEnabled(false);
// FWM
connect(m_fwm, SIGNAL(activeFormWindowChanged(QDesignerFormWindowInterface*)), this, SLOT(activeFormWindowChanged(QDesignerFormWindowInterface*)));
}
