def save_trajectory_callback(self):
        self.blockSignals(True)
        print "Save gains"
        # Save data to file that we can read in
        # TODO - invalid file names

        fileName = QFileDialog.getSaveFileName()

        #if fileName[0] checks to ensure that the file dialog has not been canceled
        if fileName[0]:
            if self.calculate_trajectory():
                print self.robot_command;
                newFileptr = open(fileName[0], 'w')
                # Suggested format for files to make it easy to combine different outputs
                newFileptr.write('# Trajectory \n')
                newFileptr.write(self.robot_command)
                newFileptr.write('\n')
                newFileptr.close()
            else:
                print "Trajectory calculation failure - do not save!"
        else:
            print "Save cancelled."

        newFilePtr.close()

        self.blockSignals(False)

    def newLocation(self):
        location = QFileDialog.getSaveFileName(filter="*.bag;;*", directory=os.path.dirname(self.demoLocation.text()))[0]
        if len(location) == 0:
            return
        self.demoLocation.setText(location)
        self.playDemoButton.setEnabled(False)
        self.zeroMarker.clear()
        self.zeroMarker.setEnabled(False)
        self.startTrajectoryButton.setEnabled(True)
        self.startButton.setEnabled(True)
        self.addButton.setEnabled(True)
        self.openHandButton.setEnabled(True)
        self.closeHandButton.setEnabled(True)
        self.endButton.setEnabled(True)

        try:
            os.remove(location)
            self._showStatus("Deleted existing save file.")
        except OSError:
            pass

        if not self.kinesthetic_interaction:
            self._showWarning("Record keyframe demo server unreachable", "Record keyframe demo server isn't loaded. Run `roslaunch hlpr_record_demonstration start_record_services.launch` and restart the GUI.")
            return

        saveFile = self.kinesthetic_interaction.init_demo(location=location, timestamp=self.shouldTimestamp.isChecked())
        self.demoLocation.setText(saveFile)
        self.demoName.setText(os.path.basename(saveFile))
        self.keyframeCount.setText("")
        self.playbackTree.clear()

    def load_directory(self):
        directory = QFileDialog.getExistingDirectory(self, self.tr("Open Directory"), "../")
	self.filenames.extend(os.listdir(directory))
	temp = [directory + '/' + filepath for filepath in os.listdir(directory)]
	self.filelist.extend(temp)
	self.fileLabel.setText('Files: ' + str(self.filenames))
        self.fileLabel.setWordWrap(True)	

    def browseForFolder(self):
        location = QFileDialog.getExistingDirectory(directory=os.path.dirname(self.demoLocation.text()))
        if len(location) == 0:
            return

        self.demoLocation.setText(location)
        self.loadLocation()

    def browseForLocation(self):
        location = QFileDialog.getOpenFileName(filter="*.bag;;*", directory=os.path.dirname(self.demoLocation.text()))[0]
        if len(location) == 0:
            return

        self.demoLocation.setText(location)
        self.loadLocation()

    def _load_dot(self, file_name=None):
        if file_name is None:
            file_name, _ = QFileDialog.getOpenFileName(self._widget, self.tr('Open graph from file'), None, self.tr('DOT graph (*.dot)'))
            if file_name is None or file_name == '':
                return

        try:
            fh = open(file_name, 'rb')
            dotcode = fh.read()
            fh.close()
        except IOError:
            return

        # disable controls customizing fetched ROS graph
        self._widget.depth_combo_box.setEnabled(False)
        self._widget.directions_combo_box.setEnabled(False)
        self._widget.package_type_combo_box.setEnabled(False)
        self._widget.filter_line_edit.setEnabled(False)
        self._widget.with_stacks_check_box.setEnabled(False)
        self._widget.mark_check_box.setEnabled(False)
        self._widget.colorize_check_box.setEnabled(False)
        self._widget.hide_transitives_check_box.setEnabled(False)

        self._update_graph(dotcode)
        self._redraw_graph_scene()

 def _handle_save_clicked(self, checked):
     filename = QFileDialog.getSaveFileName(self, 'Save to File', '.', self.tr('rqt_console msg file {.csv} (*.csv)'))
     if filename[0] != '':
         filename = filename[0]
         if filename[-4:] != '.csv':
             filename += '.csv'
         try:
             handle = open(filename, 'w')
         except IOError as e:
             qWarning(str(e))
             return
         try:
             handle.write(';'.join(MessageDataModel.columns) + '\n')
             for index in range(self._proxy_model.rowCount()):
                 row = self._proxy_model.mapToSource(self._proxy_model.index(index, 0)).row()
                 msg = self._model._messages[row]
                 data = {}
                 data['message'] = msg.message.replace('"', '\\"')
                 data['severity'] = str(msg.severity)
                 data['node'] = msg.node
                 data['stamp'] = str(msg.stamp[0]) + '.' + str(msg.stamp[1]).zfill(9)
                 data['topics'] = ','.join(msg.topics)
                 data['location'] = msg.location
                 line = []
                 for column in MessageDataModel.columns:
                     line.append('"%s"' % data[column])
                 handle.write(';'.join(line) + '\n')
         except Exception as e:
             qWarning('File save failed: %s' % str(e))
             return False
         finally:
             handle.close()
         return True

 def on_open_xml_clicked(self):
     (fileName, _) = QFileDialog.getOpenFileName(self,
                                                 "Load launch file",
                                                 self.__current_path,
                                                 "Config files (*.launch);;All files (*)")
     if fileName:
         self.__current_path = os.path.dirname(fileName)
         self.launchlist_model.add2LoadHistory(fileName)
         self.load_signal.emit(fileName)

    def _on_export_perspective(self):
        file_name, _ = QFileDialog.getSaveFileName(self._menu_manager.menu, self.tr('Export perspective to file'), self._current_perspective + '.perspective', self.tr('Perspectives (*.perspective)'))
        if file_name is None or file_name == '':
            return

        # trigger save of perspective before export
        self._callback = self._on_export_perspective_continued
        self._callback_args = [file_name]
        self.save_settings_signal.emit(self._global_settings, self._perspective_settings)

    def load_file(self):
        filename = QFileDialog.getOpenFileName(self, self.tr("Open File"), "../", self.tr("Yaml (*.yaml)"))
	if os.path.basename(filename[0].encode("ascii")) == "":
	    return

	self.filelist.append(filename[0])
	self.filenames.append(os.path.basename(filename[0].encode("ascii")))
	self.fileLabel.setText('Files: ' + str(self.filenames))
        self.fileLabel.setWordWrap(True)	

 def on_open_xml_clicked(self):
     (fileName, _) = QFileDialog.getOpenFileName(self,
                                                 "Load launch file",
                                                 self.__current_path,
                                                 "Config files (*.launch);;All files (*)")
     if fileName:
         self.__current_path = os.path.dirname(fileName)
         nm.settings().launch_history_add(fileName)
         self.load_signal.emit(fileName, [], None)

    def _save_image(self):
        file_name, _ = QFileDialog.getSaveFileName(self._widget, self.tr('Save as image'), 'rospackgraph.png', self.tr('Image (*.bmp *.jpg *.png *.tiff)'))
        if file_name is None or file_name == '':
            return

        img = QImage((self._scene.sceneRect().size() * 2.0).toSize(), QImage.Format_ARGB32_Premultiplied)
        painter = QPainter(img)
        painter.setRenderHint(QPainter.Antialiasing)
        self._scene.render(painter)
        painter.end()
        img.save(file_name)

    def _save_dot(self):
        file_name, _ = QFileDialog.getSaveFileName(self._widget, self.tr('Save as DOT'), 'rospackgraph.dot', self.tr('DOT graph (*.dot)'))
        if file_name is None or file_name == '':
            return

        handle = QFile(file_name)
        if not handle.open(QIODevice.WriteOnly | QIODevice.Text):
            return

        handle.write(self._current_dotcode)
        handle.close()

    def _import(self):
        file_path, _ = QFileDialog.getOpenFileName(self, self.tr('Import custom graph'),
                                                   None, self.tr('DOT graph (*.dot)'))

        if file_path is None or file_path == '':
            return

        custom_graph = Graph(self._dot_processor, file_path, file_path)
        self.decision_graphs[custom_graph.source] = custom_graph
        self._current_graph = custom_graph

        self.decision_graphs_combo_box.addItem(custom_graph.source)
        self.decision_graphs_combo_box.setCurrentIndex(self.decision_graphs_combo_box.findText(custom_graph.source))

    def _save_svg(self):
        file_name, _ = QFileDialog.getSaveFileName(self._widget, self.tr('Save as SVG'), 'rospackgraph.svg', self.tr('Scalable Vector Graphic (*.svg)'))
        if file_name is None or file_name == '':
            return

        generator = QSvgGenerator()
        generator.setFileName(file_name)
        generator.setSize((self._scene.sceneRect().size() * 2.0).toSize())

        painter = QPainter(generator)
        painter.setRenderHint(QPainter.Antialiasing)
        self._scene.render(painter)
        painter.end()

    def _export(self):
        file_name, _ = QFileDialog.getSaveFileName(
            self, self.tr("Save as image"), "graph.png", self.tr("Image (*.bmp *.jpg *.png *.tiff)")
        )

        if file_name is None or file_name == "":
            return

        img = QImage((self._scene.sceneRect().size() * 2.0).toSize(), QImage.Format_ARGB32_Premultiplied)
        painter = QPainter(img)
        painter.setRenderHint(QPainter.Antialiasing)
        self._scene.render(painter)
        painter.end()
        img.save(file_name)

 def _on_path_select_clicked(self):
     # Workaround for QFileDialog.getExistingDirectory because it do not
     # select the configuration folder in the dialog
     self.dialog = QFileDialog(self, caption='Select a new settings folder')
     self.dialog.setOption(QFileDialog.HideNameFilterDetails, True)
     self.dialog.setFileMode(QFileDialog.Directory)
     self.dialog.setDirectory(self.path)
     if self.dialog.exec_():
         fileNames = self.dialog.selectedFiles()
         path = fileNames[0]
         if os.path.isfile(path):
             path = os.path.basename(path)
         self._lineedit.setText(path)
         self.path = dir
         self.editing_finished_signal.emit()

    def _on_import_perspective(self):
        file_name, _ = QFileDialog.getOpenFileName(self._menu_manager.menu, self.tr('Import perspective from file'), None, self.tr('Perspectives (*.perspective)'))
        if file_name is None or file_name == '':
            return

        perspective_name = os.path.basename(file_name)
        suffix = '.perspective'
        if perspective_name.endswith(suffix):
            perspective_name = perspective_name[:-len(suffix)]
        if perspective_name in self.perspectives:
            perspective_name = self._choose_new_perspective_name(False)
            if perspective_name is None:
                return

        self.import_perspective_from_file(file_name, perspective_name)

