Opens the format scope.
772002
def _set_format_scope(self, fmt):
        
        self._prev_fmt = QtGui.QTextCharFormat(fmt)
        self._prev_fmt_closed = False
1251724
def open(self):
        """"""
        filename = self.dialogs.getOpenFileName(filter="*.%s" % self.FTYPE)
        if filename:
            self.new(filename)
227454
def open(self):
        """"""
        try:
            self.project.open_main(self.filename)
        except UnicodeDecodeError:
            with open(self.filename, 'rb') as openfile:
                encoding = get_encoding(openfile.read())

            try:
                self.project.open_main(self.filename, encoding)
            except UnicodeDecodeError:
                LOGGER.error("'%s' encountered a fatal encoding error",
                             self.filename)
                sys.exit(1)
            except:  # pylint: disable=W0702
                open_error(self.filename)

        except:  # pylint: disable=W0702
            open_error(self.filename)
958436
def open(self, mode='r', **kwargs):
        """"""
        _fs, filename = opener.parse(self.uri)
        return _fs.open(filename, mode=mode, **kwargs)
838108
public void open(Context<K, W> ctx) throws Exception {
		this.ctx = ctx;
		this.windowAssigner.open(ctx);
	}
1288715
def _openResources(self):
        
        logger.info("Opening: {}".format(self._fileName))
        self._h5Group = h5py.File(self._fileName, 'r')
306043
def add_scope(self, scope_type, scope_name, scope_start, is_method=False):
        """"""
        if self._curr is not None:
            self._curr['end'] = scope_start - 1  # close last scope
        self._curr = {
            'type': scope_type, 'name': scope_name,
            'start': scope_start, 'end': scope_start
        }

        if is_method and self._positions:
            last = self._positions[-1]
            if not 'methods' in last:
                last['methods'] = []
            last['methods'].append(self._curr)
        else:
            self._positions.append(self._curr)
697119
def _raw_open(self, flags, mode=0o777):
        
        return self._accessor.open(self, flags, mode)
1063745
def open(self, mode='r', buffering=-1, encoding=None,
             errors=None, newline=None):
        
        if mode != 'r' or buffering != -1 or encoding or errors or newline:
            raise NotImplementedError('Only the default open() ' +
                                      'arguments are supported')

        return self._accessor.open(self)
82969
public void open() {
		Futures.transform(lcm, new Subscribe(subscriber));
		publishTask = Futures.transform(lcm, publisher);
	}
1334524
protected function openFile()
    {
        ini_set('auto_detect_line_endings', 1);
        $this->fileHandle = fopen($this->filename, 'r');

        if ($this->providedHeaderRow) {
            $this->headerRow = $this->remapHeader($this->providedHeaderRow);
        }
    }
796248
def do_open(self, mode=None):
        
        if mode is None:
            mode = self.mode

        with self._alter_umask():
            # noinspection PyArgumentList
            stream = io.open(
                self.baseFilename, mode=mode, encoding=self.encoding, newline=self.newline)

        self._do_chown_and_chmod(self.baseFilename)

        return stream
1014922
def load(self):
        
        # load the custom format
        if self._customFormat and os.path.exists(self.fileName()):
            self._customFormat.load(self.fileName())
1017568
public void open() {
		if (!close) {
            open = true;
        }
        DocListener listener;
		for (Iterator iterator = listeners.iterator(); iterator.hasNext();) {
            listener = (DocListener) iterator.next();
            listener.setPageSize(pageSize);
			listener.setMargins(marginLeft, marginRight, marginTop,
					marginBottom);
            listener.open();
        }
    }
806459
@Override
  public void open() {
    try {
      if (this.isOpened() == false) {
        System.out.println(formatVersionInfo() + " Opening ...");

        this.traceLogfile = FileSystems.getDefault().getPath(this.logDirPath.toString(), super.getName() + ".log").toFile();
        this.fileOutputStream = new FileOutputStream(this.traceLogfile);
        this.setBufferedOutputStream(new BufferedOutputStream(this.fileOutputStream, this.getBufferSize()));
        this.setTracePrintStream(new TracePrintStream(this.getBufferedOutputStream(), this.getThreadMap()));

        this.getTracePrintStream().printf("--> TraceLog opened!%n");
        this.getTracePrintStream().printf("    Time     : %tc%n", new Date());
        this.getTracePrintStream().printf("    Bufsize  : %d%n", this.getBufferSize());
        this.getTracePrintStream().printf("    Autoflush: %b%n%n", this.isAutoflush());
        this.setOpened(true);
      }
      else {
        System.err.println("WARNING: Tracelog is opened already.");
      }
    }
    catch (FileNotFoundException ex) {
      ex.printStackTrace(System.err);
    }
  }
853842
void openBuffer() {
    if(buffer == null) {
      try {
        buffer = input.map(MapMode.READ_ONLY, 0, input.size());
      }
      catch(IOException e) {
        throw new AbortException("Cannot map input bundle.", e);
      }
    }
  }
770839
def open(fname):
    
    with _builtin_open(fname) as fh:
        region_string = fh.read()
    return parse(region_string)