Displays the ListAll view for the primary model object.  Because the
datagrid is populated via ajax, no model data is populated here
431850
public function ListAll()
	{
		if (!$this->ModelName)
		{
			throw new Exception("ModelName must be defined in " . get_class($this) . "::ListAll");
		}

		// capture output instead of rendering if specified
		if ($this->CaptureOutputMode)
		{
			$this->DebugOutput = $this->RenderEngine->fetch("View" . $this->ModelName .  "ListAll.tpl");
		}
		else
		{
			$this->RenderEngine->display("View" . $this->ModelName .  "ListAll.tpl");
		}
		//$this->_ListAll(null, Request::Get("page",1), Request::Get("limit",20));
	}
796397
def get_list_display(self, request):
        

        # Force cast to list as super get_list_display could return a tuple
        list_display = list(
            super(VersionedAdmin, self).get_list_display(request))

        # Preprend the following fields to list display
        if self.list_display_show_identity:
            list_display = ['identity_shortener', ] + list_display

        # Append the following fields to list display
        if self.list_display_show_start_date:
            list_display += ['version_start_date', ]
        if self.list_display_show_end_date:
            list_display += ['version_end_date', ]

        return list_display + ['is_current', ]
915474
public function listToString(
        $data,
        string $title = null,
        string $titleAddition = null,
        string $class = null,
        string $delimiter = null,
        string $delimiterAddition = null,
        string $view = null
    ): string {
        $view = $view ?: 'column.listToString';

        return GridView::view($view, [
            'data'              => $data,
            'title'             => $title,
            'titleAddition'     => $titleAddition,
            'class'             => $class,
            'delimiter'         => $delimiter,
            'delimiterAddition' => $delimiterAddition,
        ])->render();
    }
507411
public static List<ListViewColumn> createDefaultInitialColumnList(View view) {
        return createDefaultInitialColumnList(DescriptorVisibilityFilter.apply(view, ListViewColumn.all()));
    }
715127
def show_for object, html_options = {}, &block
      html_options = html_options.dup

      tag = html_options[:list_tag] || IndexFor.list_tag

      html_options[:id] ||= show_for_id(object)
      html_options[:class] = show_for_class(object, html_options)

      builder = html_options[:builder] || IndexFor::ListColumnBuilder
      content = capture(builder.new(object, html_options, self), &block)

      content_tag(tag, content, html_options)
    end
91110
function View() {
        Element.apply(this, arguments);

        /** @member {Model} */
        this.model = null;

        /** @member {Array.<View>} */
        this.subViews = [];

        /** @member {View} */
        this.containerView = null;

        /** @member {Array.<View>} */
        this.containedViews = [];

        /** @member {boolean} */
        this.visible = true;

        /** @member {boolean} */
        this.enabled = true;

        /** @member {boolean} */
        this.selected = false;

        /** @member {number} */
        this.selectable = SK_YES;

        /** @member {string} */
        this.lineColor = PreferenceManager.get("view.lineColor", "#000000");

        /** @member {string} */
        this.fillColor = PreferenceManager.get("view.fillColor", "#ffffff");

        /** @member {string} */
        this.fontColor = PreferenceManager.get("view.fontColor", "#000000");

        /** @member {Font} */
        this.font = new Font(
            PreferenceManager.get("view.font", "Arial"),
            PreferenceManager.get("view.fontSize", 13),
            Graphics.FS_NORMAL
        );

        /** @member {boolean} */
        this.parentStyle = false;

        /** @member {boolean} */
        this.showShadow = PreferenceManager.get("view.showShadow", true);

        /** @member {boolean} */
        this.containerChangeable = false;

        /** @member {boolean} */
        this.containerExtending = false;

        /** @member {number} */
        this.zIndex = 0;
    }
