Return dict editor view settings
501079
def get_view_settings(self):
        """"""
        settings = {}
        for name in REMOTE_SETTINGS:
            settings[name] = getattr(self, name)
        return settings
1311024
def get_view_description(self, html=False):
        
        func = self.settings.VIEW_DESCRIPTION_FUNCTION
        return func(self.__class__, html)
107702
def saveTemplate(self):
        """"""
        savedict = {}
        for comp_editor in self.widgets():
            stim = comp_editor.component()
            comp_editor.saveToObject()
            savedict[stim.name] = stim.stateDict()
        savedict['delay'] = self.delaySpnbx.value()
        return savedict
1242955
def __Script_Editor_Output_plainTextEdit_set_default_view_state(self):
        

        self.Script_Editor_Output_plainTextEdit.moveCursor(QTextCursor.End)
        self.Script_Editor_Output_plainTextEdit.ensureCursorVisible()
706935
function viewDocs (ddoc, viewName, qs, callback) {
      return view(ddoc, viewName, { type: 'view' }, qs, callback)
    }
501677
function _restoreEditorViewState(editor) {
        // We want to ignore the current state of the editor, so don't call __getViewState()
        var viewState = ViewStateManager.getViewState(editor.document.file);
        if (viewState) {
            editor.restoreViewState(viewState);
        }
    }
1232961
function( editor )
	{
		// Set config related properties.

		var skin = editor.config.skin.split( ',' ),
			skinName = skin[ 0 ],
			skinPath = CKEDITOR.getUrl( skin[ 1 ] || (
				'_source/' +	// @Packager.RemoveLine
				'skins/' + skinName + '/' ) );

		/**
		 * The name of the skin used by this editor instance. The skin name can
		 * be set through the <code>{@link CKEDITOR.config.skin}</code> setting.
		 * @name CKEDITOR.editor.prototype.skinName
		 * @type String
		 * @example
		 * alert( editor.skinName );  // E.g. "kama"
		 */
		editor.skinName = skinName;

		/**
		 * The full URL of the skin directory.
		 * @name CKEDITOR.editor.prototype.skinPath
		 * @type String
		 * @example
		 * alert( editor.skinPath );  // E.g. "http://example.com/ckeditor/skins/kama/"
		 */
		editor.skinPath = skinPath;

		/**
		 * The CSS class name used for skin identification purposes.
		 * @name CKEDITOR.editor.prototype.skinClass
		 * @type String
		 * @example
		 * alert( editor.skinClass );  // E.g. "cke_skin_kama"
		 */
		editor.skinClass = 'cke_skin_' + skinName;

		/**
		 * The <a href="http://en.wikipedia.org/wiki/Tabbing_navigation">tabbing
		 * navigation</a> order that has been calculated for this editor
		 * instance. This can be set by the <code>{@link CKEDITOR.config.tabIndex}</code>
		 * setting or taken from the <code>tabindex</code> attribute of the
		 * <code>{@link #element}</code> associated with the editor.
		 * @name CKEDITOR.editor.prototype.tabIndex
		 * @type Number
		 * @default 0 (zero)
		 * @example
		 * alert( editor.tabIndex );  // E.g. "0"
		 */
		editor.tabIndex = editor.config.tabIndex || editor.element.getAttribute( 'tabindex' ) || 0;

		/**
		 * Indicates the read-only state of this editor. This is a read-only property.
		 * @name CKEDITOR.editor.prototype.readOnly
		 * @type Boolean
		 * @since 3.6
		 * @see CKEDITOR.editor#setReadOnly
		 */
		editor.readOnly = !!( editor.config.readOnly || editor.element.getAttribute( 'disabled' ) );

		// Fire the "configLoaded" event.
		editor.fireOnce( 'configLoaded' );

		// Load language file.
		loadSkin( editor );
	}
794575
def list_editors(self, node=None):
        

        return [editor_node.editor for editor_node in self.list_editor_nodes(node) if editor_node.editor]
