def create_application(self, argv):
     from python_qt_binding.QtCore import Qt
     from python_qt_binding.QtGui import QApplication
     # QApplication.setAttribute(Qt.AA_X11InitThreads, True)
     app = QApplication(argv)
     app.setAttribute(Qt.AA_DontShowIconsInMenus, False)
     return app

def main(name):
  try:
    from python_qt_binding.QtGui import QApplication
  except:
    print >> sys.stderr, "please install 'python_qt_binding' package!!"
    sys.exit(-1)

  masteruri = init_cfg_path()
  parser = init_arg_parser()
  args = rospy.myargv(argv=sys.argv)
  parsed_args = parser.parse_args(args[1:])
  # Initialize Qt
  global app
  app = QApplication(sys.argv)

  # decide to show main or echo dialog
  global main_form
  if parsed_args.echo:
    main_form = init_echo_dialog(name, masteruri, parsed_args.echo[0], parsed_args.echo[1], parsed_args.hz)
  else:
    main_form = init_main_window(name, masteruri, parsed_args.file)

  # resize and show the qt window
  if not rospy.is_shutdown():
    os.chdir(PACKAGE_DIR) # change path to be able to the images of descriptions
    main_form.resize(1024, 720)
    screen_size = QApplication.desktop().availableGeometry()
    if main_form.size().width() >= screen_size.width() or main_form.size().height() >= screen_size.height()-24:
      main_form.showMaximized()
    else:
      main_form.show()
    exit_code = -1
    rospy.on_shutdown(finish)
    exit_code = app.exec_()

 def on_launch_selection_activated(self, activated):
     '''
     Tries to load the launch file, if one was activated.
     '''
     selected = self._launchItemsFromIndexes(self.xmlFileView.selectionModel().selectedIndexes(), False)
     for item in selected:
         try:
             lfile = self.launchlist_model.expandItem(item.name, item.path, item.id)
             self.searchPackageLine.setText('')
             if lfile is not None:
                 if item.isLaunchFile():
                     nm.settings().launch_history_add(item.path)
                     key_mod = QApplication.keyboardModifiers()
                     if key_mod & Qt.ShiftModifier:
                         self.load_as_default_signal.emit(item.path, None)
                     elif key_mod & Qt.ControlModifier:
                         self.launchlist_model.setPath(os.path.dirname(item.path))
                     else:
                         self.load_signal.emit(item.path, [], None)
                 elif item.isProfileFile():
                     nm.settings().launch_history_add(item.path)
                     key_mod = QApplication.keyboardModifiers()
                     if key_mod & Qt.ControlModifier:
                         self.launchlist_model.setPath(os.path.dirname(item.path))
                     else:
                         self.load_profile_signal.emit(item.path)
                 elif item.isConfigFile():
                     self.edit_signal.emit([lfile])
         except Exception as e:
             rospy.logwarn("Error while load launch file %s: %s" % (item, utf8(e)))
             MessageBox.warning(self, "Load error",
                                'Error while load launch file:\n%s' % item.name,
                                "%s" % utf8(e))

 def expandItem(self, path_item, path, item_id):
     '''
     Returns for the given item and path the file path if this is a file. Otherwise the
     folder will be expanded and None will be returned.
     @param path_item: the list item
     @type path_item: C{str}
     @param path: the real path of the item
     @type path: C{str}
     @return: path of the launch file or None
     @rtype: C{str}
     @raise Exception if no path to given item was found
     '''
     if path_item == '..':
         goto_path = os.path.dirname(path)
         key_mod = QApplication.keyboardModifiers()
         if key_mod & Qt.ControlModifier:
             goto_path = None
         root_path, items = self._moveUp(goto_path)
     elif os.path.isfile(path):
         return path
     elif item_id == LaunchItem.RECENT_FILE or item_id == LaunchItem.LAUNCH_FILE:
         raise Exception("Invalid file path: %s", path)
     else:
         key_mod = QApplication.keyboardModifiers()
         onestep = False
         if key_mod & Qt.ControlModifier:
             onestep = True
         root_path, items = self._moveDown(path, onestep)
     self._setNewList((root_path, items))
     return None

def main():
    app = QApplication(sys.argv)
    
    test_g = MainWidget()
    test_g.show()
    
    return app.exec_()

 def __init__(self, img):
     splash_pix = QPixmap(img)
     self.splash = QSplashScreen(splash_pix, Qt.WindowStaysOnTopHint)
     self.splash.setMask(splash_pix.mask())
     self.splash.show()
     for i in range(100):
         time.sleep(0.01)
         QApplication.processEvents()

