C++ Q_CHECK_PTR函数代码示例

void menu::recurse(QMenu *cm, QFile &istr)
{
	QString p1,p2,p3;
	
	while(! istr.atEnd())
	{
		QTextStream til(istr.readLine(1024));

		til >> p1;  // command 
		if(p1.isEmpty() || p1 == "#")
			continue;
		
		if(p1 == "End")
			return;

		if(p1 == "Separator")
		{
			cm->addSeparator();
			continue;
		}	

		til >> p2;            // menu label
		
		if(p2.isEmpty())
			continue;

		p3 = til.readLine();  // command line

		if(p2[0] == '"')
		{
			if(p2[p2.length()-1] != '"')
			{
				int i = p3.indexOf('"');
				if(i == -1)
					continue;
				
				p2 += p3.left(i);
				p2 = p2.mid(1, p2.length()-1);
				p3 = p3.right(p3.length()-i-1);
			}
			else p2 = p2.mid(1, p2.length()-2);
		}
		
		if(p1 == "Menu")
		{
			QMenu *nm = new QMenu(p2);
			Q_CHECK_PTR(nm);
			cm->addMenu(nm);
			recurse(nm, istr);
			continue;
		}

		if(p1 == "Quit")
		{
			act_quit->setText(p2);
			cm->addAction(act_quit);
			continue;
		}
		
		if(p1 == "Kill")
		{
			act_kill->setText(p2);
			cm->addAction(act_kill);
			continue;
		}	

		if(p1 == "Restart")
		{
			act_rest->setText(p2);
			cm->addAction(act_rest);
			continue;
		}	
		
		if(p1 != "Entry")
			continue;

		p3 = p3.simplified();
		
		if(p3.isEmpty())
			continue;
			
		QAction *act_run = new QAction(p2, cm);
		act_run->setData(QVariant(p3));
		cm->addAction(act_run);
	}
}	

WatchItemBase * ConnectorBoolIn::makeWatchItem()
{
	WatchItemBase * wi = new WatchItemBooleanConnector(this);
	Q_CHECK_PTR(wi);
	return wi;
}

ScPlugin* subdivide_getPlugin()
{
	SubdividePlugin* plug = new SubdividePlugin();
	Q_CHECK_PTR(plug);
	return plug;
}

QWidget* OptionsDialog::getVariantWidget(const QVariant& v, const QString& message) {
     QWidget* pwidget = NULL;
     QLineEdit *plineedit = NULL;
     QSpinBox *pspinbox;
     QDoubleSpinBox *pdoublespinbox;
     QCheckBox *pcheckbox;
     QComboBox *pcombobox;
     bool ok;
     QRect rect;
     QString currentitem;

     QStringList combolist;
     QStringList editlist;
     InflowEditQListWidget *editlistwidget;
     int currenti = -1, i = 0;
     switch( v.type() ) {
          case QVariant::String:
                   combolist = v.toString().split(",", QString::SkipEmptyParts);
                   if (combolist.count() > 1 ) {
                       pwidget = new QComboBox(this);
                       pcombobox = qobject_cast<QComboBox*>(pwidget);
                       Q_CHECK_PTR(pcombobox);
                       for( i = 0; i < combolist.count(); i++) {
                             currentitem = combolist.at(i);
                             if (currentitem.endsWith("+") ) {
                                 currenti = i;
                                 currentitem.chop(1);

                             }
                            pcombobox->addItem(currentitem);
                       }
                       if ( currenti >= 0 && currenti < pcombobox->count() ) {
                           pcombobox->setCurrentIndex( currenti );
                       }
                       break;
                   }

                   if ( v.toString().endsWith(";") ) {
                       editlist = v.toString().split(";", QString::SkipEmptyParts);
                       pwidget = new InflowEditQListWidget(this);
                       editlistwidget = (qobject_cast<InflowEditQListWidget*>(pwidget));
                       Q_CHECK_PTR( editlistwidget );
                       editlistwidget->buildWidget();
                       editlistwidget->setEditList(editlist);
                       break;
                   }
                   pwidget = new QLineEdit(v.toString() );
                   pwidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding );
                   //rect = pwidget->geometry();
                   //rect.setWidth(350);
                   //pwidget->setGeometry(rect);
                   if (message.contains(QRegExp(tr("contrase[nñ]a|password|clave|pin"),Qt::CaseInsensitive)) ) {
                        plineedit = qobject_cast<QLineEdit*>(pwidget);
                        Q_CHECK_PTR( plineedit );
                        plineedit->setEchoMode(QLineEdit::Password);
                   }
               break;
          case QVariant::Bool:
                   pwidget = new QCheckBox("",this);
                   pcheckbox = qobject_cast<QCheckBox*>(pwidget);
                   if ( v.toBool() ) {
                         pcheckbox->setCheckState(Qt::Checked);
                   }
                   else {
                        pcheckbox->setCheckState(Qt::Unchecked);
                   }
                   break;
          case QVariant::Int:
                   pwidget = new QSpinBox();
                   pspinbox = qobject_cast<QSpinBox*>(pwidget);
                   pspinbox->setValue( v.toInt() );
               break;
          case QVariant::Double:
                    pwidget = new QDoubleSpinBox();
                    pdoublespinbox = qobject_cast<QDoubleSpinBox*>(pwidget);
                    pdoublespinbox->setValue( v.toDouble(&ok) );
               break;
          case QVariant::Date:
                    break;
          case QVariant::DateTime:
                    break;

          default:
               break;

     }
     return pwidget;

}