class PathEditor(QWidget):
    '''
    This is a path editor used as ItemDeligate in settings view. This editor
    provides an additional button for directory selection dialog.
    '''

    editing_finished_signal = Signal()

    def __init__(self, path, parent=None):
        QWidget.__init__(self, parent)
        self.path = path
        self._layout = QHBoxLayout(self)
        self._layout.setContentsMargins(0, 0, 0, 0)
        self._layout.setSpacing(0)
        self._button = QPushButton('...')
        self._button.setMaximumSize(QSize(24, 20))
        self._button.clicked.connect(self._on_path_select_clicked)
        self._layout.addWidget(self._button)
        self._lineedit = QLineEdit(path)
        self._lineedit.returnPressed.connect(self._on_editing_finished)
        self._layout.addWidget(self._lineedit)
        self.setLayout(self._layout)
        self.setFocusProxy(self._button)
        self.setAutoFillBackground(True)

    def _on_path_select_clicked(self):
        # Workaround for QFileDialog.getExistingDirectory because it do not
        # select the configuration folder in the dialog
        self.dialog = QFileDialog(self, caption='Select a new settings folder')
        self.dialog.setOption(QFileDialog.HideNameFilterDetails, True)
        self.dialog.setFileMode(QFileDialog.Directory)
        self.dialog.setDirectory(self.path)
        if self.dialog.exec_():
            fileNames = self.dialog.selectedFiles()
            path = fileNames[0]
            if os.path.isfile(path):
                path = os.path.basename(path)
            self._lineedit.setText(path)
            self.path = dir
            self.editing_finished_signal.emit()

    def _on_editing_finished(self):
        if self._lineedit.text():
            self.path = self._lineedit.text()
            self.editing_finished_signal.emit()

    def _on_record_settings_selected(self, all_topics, selected_topics):
        # TODO verify master is still running
        filename = QFileDialog.getSaveFileName(self, self.tr('Select prefix for new Bag File'), '.', self.tr('Bag files {.bag} (*.bag)'))
        if filename[0] != '':
            prefix = filename[0].strip()

            # Get filename to record to
            record_filename = time.strftime('%Y-%m-%d-%H-%M-%S.bag', time.localtime(time.time()))
            if prefix.endswith('.bag'):
                prefix = prefix[:-len('.bag')]
            if prefix:
                record_filename = '%s_%s' % (prefix, record_filename)

            rospy.loginfo('Recording to %s.' % record_filename)

            self.load_button.setEnabled(False)
            self._recording = True
            self._timeline.record_bag(record_filename, all_topics, selected_topics)