def main(name):
    '''
    Start the NodeManager or EchoDialog.
    :param name: the name propagated to the rospy.init_node()
    :type name: str
    '''
    try:
        from python_qt_binding.QtGui import QApplication
    except:
        try:
            from python_qt_binding.QtWidgets import QApplication
        except:
            print >> sys.stderr, "please install 'python_qt_binding' package!!"
            sys.exit(-1)

    init_settings()
    parser = init_arg_parser()
    args = rospy.myargv(argv=sys.argv)
    parsed_args = parser.parse_args(args[1:])
    if parsed_args.muri:
        masteruri = parsed_args.muri[0]
        hostname = NameResolution.get_ros_hostname(masteruri)
        os.environ['ROS_MASTER_URI'] = masteruri
        if hostname:
            os.environ['ROS_HOSTNAME'] = hostname
    masteruri = settings().masteruri()
    # Initialize Qt
    global _QAPP
    _QAPP = QApplication(sys.argv)

    # decide to show main or echo dialog
    global _MAIN_FORM
    try:
        if parsed_args.echo:
            _MAIN_FORM = init_echo_dialog(name, masteruri, parsed_args.echo[0],
                                          parsed_args.echo[1], parsed_args.hz,
                                          parsed_args.ssh)
        else:
            _MAIN_FORM = init_main_window(name, masteruri, parsed_args.file)
    except Exception as err:
        sys.exit("%s" % err)

    exit_code = 0
    # resize and show the qt window
    if not rospy.is_shutdown():
        # change path for access to the images of descriptions
        os.chdir(settings().PACKAGE_DIR)
#    _MAIN_FORM.resize(1024, 720)
        screen_size = QApplication.desktop().availableGeometry()
        if (_MAIN_FORM.size().width() >= screen_size.width() or
                _MAIN_FORM.size().height() >= screen_size.height() - 24):
            _MAIN_FORM.showMaximized()
        else:
            _MAIN_FORM.show()
        exit_code = -1
        rospy.on_shutdown(finish)
        exit_code = _QAPP.exec_()
    return exit_code

 def copy_to_clipboard(self, indexes):
     '''
     Copy the selected path to the clipboard
     '''
     mimeData = QMimeData()
     text = ''
     for index in indexes:
         if index.isValid():
             item = self.itemFromIndex(index)
             prev = '%s\n' % text if text else ''
             text = '%sfile://%s' % (prev, item.path)
     mimeData.setData('text/plain', text.encode('utf-8'))
     QApplication.clipboard().setMimeData(mimeData)

    def paint(self, painter, option, index):
        if index.column() in [0,3]:
            return super(GroupsDelegate, self).paint(painter, option, index)

        button = QStyleOptionButton()
        r = option.rect
        x = r.left() + r.width() - 30
        y = r.top()+ 2
        w = 28
        h = 14
        button.rect = QRect(x,y,w,h)
        button.text = '+' if index.column() == 1 else '-'
        button.state = QStyle.State_Enabled

        QApplication.style().drawControl(QStyle.CE_PushButton, button, painter)

 def closeEvent(self, event):
     if self.sub is not None:
         self.sub.unregister()
         del self.sub
     try:
         self.ssh_output_file.close()
         self.ssh_error_file.close()
         # send Ctrl+C to remote process
         self.ssh_input_file.write("%s\n" % chr(3))
         self.ssh_input_file.close()
     except:
         pass
     self.finished_signal.emit(self.topic)
     if self.parent() is None:
         QApplication.quit()