void NBioBSPRollDemo_Widget::Initialize()
{
   //Create a groupbox which layouts its childs in a columns
   // Device Function
   gbox_Device = new QButtonGroup(0, QGroupBox::Vertical, "Device Function", this); 
   gbox_Device->setGeometry(5,7,520,60);
   gbox_Device->setLineWidth(1);
  
   lbl_Device = new QLabel("Device List", this);
   //lbl_Device->setText("Device List");
   lbl_Device->setGeometry(15,40,80,10);
   
   cb_DEV_LIST = new QComboBox(FALSE, gbox_Device);
   Q_CHECK_PTR(cb_DEV_LIST);
   //cb_DEV_LIST->insertStrList(DeviceList, 1);
   cb_DEV_LIST->setGeometry(100,25,250,30);
   connect(cb_DEV_LIST, SIGNAL(activated(int)), this, SLOT(OnComboDeviceList()));
   //cb_DEV_LIST->setCurrentItem(0);
   m_DeviceID = NBioAPI_DEVICE_ID_AUTO;
   
   pb_OPEN = new QPushButton("&Open", gbox_Device, "Open");
   pb_OPEN->setGeometry(360, 25, 150, 30);
   connect(pb_OPEN, SIGNAL(clicked()), this, SLOT(OnBtnOpenDevice()));	
    
   ////////////////////////////////////////////////////////////////  
   // Capture Function   
   gbox_Capture = new QButtonGroup(0, QGroupBox::Vertical, "Capture Function", this); 
   gbox_Capture->setGeometry(5,90,490,355);
   gbox_Capture->setLineWidth(1);
   
   // Create a nice frame to put around the OpenGL widget	
   m_frmRoll = new QFrame(gbox_Capture, "CaptureFunction");
   m_frmRoll->setFrameStyle(QFrame::Sunken | QFrame::Panel);
   m_frmRoll->setLineWidth(1);
   m_frmRoll->setGeometry(5, 25, 300, 300);
   m_frmRoll->unsetPalette();
       
   ////////////////////////////////////////////////////////////////  
   // UI Setting   
   gbox_UISet = new QButtonGroup(0, QGroupBox::Vertical, "UI Setting", this); 
   gbox_UISet->setGeometry(310, 90, 565,140);
   gbox_UISet->setLineWidth(1);
   
   rb_DrawImageY = new QRadioButton("Yes,(Finger image drawing)", gbox_UISet, "rbDrawImageY");
   rb_DrawImageY->setGeometry(5, 20, 260, 20);
   connect(rb_DrawImageY, SIGNAL(clicked()), this, SLOT(OnRadioYes()));
   rb_DrawImageY->setChecked(true);
   m_ScanType = 1;
   
   rb_DrawImageN = new QRadioButton("No,(Finger image drawing)", gbox_UISet, "rbDrawImageY");
   rb_DrawImageN->setGeometry(5, 41, 260, 20);
   connect(rb_DrawImageN, SIGNAL(clicked()), this, SLOT(OnRadioNo()));
   
   gbox_UISet->setEnabled(false);  
   rb_DrawImageY->setEnabled(false);
   rb_DrawImageN->setEnabled(false);
   ////////////////////////////////////////////////////////////////  
   // Roll Capture 
   gbox_Type2 = new QButtonGroup(0, QGroupBox::Vertical, "Roll Capture", this); 
   gbox_Type2->setGeometry(310, 170, 510, 200);
   gbox_Type2->setLineWidth(1);
   
   pb_RollStart = new QPushButton("&Roll Live Capture Start", gbox_Type2, "ppRollStart");
   pb_RollStart->setGeometry(5, 20, 210, 30);
   connect(pb_RollStart, SIGNAL(clicked()), this, SLOT(OnBtnStart()));	
   pb_RollStart->setEnabled(false);
      
   ////////////////////////////////////////////////////////////////  
   // Match 
   gbox_Match = new QButtonGroup(0, QGroupBox::Vertical, "VerifyMatch", this); 
   gbox_Match->setGeometry(310,270,520,270);
   gbox_Match->setLineWidth(1);
   
   pb_RollMatch = new QPushButton("&Verify Match", gbox_Match, "VerifyMatch");
   pb_RollMatch->setGeometry(5, 20, 210, 30);
   connect(pb_RollMatch, SIGNAL(clicked()), this, SLOT(OnBtnVerifyMatch()));
   pb_RollMatch->setEnabled(false);
   
   pb_EXIT = new QPushButton("&Exit", gbox_Match, "VerifyMatch");
   pb_EXIT->setGeometry(5, 55, 210,30 );
   connect(pb_EXIT, SIGNAL(clicked()), this, SLOT(OnBtnExit()));
}

