A row of the menu, which comprises the left and right verticals plus the given content.

        Returns:
            str: A row of this menu component with the specified content.
15679
def row(self, content='', align='left'):
        
        return u"{lm}{vert}{cont}{vert}".format(lm=' ' * self.margins.left,
                                                vert=self.border_style.outer_vertical,
                                                cont=self._format_content(content, align))
720540
def get_row(row)
      row = @row_keys[row]
      row.nil? ? nil : @col_keys.map { |c, ci| [c, @content[row][ci]] }.to_h
    end
905160
def view_data(self):
        
        left, right = self.left_index, self.left_index + len(self)
        if left > right:
            left, right = right, left

        data = np.frombuffer(self.__data.get_obj(), dtype=np.complex64)
        return np.concatenate((data[left:right], data[right:], data[:left]))
174449
def MenuItem(parent, menu, label='', longtext='', action=None, default=True,
             **kws):
    
    item = menu.Append(-1, label, longtext, **kws)
    kind = item.GetKind()
    if kind == wx.ITEM_CHECK:
        item.Check(default)
    if callable(action):
        parent.Bind(wx.EVT_MENU, action, item)
    return item
844111
def table_format(self, columns, content):
        
        result = []
        textw = TextWidget()
        for row in content:
            i = 0
            result_row = []
            for cell in row:
                result_row.append(textw.render(cell, **columns[i]))
                i += 1
            result.append(result_row)
        return (columns, result)
1182592
def getTopRight(self):
        
        return (float(self.get_x()) + float(self.get_width()), float(self.get_y()) + float(self.get_height()))
19374
private void showSystemMenu() {
        Insets insets = rootPane.getInsets();
        windowMenu.show(menuButton, getX() - insets.left - insets.right,
            getY() + this.getPreferredSize().height);
    }
389866
def fmt_row_header(self, columns, dimensions, **settings):
        
        row = list(map(lambda x: x['label'], columns))
        return self.fmt_row(columns, dimensions, row, **settings)
164997
def verticals(self):
        
        vertical_shifts = set(izip_longest([], map(
            lambda i: i - self.y, range(self.board.height)), fillvalue=0))
        vertical_shifts.discard((0, 0))
        return vertical_shifts
868704
function(menu, data) {
        if (!data.children || !data.children.length) {
            return;
        }

        var options = this.options,
            groups = [],
            ul,
            li,
            tag,
            limit = options.itemLimit,
            i, l;

        if (options.className) {
            menu.addClass(options.className);
        }

        menu
            .aria('expanded', false)
            .attr('role', 'menu');

        if (limit && data.children.length > limit) {
            i = 0;
            l = data.children.length;

            while (i < l) {
                groups.push(data.children.slice(i, i += limit));
            }
        } else {
            groups.push(data.children);
        }

        for (var g = 0, group, child; group = groups[g]; g++) {
            ul = $('<ul/>');

            for (i = 0, l = group.length; i < l; i++) {
                child = group[i];

                // Build tag
                if (child.url) {
                    li = $('<li/>');
                    tag = $('<a/>', {
                        text: child.title,
                        href: child.url,
                        role: 'menuitem'
                    });

                    // Add icon
                    $('<span/>')
                        .addClass(child.icon || (Toolkit.isRTL ? 'caret-left' : 'caret-right'))
                        .prependTo(tag);

                } else {
                    li = this.render(options.template);
                    tag = $('<span/>', {
                        text: child.title,
                        role: 'presentation'
                    });
                }

                if (child.attributes) {
                    tag.attr(child.attributes);
                }

                // Build list
                if (child.className) {
                    li.addClass(child.className);
                }

                li.append(tag).appendTo(ul);

                if (child.children && child.children.length) {
                    var childMenu = this.render(options.template)
                        .conceal()
                        .appendTo(li);

                    this._buildMenu(childMenu, child);

                    li.addClass('has-children')
                        .aria('haspopup', true)
                        .on('mouseenter', this.onPositionChild.bind(this, li))
                        .on('mouseleave', this.onHideChild.bind(this, li));
                }
            }

            menu.append(ul);
        }

        // Only monitor top level menu
        if (options.mode !== 'click' && menu.hasClass('is-root')) {
            menu.on({
                mouseenter: function() {
                    this.clearTimer('hide');
                }.bind(this),
                mouseleave: function() {
                    this.startTimer('hide', options.hideDelay);
                }.bind(this)
            });
        }
    }
996955
def viewable_width(self):
        
        return sum(self.widths) + sum(x['padding'] for x in self.colspec)
919510
def get_left_key_rect(self):
        """"""

        key_left = self.row, self.col - 1, self.tab

        border_width_right = \
            float(self.cell_attributes[key_left]["borderwidth_right"]) / 2.0

        rect_left = (self.x-border_width_right, self.y,
                     border_width_right, self.height)
        return key_left, rect_left
363585
def tile(self, zoom, row, col):
        
        return Tile(self, zoom, row, col)
696576
def get_context_menu(self):
        
        mnu = QtWidgets.QMenu()
        mnu.addActions(self._actions)
        mnu.addSeparator()
        for menu in self._menus:
            mnu.addMenu(menu)
        return mnu
921466
def menu():
    
    root = MenuItem('')

    for mod in droplet.modules():
        if mod.installed:
            module_path = mod.__class__.__module__.rsplit('.', 1)[0]
            menu = import_module(module_path + '.menu')
            if menu:
                menu.menu(root)

    return root
1014786
function () {
        var self = this, elm = self.getEl(), rect = self.layoutRect(), mainButtonElm, menuButtonElm;

        self._super();

        mainButtonElm = elm.firstChild;
        menuButtonElm = elm.lastChild;

        $(mainButtonElm).css({
          width: rect.w - DomUtils.getSize(menuButtonElm).width,
          height: rect.h - 2
        });

        $(menuButtonElm).css({
          height: rect.h - 2
        });

        return self;
      }
1262655
def menu text, &block
      m = Menu.new text, &block 
      m.color = @color
      m.bgcolor = @bgcolor
      add m
      return m
    end