Displays the menu for this filter widget.
425451
def showMenu(self, point):
        
        menu = QMenu(self)
        acts = {}
        acts['edit'] = menu.addAction('Edit quick filter...')
        
        trigger = menu.exec_(self.mapToGlobal(point))
        
        if trigger == acts['edit']:
            text, accepted = XTextEdit.getText(self.window(),
                                                  'Edit Format',
                                                  'Format:',
                                                  self.filterFormat(),
                                                  wrapped=False)
            
            if accepted:
                self.setFilterFormat(text)
1156351
public function index()
    {
        $menus = $this->Filter->filter($this->Menus->find('all'))->hydrate(false);
        $this->set('menus', $menus);
    }
825600
public function display()
    {
        $options = $this->getOptions();

        if (!$this->visible || count($options) === 0) {
            return;
        }

        parent::display();

        // outer div is required because the check-all widget is outside the
        // unordered list
        $div_tag = new SwatHtmlTag('div');
        $div_tag->id = $this->id;
        $div_tag->class = $this->getCSSClassString();
        $div_tag->open();

        $current_column = 1;
        $current_option = 0;
        $columns = is_array($this->columns)
            ? $this->columns
            : array(
                ceil(
                    count($options) / ($this->columns > 0 ? $this->columns : 1)
                )
            );

        $multiple_columns = count($options) > $columns[0];
        $maximum_options = array_shift($columns);

        $ul_tag = new SwatHtmlTag('ul');
        if ($multiple_columns) {
            $ul_tag->id = sprintf('%s_column_%s', $this->id, $current_column);
            $ul_tag->class = 'swat-checkbox-list-column';
        }
        $ul_tag->open();

        foreach ($options as $index => $option) {
            if ($current_option == $maximum_options) {
                $ul_tag->close();

                $current_column++;
                $current_option = 0;
                $maximum_options =
                    count($columns) > 0
                        ? array_shift($columns)
                        : $maximum_options;

                $ul_tag->id = sprintf(
                    '%s_column_%s',
                    $this->id,
                    $current_column
                );

                $ul_tag->class = 'swat-checkbox-list-column';

                $ul_tag->open();
            }

            $current_option++;
            $this->displayOption($option, $index);
        }

        $ul_tag->close();

        // Show clear div if columns are used
        if ($multiple_columns) {
            echo '<div class="swat-clear"></div>';
        }

        // Show the check all if more than one checkable item is displayed.
        $check_all = $this->getCompositeWidget('check_all');
        $check_all->visible = $this->show_check_all && count($options) > 1;
        $check_all->display();

        $div_tag->close();

        Swat::displayInlineJavaScript($this->getInlineJavaScript());
    }
1185840
def show_popup_menu(self, pos):
        ''''''
        self.popup_pos = self.image_coordinates(pos)
        self.frame.PopupMenu(self.wx_popup_menu, pos)
1174368
function () {
        var self = this;

        if (self.menu) {
          self.menu.items().each(function (item) {
            if (item.hideMenu) {
              item.hideMenu();
            }
          });

          self.menu.hide();
        }
      }
28407
public function views()
    {
        $views = $this->get_views();
        $views = apply_filters('views_' . $this->screen->id, $views);

        if (empty($views)) {
            return;
        }

        echo "<ul class='subsubsub'>\n";

        foreach ( $views as $class => $view ) {
            $views[ $class ] = "\t<li class='$class'>$view";
        }

        echo implode( " |</li>\n", $views ) . "</li>\n";
        echo "</ul>";
    }
1174857
public function index()
    {
        $this->loadModel('Menu.MenuLinks');
        $links = $this->MenuLinks
            ->find('threaded')
            ->where([
                'parent_id IN' => $this->MenuLinks
                    ->find()
                    ->select(['id'])
                    ->where(['url' => '/admin/system/structure'])
            ])
            ->all();

        $this->title(__d('system', 'Site’s Structure'));
        $this->set('links', $links);
        $this->Breadcrumb->push('/admin/system/structure');
    }
830456
public void showSlideMenu() {
        synchronized (this) {
            if (!this.menuShown.getAndSet(true)) {
                final SlideMenuModel smm = getModel(Key.create(SlideMenuModel.class, this.selectedSlide));

                StackPane.setAlignment(smm.node(), Pos.CENTER);
                view().node().getChildren().add(smm.node());

                smm.node().parentProperty().addListener((observable, oldValue, newValue) -> {
                    if (newValue == null) {
                        this.menuShown.set(false);
                    }
                });
            }
        }
    }
