ActionItem *pop()
{
if (actions.empty())
return 0;
ActionItem *ret=actions.at(0);
actions.pop_front();
return ret;
}
static QStringList objectNameList(QDesignerFormWindowInterface *form)
{
typedef QList<QAction*> ActionList;
typedef QList<QButtonGroup *> ButtonGroupList;
QStringList result;
QWidget *mainContainer = form->mainContainer();
if (!mainContainer)
return result;
// Add main container container pages (QStatusBar, QWizardPages) etc.
// to the list. Pages of containers on the form are not added, however.
if (const QDesignerContainerExtension *c = qt_extension<QDesignerContainerExtension *>(form->core()->extensionManager(), mainContainer)) {
const int count = c->count();
for (int i = 0 ; i < count; i++)
addWidgetToObjectList(c->widget(i), result);
}
const QDesignerFormWindowCursorInterface *cursor = form->cursor();
const int widgetCount = cursor->widgetCount();
for (int i = 0; i < widgetCount; ++i)
addWidgetToObjectList(cursor->widget(i), result);
const QDesignerMetaDataBaseInterface *mdb = form->core()->metaDataBase();
// Add managed actions and actions with managed menus
const ActionList actions = mainContainer->findChildren<QAction*>();
if (!actions.empty()) {
const ActionList::const_iterator cend = actions.constEnd();
for (ActionList::const_iterator it = actions.constBegin(); it != cend; ++it) {
QAction *a = *it;
if (!a->isSeparator()) {
if (QMenu *menu = a->menu()) {
if (mdb->item(menu))
result.push_back(menu->objectName());
} else {
if (mdb->item(a))
result.push_back(a->objectName());
}
}
}
}
// Add managed buttons groups
const ButtonGroupList buttonGroups = mainContainer->findChildren<QButtonGroup *>();
if (!buttonGroups.empty()) {
const ButtonGroupList::const_iterator cend = buttonGroups.constEnd();
for (ButtonGroupList::const_iterator it = buttonGroups.constBegin(); it != cend; ++it)
if (mdb->item(*it))
result.append((*it)->objectName());
}
result.sort();
return result;
}
NodeList Builder::add_task(
const Environment& env,
const NodeList& targets,
const NodeList& sources,
const ActionList& actions
)
{
if(!actions.empty()) {
Task::pointer task(new Task(env, targets, sources, actions));
for(const Node& node : targets)
graph[node]->set_task(task);
} else {
for(const Node& target : targets)
for(const Node& source : sources)
add_edge(target, source, graph);
}
return targets;
}
bool ToolBarEventFilter::handleContextMenuEvent(QContextMenuEvent * event )
{
event->accept();
const QPoint globalPos = event->globalPos();
const int index = actionIndexAt(m_toolBar, m_toolBar->mapFromGlobal(globalPos), m_toolBar->orientation());
const ActionList actions = m_toolBar->actions();
QAction *action = index != -1 ?actions.at(index) : 0;
QVariant itemData;
QMenu menu(0);
// Insert before
if (action && index != 0 && !action->isSeparator()) {
QAction *newSeperatorAct = menu.addAction(tr("Insert Separator before '%1'").arg(action->objectName()));
qVariantSetValue(itemData, action);
newSeperatorAct->setData(itemData);
connect(newSeperatorAct, SIGNAL(triggered()), this, SLOT(slotInsertSeparator()));
}
// Append separator
if (actions.empty() || !actions.back()->isSeparator()) {
QAction *newSeperatorAct = menu.addAction(tr("Append Separator"));
qVariantSetValue(itemData, static_cast<QAction*>(0));
newSeperatorAct->setData(itemData);
connect(newSeperatorAct, SIGNAL(triggered()), this, SLOT(slotInsertSeparator()));
}
// Remove
if (!menu.actions().empty())
menu.addSeparator();
// Remove
if (action) {
QAction *a = menu.addAction(tr("Remove action '%1'").arg(action->objectName()));
qVariantSetValue(itemData, action);
a->setData(itemData);
connect(a, SIGNAL(triggered()), this, SLOT(slotRemoveSelectedAction()));
}
QAction *remove_toolbar = menu.addAction(tr("Remove Toolbar '%1'").arg(m_toolBar->objectName()));
connect(remove_toolbar, SIGNAL(triggered()), this, SLOT(slotRemoveToolBar()));
menu.exec(globalPos);
return true;
}
// Create a MDI subwindow for the form.
QMdiSubWindow *DockedMainWindow::createMdiSubWindow(QWidget *fw, Qt::WindowFlags f, const QKeySequence &designerCloseActionShortCut)
{
QMdiSubWindow *rc = mdiArea()->addSubWindow(fw, f);
// Make action shortcuts respond only if focused to avoid conflicts with
// designer menu actions
if (designerCloseActionShortCut == QKeySequence(QKeySequence::Close)) {
const ActionList systemMenuActions = rc->systemMenu()->actions();
if (!systemMenuActions.empty()) {
const ActionList::const_iterator cend = systemMenuActions.constEnd();
for (ActionList::const_iterator it = systemMenuActions.constBegin(); it != cend; ++it) {
if ( (*it)->shortcut() == designerCloseActionShortCut) {
(*it)->setShortcutContext(Qt::WidgetShortcut);
break;
}
}
}
}
return rc;
}
ActionList ToolBarEventFilter::contextMenuActions(const QPoint &globalPos)
{
ActionList rc;
const int index = actionIndexAt(m_toolBar, m_toolBar->mapFromGlobal(globalPos), m_toolBar->orientation());
const ActionList actions = m_toolBar->actions();
QAction *action = index != -1 ?actions.at(index) : 0;
QVariant itemData;
// Insert before
if (action && index != 0 && !action->isSeparator()) {
QAction *newSeperatorAct = new QAction(tr("Insert Separator before '%1'").arg(action->objectName()), 0);
itemData.setValue(action);
newSeperatorAct->setData(itemData);
connect(newSeperatorAct, SIGNAL(triggered()), this, SLOT(slotInsertSeparator()));
rc.push_back(newSeperatorAct);
}
// Append separator
if (actions.empty() || !actions.back()->isSeparator()) {
QAction *newSeperatorAct = new QAction(tr("Append Separator"), 0);
itemData.setValue(static_cast<QAction*>(0));
newSeperatorAct->setData(itemData);
connect(newSeperatorAct, SIGNAL(triggered()), this, SLOT(slotInsertSeparator()));
rc.push_back(newSeperatorAct);
}
// Promotion
if (!m_promotionTaskMenu)
m_promotionTaskMenu = new PromotionTaskMenu(m_toolBar, PromotionTaskMenu::ModeSingleWidget, this);
m_promotionTaskMenu->addActions(formWindow(), PromotionTaskMenu::LeadingSeparator|PromotionTaskMenu::TrailingSeparator, rc);
// Remove
if (action) {
QAction *a = new QAction(tr("Remove action '%1'").arg(action->objectName()), 0);
itemData.setValue(action);
a->setData(itemData);
connect(a, SIGNAL(triggered()), this, SLOT(slotRemoveSelectedAction()));
rc.push_back(a);
}
QAction *remove_toolbar = new QAction(tr("Remove Toolbar '%1'").arg(m_toolBar->objectName()), 0);
connect(remove_toolbar, SIGNAL(triggered()), this, SLOT(slotRemoveToolBar()));
rc.push_back(remove_toolbar);
return rc;
}
// Determine the free area behind the last action.
QRect ToolBarEventFilter::freeArea(const QToolBar *tb)
{
QRect rc = QRect(QPoint(0, 0), tb->size());
const ActionList actionList = tb->actions();
QRect exclusionRectangle = actionList.empty() ? handleArea(tb) : tb->actionGeometry(actionList.back());
switch (tb->orientation()) {
case Qt::Horizontal:
switch (QApplication::layoutDirection()) {
case Qt::LeftToRight:
rc.setX(exclusionRectangle.right() + 1);
break;
case Qt::RightToLeft:
rc.setRight(exclusionRectangle.x());
break;
}
break;
case Qt::Vertical:
rc.setY(exclusionRectangle.bottom() + 1);
break;
}
return rc;
}
void Driver::BuildActions(const ArgList &Args, ActionList &Actions) const {
llvm::PrettyStackTraceString CrashInfo("Building compilation actions");
// Start by constructing the list of inputs and their types.
// Track the current user specified (-x) input. We also explicitly
// track the argument used to set the type; we only want to claim
// the type when we actually use it, so we warn about unused -x
// arguments.
types::ID InputType = types::TY_Nothing;
Arg *InputTypeArg = 0;
llvm::SmallVector<std::pair<types::ID, const Arg*>, 16> Inputs;
for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
it != ie; ++it) {
Arg *A = *it;
if (isa<InputOption>(A->getOption())) {
const char *Value = A->getValue(Args);
types::ID Ty = types::TY_INVALID;
// Infer the input type if necessary.
if (InputType == types::TY_Nothing) {
// If there was an explicit arg for this, claim it.
if (InputTypeArg)
InputTypeArg->claim();
// stdin must be handled specially.
if (memcmp(Value, "-", 2) == 0) {
// If running with -E, treat as a C input (this changes the
// builtin macros, for example). This may be overridden by
// -ObjC below.
//
// Otherwise emit an error but still use a valid type to
// avoid spurious errors (e.g., no inputs).
if (!Args.hasArg(options::OPT_E, false))
Diag(clang::diag::err_drv_unknown_stdin_type);
Ty = types::TY_C;
} else {
// Otherwise lookup by extension, and fallback to ObjectType
// if not found. We use a host hook here because Darwin at
// least has its own idea of what .s is.
if (const char *Ext = strrchr(Value, '.'))
Ty = Host->lookupTypeForExtension(Ext + 1);
if (Ty == types::TY_INVALID)
Ty = types::TY_Object;
}
// -ObjC and -ObjC++ override the default language, but only for "source
// files". We just treat everything that isn't a linker input as a
// source file.
//
// FIXME: Clean this up if we move the phase sequence into the type.
if (Ty != types::TY_Object) {
if (Args.hasArg(options::OPT_ObjC))
Ty = types::TY_ObjC;
else if (Args.hasArg(options::OPT_ObjCXX))
Ty = types::TY_ObjCXX;
}
} else {
assert(InputTypeArg && "InputType set w/o InputTypeArg");
InputTypeArg->claim();
Ty = InputType;
}
// Check that the file exists. It isn't clear this is worth
// doing, since the tool presumably does this anyway, and this
// just adds an extra stat to the equation, but this is gcc
// compatible.
if (memcmp(Value, "-", 2) != 0 && !llvm::sys::Path(Value).exists())
Diag(clang::diag::err_drv_no_such_file) << A->getValue(Args);
else
Inputs.push_back(std::make_pair(Ty, A));
} else if (A->getOption().isLinkerInput()) {
// Just treat as object type, we could make a special type for
// this if necessary.
Inputs.push_back(std::make_pair(types::TY_Object, A));
} else if (A->getOption().getId() == options::OPT_x) {
InputTypeArg = A;
InputType = types::lookupTypeForTypeSpecifier(A->getValue(Args));
// Follow gcc behavior and treat as linker input for invalid -x
// options. Its not clear why we shouldn't just revert to
// unknown; but this isn't very important, we might as well be
// bug comatible.
if (!InputType) {
Diag(clang::diag::err_drv_unknown_language) << A->getValue(Args);
InputType = types::TY_Object;
}
}
}
if (!SuppressMissingInputWarning && Inputs.empty()) {
Diag(clang::diag::err_drv_no_input_files);
return;
}
// Determine which compilation mode we are in. We look for options
// which affect the phase, starting with the earliest phases, and
// record which option we used to determine the final phase.
Arg *FinalPhaseArg = 0;
phases::ID FinalPhase;
// -{E,M,MM} only run the preprocessor.
if ((FinalPhaseArg = Args.getLastArg(options::OPT_E)) ||
(FinalPhaseArg = Args.getLastArg(options::OPT_M)) ||
(FinalPhaseArg = Args.getLastArg(options::OPT_MM))) {
FinalPhase = phases::Preprocess;
// -{fsyntax-only,-analyze,emit-llvm,S} only run up to the compiler.
} else if ((FinalPhaseArg = Args.getLastArg(options::OPT_fsyntax_only)) ||
(FinalPhaseArg = Args.getLastArg(options::OPT__analyze,
options::OPT__analyze_auto)) ||
(FinalPhaseArg = Args.getLastArg(options::OPT_S))) {
FinalPhase = phases::Compile;
// -c only runs up to the assembler.
} else if ((FinalPhaseArg = Args.getLastArg(options::OPT_c))) {
FinalPhase = phases::Assemble;
// Otherwise do everything.
} else
FinalPhase = phases::Link;
// Reject -Z* at the top level, these options should never have been
// exposed by gcc.
if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
// Construct the actions to perform.
ActionList LinkerInputs;
for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
types::ID InputType = Inputs[i].first;
const Arg *InputArg = Inputs[i].second;
unsigned NumSteps = types::getNumCompilationPhases(InputType);
assert(NumSteps && "Invalid number of steps!");
// If the first step comes after the final phase we are doing as
// part of this compilation, warn the user about it.
phases::ID InitialPhase = types::getCompilationPhase(InputType, 0);
if (InitialPhase > FinalPhase) {
// Claim here to avoid the more general unused warning.
InputArg->claim();
Diag(clang::diag::warn_drv_input_file_unused)
<< InputArg->getAsString(Args)
<< getPhaseName(InitialPhase)
<< FinalPhaseArg->getOption().getName();
continue;
}
// Build the pipeline for this file.
Action *Current = new InputAction(*InputArg, InputType);
for (unsigned i = 0; i != NumSteps; ++i) {
phases::ID Phase = types::getCompilationPhase(InputType, i);
// We are done if this step is past what the user requested.
if (Phase > FinalPhase)
break;
// Queue linker inputs.
if (Phase == phases::Link) {
assert(i + 1 == NumSteps && "linking must be final compilation step.");
LinkerInputs.push_back(Current);
Current = 0;
break;
}
// Some types skip the assembler phase (e.g., llvm-bc), but we
// can't encode this in the steps because the intermediate type
// depends on arguments. Just special case here.
if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm)
continue;
// Otherwise construct the appropriate action.
Current = ConstructPhaseAction(Args, Phase, Current);
if (Current->getType() == types::TY_Nothing)
break;
}
// If we ended with something, add to the output list.
if (Current)
Actions.push_back(Current);
}
// Add a link action if necessary.
if (!LinkerInputs.empty())
Actions.push_back(new LinkJobAction(LinkerInputs, types::TY_Image));
}