1178768
function View(primaryModel, relatedModels, attributes) {
  if (false === (this instanceof View)) throw new Error('new operator required');
  if (!(primaryModel instanceof Model)) throw new Error('argument must be a Model');
  if (typeof relatedModels != 'object') throw new Error('object expected');
  if (!(attributes instanceof Array)) throw new Error('array of attributes expected');
  this.primaryModel = primaryModel;
  this.relatedModels = relatedModels;
  this.attributes = attributes;
  var id = new Attribute('id', 'ID');
  id.model = primaryModel;
  this.attributes.unshift(id);

  /**
   * Make sure relatedModels valid
   */
  for (var relatedModel in relatedModels) {
    if (relatedModels.hasOwnProperty(relatedModel)) {
      var obj = relatedModels[relatedModel];
      //console.log('relatedModel ' + relatedModel);
      //console.log('obj ' + JSON.stringify(obj));
      if (typeof obj != 'object') throw new Error('relatedModel key values expect object');
      if (obj.id === undefined) throw new Error('relatedModel key values expect object with id key');
      if (obj.model === undefined) throw new Error('relatedModel key values expect object with model key');
      if (!(obj.id instanceof Attribute)) throw new Error('relatedModel id must be a Attribute');
      if (!(obj.model instanceof Model)) throw new Error('relatedModel model must be a Model');
    }
  }
  /**
   * Check attributes
   */
  for (var i = 0; i < attributes.length; i++) {
    var attribute = attributes[i];
    if (!(attribute instanceof Attribute)) throw new Error('attribute array must contain Attributes');
    if (!(attribute.model instanceof Model)) {
      throw new Error('attribute array must contain Attributes with model references');
    }

  }
}
1370750
private void showAktRow() {

        try {
            pStmt.clearParameters();

            for (int i = 0; i < primaryKeys.length; i++) {
                pStmt.setObject(i + 1, resultRowPKs[aktRowNr][i]);
            }    // end of for (int i=0; i<primaryKeys.length; i++)

            ResultSet rs = pStmt.executeQuery();

            rs.next();

            for (int i = 0; i < columns.length; i++) {
                komponente[i].setContent(rs.getString(i + 1));
            }    // end of for (int i=0; i<primaryKeys.length; i++)

            rs.close();
        } catch (SQLException e) {
            ZaurusEditor.printStatus("SQL Exception: " + e.getMessage());
        }        // end of try-catch

        for (int i = 0; i < columns.length; i++) {
            komponente[i].clearChanges();
        }
    }