def run(gui,debug=False):
    """
    @param gui: The gui to render and execute
    """
    
    if debug:
        str_traverse = StringTraverse()
        gui.traverse(str_traverse)
        
    rospy.init_node("guiname")
    code_traverse = pyqtTraverse()
    
    app = QApplication(sys.argv)
    
    gui.traverse(code_traverse)
    sys.exit(app.exec_())

 def keyPressEvent(self, event):
     '''
     Defines some of shortcuts for navigation/management in launch
     list view or topics view.
     '''
     key_mod = QApplication.keyboardModifiers()
     if not self.xmlFileView.state() == QAbstractItemView.EditingState:
         # remove history file from list by pressing DEL
         if event == QKeySequence.Delete:
             selected = self._launchItemsFromIndexes(self.xmlFileView.selectionModel().selectedIndexes(), False)
             for item in selected:
                 nm.settings().launch_history_remove(item.path)
                 self.launchlist_model.reloadCurrentPath()
         elif not key_mod and event.key() == Qt.Key_F4 and self.editXmlButton.isEnabled():
             # open selected launch file in xml editor by F4
             self.on_edit_xml_clicked()
         elif event == QKeySequence.Find:
             # set focus to filter box for packages
             self.searchPackageLine.setFocus(Qt.ActiveWindowFocusReason)
         elif event == QKeySequence.Paste:
             # paste files from clipboard
             self.launchlist_model.paste_from_clipboard()
         elif event == QKeySequence.Copy:
             # copy the selected items as file paths into clipboard
             selected = self.xmlFileView.selectionModel().selectedIndexes()
             indexes = []
             for s in selected:
                 indexes.append(self.launchlist_proxyModel.mapToSource(s))
             self.launchlist_model.copy_to_clipboard(indexes)
     if self.searchPackageLine.hasFocus() and event.key() == Qt.Key_Escape:
         # cancel package filtering on pressing ESC
         self.launchlist_model.show_packages(False)
         self.searchPackageLine.setText('')
         self.xmlFileView.setFocus(Qt.ActiveWindowFocusReason)
     QDockWidget.keyReleaseEvent(self, event)

    def paint(self, painter, option, index):
        '''
        Use the QTextDokument to represent the HTML text.
        @see: U{http://www.pyside.org/docs/pyside/PySide/QtGui/QAbstractItemDelegate.html#PySide.QtGui.QAbstractItemDelegate}
        '''
        options = QStyleOptionViewItem(option)
        self.initStyleOption(options, index)

        style = QApplication.style() if options.widget is None else options.widget.style()

        doc = QTextDocument()
        doc.setHtml(self.toHTML(options.text))
        doc.setTextWidth(option.rect.width())

        options.text = ''
        style.drawControl(QStyle.CE_ItemViewItem, options, painter)

        ctx = QAbstractTextDocumentLayout.PaintContext()

        # Highlighting text if item is selected
        # if (optionV4.state and QStyle::State_Selected):
        #  ctx.palette.setColor(QPalette::Text, optionV4.palette.color(QPalette::Active, QPalette::HighlightedText));

        textRect = style.subElementRect(QStyle.SE_ItemViewItemText, options, options.widget)
        painter.save()
        painter.translate(QPoint(textRect.topLeft().x(), textRect.topLeft().y() - 3))
        painter.setClipRect(textRect.translated(-textRect.topLeft()))
        doc.documentLayout().draw(painter, ctx)

        painter.restore()

 def paste_from_clipboard(self):
     '''
     Copy the file or folder to new position...
     '''
     if QApplication.clipboard().mimeData().hasText() and self.currentPath:
         text = QApplication.clipboard().mimeData().text()
         if text.startswith('file://'):
             path = text.replace('file://', '')
             basename = os.path.basename(text)
             ok = True
             if os.path.exists(os.path.join(self.currentPath, basename)):
                 basename, ok = QInputDialog.getText(None, 'File exists', 'New name (or override):', QLineEdit.Normal, basename)
             if ok and basename:
                 if os.path.isdir(path):
                     shutil.copytree(path, os.path.join(self.currentPath, basename))
                 elif os.path.isfile(path):
                     shutil.copy2(path, os.path.join(self.currentPath, basename))
                 self.reloadCurrentPath()