1257683
public function display()
    {
        if (!$this->visible) {
            return;
        }

        SwatWidget::display();

        $outer_div = new SwatHtmlTag('div');
        $outer_div->id = $this->id;
        $outer_div->class = $this->getCSSClassString();

        $outer_div->open();
        $this->displayTitle();
        $this->displayContent();
        $outer_div->close();
    }
659387
def __setup_menu(self):
        """"""
        self.menu.clear()
        if self.data:
            actions = self.menu_actions
        else:
            actions = (self.new_action, self.open_action)
            self.setFocus() # --> Editor.__get_focus_editortabwidget
        add_actions(self.menu, list(actions) + self.__get_split_actions())
        self.close_action.setEnabled(self.is_closable)
440929
def wx_menu(self):
        ''''''
        from MAVProxy.modules.lib.wx_loader import wx
        menu = wx.Menu()
        for i in range(len(self.items)):
            m = self.items[i]
            m._append(menu)
        return menu
170297
def on_summary_menu_open(self, widget):
        """"""
        self.original_widget = urwid.Overlay(
            self.summary_menu.main_window,
            self.original_widget,
            ('relative', self.left_margin),
            self.summary_menu.get_size()[1],
            ('relative', self.top_margin),
            self.summary_menu.get_size()[0])
111607
function showMenu() {
        opts.parent.append(element);
        element[0].style.display = '';

        return $q(function(resolve) {
          var position = calculateMenuPosition(element, opts);

          element.removeClass('md-leave');

          // Animate the menu scaling, and opacity [from its position origin (default == top-left)]
          // to normal scale.
          $animateCss(element, {
            addClass: 'md-active',
            from: animator.toCss(position),
            to: animator.toCss({transform: ''})
          })
          .start()
          .then(resolve);

        });
      }
489063
def show(self, **kwargs):
        """"""
        show_kwargs = copy.deepcopy(self._show_kwargs)
        show_kwargs.update(kwargs)
        return show_menu(self.entries, **show_kwargs)
1345792
def set_menu(self, menu):
        
        self.menu = menu
        self.submenu.parent = menu
851770
function () {
        var self = this, settings = self.settings, menu, parent = self.parent();

        parent.items().each(function (ctrl) {
          if (ctrl !== self) {
            ctrl.hideMenu();
          }
        });

        if (settings.menu) {
          menu = self.menu;

          if (!menu) {
            menu = settings.menu;

            // Is menu array then auto constuct menu control
            if (menu.length) {
              menu = {
                type: 'menu',
                items: menu
              };
            } else {
              menu.type = menu.type || 'menu';
            }

            if (parent.settings.itemDefaults) {
              menu.itemDefaults = parent.settings.itemDefaults;
            }

            menu = self.menu = Factory.create(menu).parent(self).renderTo();
            menu.reflow();
            menu.on('cancel', function (e) {
              e.stopPropagation();
              self.focus();
              menu.hide();
            });
            menu.on('show hide', function (e) {
              if (e.control.items) {
                e.control.items().each(function (ctrl) {
                  ctrl.active(ctrl.settings.selected);
                });
              }
            }).fire('show');

            menu.on('hide', function (e) {
              if (e.control === menu) {
                self.classes.remove('selected');
              }
            });

            menu.submenu = true;
          } else {
            menu.show();
          }

          menu._parentMenu = parent;

          menu.classes.add('menu-sub');

          var rel = menu.testMoveRel(
            self.getEl(),
            self.isRtl() ? ['tl-tr', 'bl-br', 'tr-tl', 'br-bl'] : ['tr-tl', 'br-bl', 'tl-tr', 'bl-br']
          );

          menu.moveRel(self.getEl(), rel);
          menu.rel = rel;

          rel = 'menu-sub-' + rel;
          menu.classes.remove(menu._lastRel).add(rel);
          menu._lastRel = rel;

          self.classes.add('selected');
          self.aria('expanded', true);
        }
      }
585568
protected void display() {
        new FilterPresenter(new FilterViewUI()).go(layout);
        resultPresenter = new ResultPresenter(getResultView());
        loadStatusListener.registerObserver(resultPresenter);
        resultPresenter.go(layout);

    }