846573
public void displayModelPages(CmsModelInfo modelPageData) {

        m_modelPageTree.clear();
        m_modelPageTreeItems.clear();
        m_parentModelPageTreeItems.clear();

        if ((modelPageData.getParentModelPages() != null) && !modelPageData.getParentModelPages().isEmpty()) {
            m_parentModelPageRoot = CmsModelPageTreeItem.createRootItem(
                false,
                Messages.get().key(Messages.GUI_PARENT_MODEL_PAGE_TREE_ROOT_TITLE_0),
                "");

            for (CmsModelPageEntry parentModel : modelPageData.getParentModelPages()) {
                if (parentModel.isDisabled()) {
                    continue;
                }
                CmsModelPageTreeItem treeItem = new CmsModelPageTreeItem(parentModel, false, true);
                if (m_controller.isEditable()) {
                    CmsSitemapHoverbar.installOn(
                        m_controller,
                        treeItem,
                        parentModel.getStructureId(),
                        parentModel.getSitePath(),
                        parentModel.getSitePath() != null);
                }
                m_parentModelPageTreeItems.put(parentModel.getStructureId(), treeItem);
                m_parentModelPageRoot.addChild(treeItem);
                m_modelPageData.put(parentModel.getStructureId(), parentModel);
            }
            if (m_parentModelPageRoot.getChildren().getWidgetCount() > 0) {
                m_modelPageTree.add(m_parentModelPageRoot);
            } else {
                m_parentModelPageRoot = null;
            }
        } else {
            m_parentModelPageRoot = null;
        }
        m_modelPageRoot = CmsModelPageTreeItem.createRootItem(
            false,
            Messages.get().key(Messages.GUI_MODEL_PAGE_TREE_ROOT_TITLE_0),
            Messages.get().key(Messages.GUI_MODEL_PAGE_TREE_ROOT_SUBTITLE_0));
        if (m_controller.isEditable()) {
            CmsHoverbarCreateModelPageButton createButton = new CmsHoverbarCreateModelPageButton(false);
            CmsSitemapHoverbar hoverbar = CmsSitemapHoverbar.installOn(
                m_controller,
                m_modelPageRoot,
                Collections.<Widget> singleton(createButton));
            hoverbar.setAlwaysVisible();
            createButton.setHoverbar(hoverbar);
        }
        m_modelPageTree.add(m_modelPageRoot);
        for (CmsModelPageEntry entry : modelPageData.getModelPages()) {
            if (m_parentModelPageTreeItems.containsKey(entry.getStructureId())) {
                CmsModelPageTreeItem item = m_parentModelPageTreeItems.get(entry.getStructureId());
                item.setDisabled(entry.isDisabled());
            } else {
                m_modelPageData.put(entry.getStructureId(), entry);
                CmsModelPageTreeItem treeItem = new CmsModelPageTreeItem(entry, false, false);
                if (m_controller.isEditable()) {
                    CmsSitemapHoverbar.installOn(
                        m_controller,
                        treeItem,
                        entry.getStructureId(),
                        entry.getSitePath(),
                        entry.getSitePath() != null);
                }
                m_modelPageTreeItems.put(entry.getStructureId(), treeItem);
                m_modelPageRoot.addChild(treeItem);
            }
        }
        m_modelPageRoot.setOpen(true);
        m_modelGroupRoot = CmsModelPageTreeItem.createRootItem(
            true,
            Messages.get().key(Messages.GUI_MODEL_GROUP_PAGE_TREE_ROOT_TITLE_0),
            Messages.get().key(Messages.GUI_MODEL_GROUP_PAGE_TREE_ROOT_SUBTITLE_0));
        if (m_controller.isEditable()) {
            CmsHoverbarCreateModelPageButton createModelGroupButton = new CmsHoverbarCreateModelPageButton(true);
            CmsSitemapHoverbar modelGroupHoverbar = CmsSitemapHoverbar.installOn(
                m_controller,
                m_modelGroupRoot,
                Collections.<Widget> singleton(createModelGroupButton));
            modelGroupHoverbar.setAlwaysVisible();
            createModelGroupButton.setHoverbar(modelGroupHoverbar);
        }
        m_modelPageTree.add(m_modelGroupRoot);
        for (CmsModelPageEntry entry : modelPageData.getModelGroups()) {
            CmsModelPageTreeItem treeItem = new CmsModelPageTreeItem(entry, true, false);
            if (m_controller.isEditable()) {
                CmsSitemapHoverbar.installOn(
                    m_controller,
                    treeItem,
                    entry.getStructureId(),
                    entry.getSitePath(),
                    entry.getSitePath() != null);
            }
            m_modelPageTreeItems.put(entry.getStructureId(), treeItem);
            m_modelGroupRoot.addChild(treeItem);
        }
        m_modelGroupRoot.setOpen(true);
        m_modelPageTree.truncate(TM_SITEMAP, 920);
    }
371489
def generate_list_view(self):
        """"""

        name = model_class_form(self.model + 'ListView')
        list_args = dict(
            model=self.get_model_class,
            context_object_name=plural(self.model),
            template_name=self.get_template('list'),
            table_class=self.get_actual_table(),
            context_table_name='table_objects',
            crud=self.crud,
            permissions=self.view_permission('list'),
            permission_required=self.check_permission_required,
            login_required=self.check_login_required,
            table_pagination={'per_page': self.tables2_pagination or 10},
            custom_queryset=self.custom_queryset,
            custom_context=self.custom_context,
            custom_postfix_url=self.custom_postfix_url
        )

        list_class = type(
            name,
            (BaseListViewMixin, SingleTableView),
            list_args
        )
        self.classes[name] = list_class
        return list_class