def main(name, anonymous=False):
  masteruri = init_cfg_path()

  args = rospy.myargv(argv=sys.argv)
  # decide to show main or echo dialog
  if len(args) >= 4 and args[1] == '-t':
    name = ''.join([name, '_echo'])
    anonymous = True

  try:
    from python_qt_binding.QtGui import QApplication
  except:
    print >> sys.stderr, "please install 'python-pyside' package!!"
    sys.exit(-1)
  rospy.init_node(name, anonymous=anonymous, log_level=rospy.DEBUG)
  setTerminalName(rospy.get_name())
  setProcessName(rospy.get_name())

  # Initialize Qt
  global app
  app = QApplication(sys.argv)

  # decide to show main or echo dialog
  import main_window, echo_dialog
  global main_form
  if len(args) >= 4 and args[1] == '-t':
    show_hz_only = (len(args) > 4 and args[4] == '--hz')
    main_form = echo_dialog.EchoDialog(args[2], args[3], show_hz_only, masteruri)
  else:
    local_master = init_globals(masteruri)

    #start the gui
    main_form = main_window.MainWindow(args, not local_master)

  if not rospy.is_shutdown():
    os.chdir(PACKAGE_DIR) # change path to be able to the images of descriptions
    main_form.show()
    exit_code = -1
    rospy.on_shutdown(finish)
    exit_code = app.exec_()

 def _copy_text_to_clipboard(self):
     # Get tab indented text for all selected items
     def get_distance(item, ancestor, distance=0):
         parent = item.parent()
         if parent == None:
             return distance
         else:
             return get_distance(parent, ancestor, distance + 1)
     text = ''
     for i in self.get_all_items():
         if i in self.selectedItems():
             text += ('\t' * (get_distance(i, None))) + i.text(0) + '\n'
     # Copy the text to the clipboard
     clipboard = QApplication.clipboard()
     clipboard.setText(text)

 def on_search_result_on_open(self, search_text, found, path, index):
     '''
     Like on_search_result, but skips the text in comments.
     '''
     if found:
         if self.tabWidget.currentWidget().filename != path:
             focus_widget = QApplication.focusWidget()
             self.on_load_request(path)
             focus_widget.setFocus()
         comment_start = self.tabWidget.currentWidget().document().find('<!--', index, QTextDocument.FindBackward)
         if not comment_start.isNull():
             comment_end = self.tabWidget.currentWidget().document().find('-->', comment_start)
             if not comment_end.isNull() and comment_end.position() > index + len(search_text):
                 # commented -> retrun
                 return
     self.on_search_result(search_text, found, path, index)

 def on_load_as_default(self):
     '''
     Tries to load the selected launch file as default configuration. The button
     is only enabled and this method is called, if the button was enabled by
     on_launch_selection_clicked()
     '''
     key_mod = QApplication.keyboardModifiers()
     if (key_mod & Qt.ShiftModifier):
         self.loadXmlAsDefaultButton.showMenu()
     else:
         selected = self._launchItemsFromIndexes(self.xmlFileView.selectionModel().selectedIndexes(), False)
         for item in selected:
             path = self.launchlist_model.expandItem(item.name, item.path, item.id)
             if path is not None:
                 rospy.loginfo("LOAD the launch file as default: %s", path)
                 self.launchlist_model.add2LoadHistory(path)
                 self.load_as_default_signal.emit(path, None)

 def on_search_result(self, search_text, found, path, index):
     '''
     A slot to handle a found text. It goes to the position in the text and select
     the searched text. On new file it will be open.
     :param search_text: the searched text
     :type search_text: str
     :param found: the text was found or not
     :type found: bool
     :param path: the path of the file the text was found
     :type path: str
     :param index: the position in the text
     :type index: int
     '''
     if found:
         if self.tabWidget.currentWidget().filename != path:
             focus_widget = QApplication.focusWidget()
             self.on_load_request(path)
             focus_widget.setFocus()
         cursor = self.tabWidget.currentWidget().textCursor()
         cursor.setPosition(index, QTextCursor.MoveAnchor)
         cursor.movePosition(QTextCursor.NextCharacter, QTextCursor.KeepAnchor, len(search_text))
         self.tabWidget.currentWidget().setTextCursor(cursor)

        self.testButton.clicked.disconnect(self.oneButtonAvailable);        
        self.testButton.clicked.connect(self.noSetAvailable);
        
    def noSetAvailable(self):
        testButtonSetArray = [];
        buttonSetChoiceDialog = ButtonSetPopupSelector(iter(testButtonSetArray));
        #buttonSetChoiceDialog.show();
        choiceResult = buttonSetChoiceDialog.exec_();
        print "Choice result: " + str(choiceResult);
        buttonSetChoiceDialog.deleteLater();
        
        # Rewire the test button for the next text:
        self.testButton.setText("Exit");
        self.testButton.clicked.disconnect(self.noSetAvailable);        
        self.testButton.clicked.connect(self.close);
        
    def exitApp(self):
        self.close();
    
if __name__ == "__main__":
    
    style = QStyleFactory.create("Cleanlooks");
    QApplication.setStyle(style);
    app = QApplication(sys.argv);

    theTester = Tester();
    
        
    # Enter Qt application main loop
    sys.exit(app.exec_());