328474
def extract_options_dict(template, options):
    """"""
    for option, val in template.items():
        if options and option in options:
            yield option, options[option]
        else:
            yield option, Default(template[option]['default'](os.environ))
897506
def readViewSettings(self, settings=None): # TODO: rename to readProfile?
        
        if settings is None:
            settings = QtCore.QSettings()
        logger.debug("Reading settings from: {}".format(settings.group()))

        self.restoreGeometry(settings.value("geometry"))
        self.restoreState(settings.value("state"))

        self.repoWidget.repoTreeView.readViewSettings('repo_tree/header_state', settings)
        self.configWidget.configTreeView.readViewSettings('config_tree/header_state', settings)

        #self._configTreeModel.readModelSettings('config_model', settings)
        settings.beginGroup('cfg_inspectors')
        try:
            for key in settings.childKeys():
                json = settings.value(key)
                self._inspectorsNonDefaults[key] = ctiLoads(json)
        finally:
            settings.endGroup()

        identifier = settings.value("inspector", None)
        try:
            if identifier:
                self.setInspectorById(identifier)
        except KeyError as ex:
            logger.warn("No inspector with ID {!r}.: {}".format(identifier, ex))
414995
def studio_view(self, context):
        
        fragment = Fragment()
        context = {'fields': []}
        # Build a list of all the fields that can be edited:
        for field_name in self.editable_fields:
            field = self.fields[field_name]
            assert field.scope in (Scope.content, Scope.settings), (
                "Only Scope.content or Scope.settings fields can be used with "
                "StudioEditableXBlockMixin. Other scopes are for user-specific data and are "
                "not generally created/configured by content authors in Studio."
            )
            field_info = self._make_field_info(field_name, field)
            if field_info is not None:
                context["fields"].append(field_info)
        fragment.content = loader.render_template('templates/studio_edit.html', context)
        fragment.add_javascript(loader.load_unicode('public/studio_edit.js'))
        fragment.initialize_js('StudioEditableXBlockMixin')
        return fragment
249394
def get_options(self):
        
        return dict(
            show_fullpath=self.treewidget.show_fullpath,
            show_all_files=self.treewidget.show_all_files,
            group_cells=self.treewidget.group_cells,
            show_comments=self.treewidget.show_comments,
            sort_files_alphabetically=(
                self.treewidget.sort_files_alphabetically),
            expanded_state=self.treewidget.get_expanded_state(),
            scrollbar_position=self.treewidget.get_scrollbar_position(),
            visibility=self.isVisible()
            )
1032613
def to_json(self):
        

        result = super(EditorInterface, self).to_json()
        result.update({'controls': self.controls})
        return result
509103
public static function getEditorGlobalLayoutSettings()
    {
        if ( self::$editorGlobalLayoutSettings === null )
        {
            $oeini = eZINI::instance( 'ezoe.ini' );
            self::$editorGlobalLayoutSettings = array(
                'buttons' => $oeini->variable('EditorLayout', 'Buttons' ),
                'toolbar_location' => $oeini->variable('EditorLayout', 'ToolbarLocation' ),
                'path_location' => $oeini->variable('EditorLayout', 'PathLocation' ),
            );
        }
        return self::$editorGlobalLayoutSettings;
    }
174607
def __Languages_comboBox_set_default_view_state(self):
        

        if not self.__container.has_editor_tab():
            return

        editor = self.__container.get_current_editor()
        index = self.Languages_comboBox.findText(editor.language.name)

        self.Languages_comboBox.setCurrentIndex(index)
1014296
def editors(self):
        """"""
        result = set()
        for role in self._EDITOR_ROLES:
            for member in self._bindings.get(role, ()):
                result.add(member)
        return frozenset(result)
955003
def showEditor(self):
        """"""
        if self.editor is not None:
            editor = self.editor()
            editor.setModel(self)
            factory = get_stimulus_factory(self._stim.stimType())
            editor.editingFinished.connect(factory.update)
            return editor
        else:
            logger = logging.getLogger('main')
            logger.warning('Erm, no editor available :(')