782260
async def ListModelSummaries(self, all_, user_tag):
        '''
        
        '''
        # map input types to rpc msg
        _params = dict()
        msg = dict(type='ModelManager',
                   request='ListModelSummaries',
                   version=5,
                   params=_params)
        _params['all'] = all_
        _params['user-tag'] = user_tag
        reply = await self.rpc(msg)
        return reply
1156979
function (source) {
  if (false === (this instanceof List)) throw new Error('new operator required');
  if (source instanceof Model) {
    this.model = source;
  } else if (source instanceof View) {
    this.view = source;
    this.model = this.view.primaryModel;
  } else {
    throw new Error('argument required: model');
  }
  this.attributes = source.attributes;
  this._items = [];
  this._itemIndex = -1;
}
1210971
def listPrimaryDatasets(self, primary_ds_name="", primary_ds_type=""):
        
        conn = self.dbi.connection()
        try:
            result = self.primdslist.execute(conn, primary_ds_name, primary_ds_type)
            if conn: conn.close()
            return result
        finally:
            if conn:
                conn.close()
728014
function() {
      inputEx.MultiSelectField.superclass.renderComponent.call(this);
      
      this.ddlist = new inputEx.widget.ListCustom({parentEl: this.fieldContainer,listSelectOptions: this.listSelectOptions, maxItems: this.maxItems, maxItemsAlert: this.maxItemsAlert });
      
   }
19571
def _convert_to_display(self, data):
        """'"""
        for _dict in data:
            keys = list(_dict.keys())[:]
            for key in keys:
                if key not in self._sp_cols:
                    raise Exception(key + ' not a column in current List.')
                _dict[self._sp_cols[key]['name']] = self._python_type(key, _dict.pop(key))
556087
def show_data(self, item):
        
        child, cookie = self.mainview_tree.GetFirstChild(item)
        child_list = []
        while child.IsOk():
            child_list.append(child)
            child, cookie = self.mainview_tree.GetNextChild(item, cookie)

        lc = self.nodeview_lc
        lc.DeleteAllItems()
        for i, child in enumerate(child_list):
            text = self.mainview_tree.GetItemText(child)
            try:
                k, v = [s.strip() for s in text.split(':')]
            except ValueError:
                k, v = text, '...'
            idx = lc.InsertItem(MAXNROW, v)
            lc.SetItem(idx, 1, k)
1145049
def __update_display_items_model(self, display_items_model: ListModel.FilteredListModel, data_group: typing.Optional[DataGroup.DataGroup], filter_id: typing.Optional[str]) -> None:
        

        with display_items_model.changes():  # change filter and sort together
            if data_group is not None:
                display_items_model.container = data_group
                display_items_model.filter = ListModel.Filter(True)
                display_items_model.sort_key = None
                display_items_model.filter_id = None
            elif filter_id == "latest-session":
                display_items_model.container = self.document_model
                display_items_model.filter = ListModel.EqFilter("session_id", self.document_model.session_id)
                display_items_model.sort_key = DataItem.sort_by_date_key
                display_items_model.sort_reverse = True
                display_items_model.filter_id = filter_id
            elif filter_id == "temporary":
                display_items_model.container = self.document_model
                display_items_model.filter = ListModel.NotEqFilter("category", "persistent")
                display_items_model.sort_key = DataItem.sort_by_date_key
                display_items_model.sort_reverse = True
                display_items_model.filter_id = filter_id
            elif filter_id == "none":  # not intended to be used directly
                display_items_model.container = self.document_model
                display_items_model.filter = ListModel.Filter(False)
                display_items_model.sort_key = DataItem.sort_by_date_key
                display_items_model.sort_reverse = True
                display_items_model.filter_id = filter_id
            else:  # "all"
                display_items_model.container = self.document_model
                display_items_model.filter = ListModel.EqFilter("category", "persistent")
                display_items_model.sort_key = DataItem.sort_by_date_key
                display_items_model.sort_reverse = True
                display_items_model.filter_id = None