ScPlugin* pathconnect_getPlugin()
{
	PathConnectPlugin* plug = new PathConnectPlugin();
	Q_CHECK_PTR(plug);
	return plug;
}

ScPlugin* scribusexportpixmap_getPlugin()
{
	PixmapExportPlugin* plug = new PixmapExportPlugin();
	Q_CHECK_PTR(plug);
	return plug;
}

ScPlugin* pathfinder_getPlugin()
{
	PathFinderPlugin* plug = new PathFinderPlugin();
	Q_CHECK_PTR(plug);
	return plug;
}

MatchScheduler::MatchScheduler(TopWidget *const &parent) :
    parent(parent) {
    Q_CHECK_PTR(parent);
    qDebug() << parent;
}

ScPlugin* lenseffects_getPlugin()
{
	LensEffectsPlugin* plug = new LensEffectsPlugin();
	Q_CHECK_PTR(plug);
	return plug;
}

void QDnsLookupRunnable::query(const int requestType, const QByteArray &requestName, const QHostAddress &nameserver, QDnsLookupReply *reply)
{
    // Load dn_expand, res_ninit and res_nquery on demand.
    static QBasicAtomicInt triedResolve = Q_BASIC_ATOMIC_INITIALIZER(false);
    if (!triedResolve.loadAcquire()) {
        QMutexLocker locker(QMutexPool::globalInstanceGet(&local_res_ninit));
        if (!triedResolve.load()) {
            resolveLibrary();
            triedResolve.storeRelease(true);
        }
    }

    // If dn_expand, res_ninit or res_nquery is missing, fail.
    if (!local_dn_expand || !local_res_nclose || !local_res_ninit || !local_res_nquery) {
        reply->error = QDnsLookup::ResolverError;
        reply->errorString = tr("Resolver functions not found");
        return;
    }

    // Initialize state.
    struct __res_state state;
    memset(&state, 0, sizeof(state));
    if (local_res_ninit(&state) < 0) {
        reply->error = QDnsLookup::ResolverError;
        reply->errorString = tr("Resolver initialization failed");
        return;
    }

    //Check if a nameserver was set. If so, use it
    if (!nameserver.isNull()) {
        if (nameserver.protocol() == QAbstractSocket::IPv4Protocol) {
            state.nsaddr_list[0].sin_addr.s_addr = htonl(nameserver.toIPv4Address());
            state.nscount = 1;
        } else if (nameserver.protocol() == QAbstractSocket::IPv6Protocol) {
#if defined(Q_OS_LINUX)
            struct sockaddr_in6 *ns;
            ns = state._u._ext.nsaddrs[0];
            // nsaddrs will be NULL if no nameserver is set in /etc/resolv.conf
            if (!ns) {
                // Memory allocated here will be free'd in res_close() as we
                // have done res_init() above.
                ns = (struct sockaddr_in6*) calloc(1, sizeof(struct sockaddr_in6));
                Q_CHECK_PTR(ns);
                state._u._ext.nsaddrs[0] = ns;
            }
            // Set nsmap[] to indicate that nsaddrs[0] is an IPv6 address
            // See: https://sourceware.org/ml/libc-hacker/2002-05/msg00035.html
            state._u._ext.nsmap[0] = MAXNS + 1;
            state._u._ext.nscount6 = 1;
            ns->sin6_family = AF_INET6;
            ns->sin6_port = htons(53);

            Q_IPV6ADDR ipv6Address = nameserver.toIPv6Address();
            for (int i=0; i<16; i++) {
                ns->sin6_addr.s6_addr[i] = ipv6Address[i];
            }
#else
            qWarning() << Q_FUNC_INFO << "IPv6 addresses for nameservers is currently not supported";
            reply->error = QDnsLookup::ResolverError;
            reply->errorString = tr("IPv6 addresses for nameservers is currently not supported");
            return;
#endif
        }
    }
#ifdef QDNSLOOKUP_DEBUG
    state.options |= RES_DEBUG;
#endif
    QScopedPointer<struct __res_state, QDnsLookupStateDeleter> state_ptr(&state);

    // Perform DNS query.
    unsigned char response[PACKETSZ];
    memset(response, 0, sizeof(response));
    const int responseLength = local_res_nquery(&state, requestName, C_IN, requestType, response, sizeof(response));

    // Check the response header.
    HEADER *header = (HEADER*)response;
    const int answerCount = ntohs(header->ancount);
    switch (header->rcode) {
    case NOERROR:
        break;
    case FORMERR:
        reply->error = QDnsLookup::InvalidRequestError;
        reply->errorString = tr("Server could not process query");
        return;
    case SERVFAIL:
        reply->error = QDnsLookup::ServerFailureError;
        reply->errorString = tr("Server failure");
        return;
    case NXDOMAIN:
        reply->error = QDnsLookup::NotFoundError;
        reply->errorString = tr("Non existent domain");
        return;
    case REFUSED:
        reply->error = QDnsLookup::ServerRefusedError;
        reply->errorString = tr("Server refused to answer");
        return;
    default:
        reply->error = QDnsLookup::InvalidReplyError;
        reply->errorString = tr("Invalid reply received");
        return;
//.........这里部分代码省略.........

KisImageBuilder_Result PSDLoader::decode(const KUrl& uri)
{
    // open the file
    QFile f(uri.toLocalFile());
    if (!f.exists()) {
        return KisImageBuilder_RESULT_NOT_EXIST;
    }
    if (!f.open(QIODevice::ReadOnly)) {
        return KisImageBuilder_RESULT_FAILURE;
    }

    dbgFile << "pos:" << f.pos();

    PSDHeader header;
    if (!header.read(&f)) {
        dbgFile << "failed reading header: " << header.error;
        return KisImageBuilder_RESULT_FAILURE;
    }

    dbgFile << header;
    dbgFile << "Read header. pos:" << f.pos();

    PSDColorModeBlock colorModeBlock(header.colormode);
    if (!colorModeBlock.read(&f)) {
        dbgFile << "failed reading colormode block: " << colorModeBlock.error;
        return KisImageBuilder_RESULT_FAILURE;
    }

    dbgFile << "Read color mode block. pos:" << f.pos();

    PSDResourceSection resourceSection;
    if (!resourceSection.read(&f)) {
        dbgFile << "failed reading resource section: " << resourceSection.error;
        return KisImageBuilder_RESULT_FAILURE;
    }

    dbgFile << "Read resource section. pos:" << f.pos();

    PSDLayerSection layerSection(header);
    if (!layerSection.read(&f)) {
        dbgFile << "failed reading layer section: " << layerSection.error;
        return KisImageBuilder_RESULT_FAILURE;
    }
    // XXX: add all the image resource blocks as annotations to the image

    dbgFile << "Read layer section. " << layerSection.nLayers << "layers. pos:" << f.pos();

    // Get the right colorspace
    QPair<QString, QString> colorSpaceId = psd_colormode_to_colormodelid(header.colormode,
                                                                         header.channelDepth);
    if (colorSpaceId.first.isNull()) return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;

    // Get the icc profile!
    const KoColorProfile* profile = 0;
    if (resourceSection.resources.contains(PSDResourceSection::ICC_PROFILE)) {
        ICC_PROFILE_1039 *iccProfileData = dynamic_cast<ICC_PROFILE_1039*>(resourceSection.resources[PSDResourceSection::ICC_PROFILE]->resource);
        if (iccProfileData ) {
            profile = KoColorSpaceRegistry::instance()->createColorProfile(colorSpaceId.first,
                                                                       colorSpaceId.second,
                                                                       iccProfileData->icc);
            dbgFile  << "Loaded ICC profile" << profile->name();
        }

    }

    // Create the colorspace
    const KoColorSpace* cs = KoColorSpaceRegistry::instance()->colorSpace(colorSpaceId.first, colorSpaceId.second, profile);
    if (!cs) {
        return KisImageBuilder_RESULT_UNSUPPORTED_COLORSPACE;
    }

    // Creating the KisImageWSP
    m_image = new KisImage(m_doc->createUndoStore(),  header.width, header.height, cs, "built image");
    Q_CHECK_PTR(m_image);
    m_image->lock();

    // set the correct resolution
    if (resourceSection.resources.contains(PSDResourceSection::RESN_INFO)) {
        RESN_INFO_1005 *resInfo = dynamic_cast<RESN_INFO_1005*>(resourceSection.resources[PSDResourceSection::RESN_INFO]->resource);
        if (resInfo) {
            m_image->setResolution(POINT_TO_INCH(resInfo->hRes), POINT_TO_INCH(resInfo->vRes));
            // let's skip the unit for now; we can only set that on the KoDocument, and krita doesn't use it.
        }
    }
    // Preserve the duotone colormode block for saving back to psd
    if (header.colormode == DuoTone) {
        KisAnnotationSP annotation = new KisAnnotation("DuotoneColormodeBlock",
                                                       i18n("Duotone Colormode Block"),
                                                       colorModeBlock.data);
        m_image->addAnnotation(annotation);
    }

    // read the projection into our single layer
    if (layerSection.nLayers == 0) {
        dbgFile << "Position" << f.pos() << "Going to read the projection into the first layer, which Photoshop calls 'Background'";

        KisPaintLayerSP layer = new KisPaintLayer(m_image, i18n("Background"), OPACITY_OPAQUE_U8);
        KisTransaction("", layer -> paintDevice());

        PSDImageData imageData(&header);
//.........这里部分代码省略.........

KisImportExportFilter::ConversionStatus KisHeightMapExport::convert(const QByteArray& from, const QByteArray& to)
{
    dbgFile << "HeightMap export! From:" << from << ", To:" << to;

    if (from != "application/x-krita")
        return KisImportExportFilter::NotImplemented;

    KisDocument *inputDoc = inputDocument();
    QString filename = outputFile();

    if (!inputDoc)
        return KisImportExportFilter::NoDocumentCreated;

    if (filename.isEmpty()) return KisImportExportFilter::FileNotFound;

    KisImageWSP image = inputDoc->image();
    Q_CHECK_PTR(image);

    if (inputDoc->image()->width() != inputDoc->image()->height()) {
        inputDoc->setErrorMessage(i18n("Cannot export this image to a heightmap: it is not square"));
        return KisImportExportFilter::WrongFormat;
    }

    if (inputDoc->image()->colorSpace()->colorModelId() != GrayAColorModelID) {
        inputDoc->setErrorMessage(i18n("Cannot export this image to a heightmap: it is not grayscale"));
        return KisImportExportFilter::WrongFormat;
    }

    KoDialog* kdb = new KoDialog(0);
    kdb->setWindowTitle(i18n("HeightMap Export Options"));
    kdb->setButtons(KoDialog::Ok | KoDialog::Cancel);

    Ui::WdgOptionsHeightMap optionsHeightMap;

    QWidget* wdg = new QWidget(kdb);
    optionsHeightMap.setupUi(wdg);

    kdb->setMainWidget(wdg);
    QApplication::restoreOverrideCursor();

    QString filterConfig = KisConfig().exportConfiguration("HeightMap");
    KisPropertiesConfiguration cfg;
    cfg.fromXML(filterConfig);

    optionsHeightMap.intSize->setValue(image->width());

    int endianness = cfg.getInt("endianness", 0);
    QDataStream::ByteOrder bo = QDataStream::LittleEndian;
    optionsHeightMap.radioPC->setChecked(true);

    if (endianness == 0) {
        bo = QDataStream::BigEndian;
        optionsHeightMap.radioMac->setChecked(true);
    }

    if (!getBatchMode()) {
        if (kdb->exec() == QDialog::Rejected) {
            return KisImportExportFilter::UserCancelled;
        }
    }

    if (optionsHeightMap.radioMac->isChecked()) {
        cfg.setProperty("endianness", 0);
        bo = QDataStream::BigEndian;
    }
    else {
        cfg.setProperty("endianness", 1);
        bo = QDataStream::LittleEndian;
    }
    KisConfig().setExportConfiguration("HeightMap", cfg);

    bool downscale = false;
    if (to == "image/x-r8" && image->colorSpace()->colorDepthId() == Integer16BitsColorDepthID) {

        downscale = (QMessageBox::question(0,
                                           i18nc("@title:window", "Downscale Image"),
                                           i18n("You specified the .r8 extension for a 16 bit/channel image. Do you want to save as 8 bit? Your image data will not be changed."),
                                           QMessageBox::Yes | QMessageBox::No)
                          == QMessageBox::Yes);
    }


    // the image must be locked at the higher levels
    KIS_SAFE_ASSERT_RECOVER_NOOP(image->locked());
    KisPaintDeviceSP pd = new KisPaintDevice(*image->projection());

    QFile f(filename);
    f.open(QIODevice::WriteOnly);
    QDataStream s(&f);
    s.setByteOrder(bo);

    KisRandomConstAccessorSP it = pd->createRandomConstAccessorNG(0, 0);
    bool r16 = ((image->colorSpace()->colorDepthId() == Integer16BitsColorDepthID) && !downscale);
    for (int i = 0; i < image->height(); ++i) {
        for (int j = 0; j < image->width(); ++j) {
            it->moveTo(i, j);
            if (r16) {
                s << KoGrayU16Traits::gray(const_cast<quint8*>(it->rawDataConst()));
            }
            else {
//.........这里部分代码省略.........

BrushProperties::BrushProperties( QWidget *parent ) : QDialog( parent, "Brush Properties", true )
{
    Q_CHECK_PTR( parent );

    //Initializations
    setCaption( tr( "Brush Properties" ) );
    setFont( QFont( "helvetica", 10 ) );
    parent_widget = parent;
    resize( 235, 155 );
    setMinimumSize( 235, 155 );
    setMaximumSize( 235, 155 );
    drawing_area = ( DrawingArea * )parent_widget;

    //------------- Operations on the static texts ----------

    text_origin = new QLabel( tr( "Origin Point" ) + QString( ":" ), this );
    text_origin -> resize( 100, 20 );
    text_origin -> move( 10, 10 );

    text_origin_x = new QLabel( "X", this );
    text_origin_x -> resize( 15, 20 );
    text_origin_x -> move( text_origin -> x() + text_origin -> width() + 5, text_origin -> y() );

    text_origin_y = new QLabel( "Y", this );
    text_origin_y -> resize( 15, 20 );
    text_origin_y -> move( text_origin_x -> x() + text_origin_x -> width() + 45, text_origin_x -> y() );

    text_pattern = new QLabel( tr( "Border Style" ) + QString( ":" ), this );
    text_pattern -> resize( 100, 20 );
    text_pattern -> move( text_origin -> x(), text_origin -> y() + text_origin -> height() + 5 );

    text_factor = new QLabel( tr( "Stipple Factor" ) + QString( ":" ), this );
    text_factor -> resize( 100, 20 );
    text_factor -> move( text_pattern -> x(), text_pattern -> y() + text_pattern -> height() + 5 );

    text_angle = new QLabel( tr( "Rotation Angle" ) + QString( ":" ), this );
    text_angle -> resize( 100, 20 );
    text_angle -> move( text_factor -> x(), text_factor -> y() + text_factor -> height() + 5 );

    //------------- Operations on the Textfields -------------

    value_origin_x = new QLineEdit( this );
    value_origin_x -> resize( 30, 20 );
    value_origin_x -> move( text_origin_x -> x() + text_origin_x -> width() + 5, text_origin_x -> y() );

    value_origin_y = new QLineEdit( this );
    value_origin_y -> resize( 30, 20 );
    value_origin_y -> move( text_origin_y -> x() + text_origin_y -> width() + 5, text_origin_y -> y() );

    value_factor = new QLineEdit( this );
    value_factor -> resize( 110, 20 );
    value_factor -> move( text_factor -> x() + text_factor -> width() + 5, text_factor -> y() );

    value_angle = new QLineEdit( this );
    value_angle -> resize( 110, 20 );
    value_angle -> move( text_angle -> x() + text_angle -> width() + 5, text_angle -> y() );

    //------------- Operations on other components -------------

    QStringList p_str;
    p_str << "___________" << "_ _ _ _ _ _ _" << "_  _  _  _  _" << ". . . . . . . . ." << ". _ . _ . _ . _"
     	  << "___ ___ ___" << "___ _ ___ _" << "___  _  ___";
    value_pattern = new QComboBox( this );
    value_pattern -> insertStringList( p_str );
    value_pattern -> resize( 110, 20 );
    value_pattern -> move( text_pattern -> x() + text_pattern -> width() + 5, text_pattern -> y() );

    //------------- Operations on the buttons -----------------

    accept = new QPushButton( tr( "Accept" ), this );
    accept -> resize( 60, 30 );
    accept -> move( text_angle -> x() + 45, text_angle -> y() + text_angle -> height() + 10 );
    connect( accept, SIGNAL( clicked() ), SLOT( slotAccept() ) );

    cancel = new QPushButton( tr( "Cancel" ), this );
    cancel -> resize( 60, 30 );
    cancel -> move( accept -> x() + accept -> width() + 5, accept -> y() );
    connect( cancel, SIGNAL( clicked() ), SLOT( slotCancel() ) );
}

ScPlugin* importvsd_getPlugin()
{
    ImportVsdPlugin* plug = new ImportVsdPlugin();
    Q_CHECK_PTR(plug);
    return plug;
}