/** Searches for a ScrollBar and a TextArea to link them */
void Window::Link(unsigned short SBID, unsigned short TAID)
{
	ScrollBar* sb = NULL;
	TextArea* ta = NULL;
	std::vector< Control*>::iterator m;
	for (m = Controls.begin(); m != Controls.end(); m++) {
		if (( *m )->Owner != this)
			continue;
		if (( *m )->ControlType == IE_GUI_SCROLLBAR) {
			if (( *m )->ControlID == SBID) {
				sb = ( ScrollBar * ) ( *m );
				if (ta != NULL)
					break;
			}
		} else if (( *m )->ControlType == IE_GUI_TEXTAREA) {
			if (( *m )->ControlID == TAID) {
				ta = ( TextArea * ) ( *m );
				if (sb != NULL)
					break;
			}
		}
	}
	if (sb && ta) {
		sb->ta = ta;
		ta->SetScrollBar( sb );
	}
}

bool Summarizer::mouseOver(TextArea& textarea, vec2 mouse) {
    mouseover=false;

    if(right && mouse.x < pos_x) return false;
    if(mouse.y < top_gap || mouse.y > (display.height-bottom_gap)) return false;
    if(items.empty()) return false;

    float y = mouse.y;

    for(SummItem& item : items) {
        if(item.departing) continue;

        if(item.pos.y<=y && (item.pos.y+font.getMaxHeight()+4) > y) {
            if(mouse.x< item.pos.x || mouse.x > item.pos.x + item.width) continue;

            std::vector<std::string> content;

            textarea.setText(item.unit.expanded);
            textarea.setColour(vec3(item.colour));
            textarea.setPos(mouse);
            mouseover=true;
            return true;
        }
    }

    return false;
}

/** Provides per-pixel scrolling. Top = 0px */
void ScrollBar::SetPosForY(unsigned short y)
{
	if (Value > 1) {// if the value is 1 we are simultaniously at both the top and bottom so there is nothing to do
		unsigned short YMax = Height
		- GetFrameHeight(IE_GUI_SCROLLBAR_SLIDER)
		- GetFrameHeight(IE_GUI_SCROLLBAR_DOWN_UNPRESSED)
		- GetFrameHeight(IE_GUI_SCROLLBAR_UP_UNPRESSED);

		if (y > YMax) y = YMax;

		if (stepPx) {
			unsigned short NewPos = (unsigned short)(y / stepPx);
			if (Pos != NewPos) {
				SetPos( NewPos, false );
			}
			if (ta) {
				// we must "scale" the pixels the slider moves
				TextArea* t = (TextArea*) ta;
				unsigned int taY = y * (t->GetRowHeight() / stepPx);
				t->ScrollToY(taY, this);
			}
			SliderYPos = (y + GetFrameHeight(IE_GUI_SCROLLBAR_UP_UNPRESSED) - 0);
			core->RedrawAll();
		}
	}else{
		// top is our default position
		SliderYPos = GetFrameHeight(IE_GUI_SCROLLBAR_UP_UNPRESSED);
	}
}

bool RequestBall::mouseOver(TextArea& textarea, vec2& mouse) {

    //within 3 pixels
    vec2 from_mouse = pos - mouse;

    if( glm::dot(from_mouse, from_mouse) < 36.0f) {

        std::vector<std::string> content;

        content.push_back( std::string( le->path ) );
        content.push_back( " " );

        if(le->vhost.size()>0) content.push_back( std::string("Virtual-Host: ") + le->vhost );

        content.push_back( std::string("Remote-Host:  ") + le->hostname );

        if(le->referrer.size()>0)   content.push_back( std::string("Referrer:     ") + le->referrer );
        if(le->user_agent.size()>0) content.push_back( std::string("User-Agent:   ") + le->user_agent );

        textarea.setText(content);
        textarea.setPos(mouse);
        textarea.setColour(colour);
        return true;
    }

    return false;
}

MenuItem* GOFactory::createMenuItem( fVector3 p_position, fVector2 p_size,
	string p_text, fVector2 p_textOffset, fVector2 p_fontSize, string p_bgTexPath)
{
	float scrW = GAME_FAIL;
	float scrH = GAME_FAIL;
	if(m_io != NULL)
	{
		scrW = (float)m_io->getScreenWidth();
		scrH = (float)m_io->getScreenHeight();
	}

	fVector2 finalPos, finalTextOffset;
	finalPos.x = scrW * (p_position.x);	
	finalPos.y = scrH * (p_position.y);
	finalTextOffset.x = scrW * (p_textOffset.x);
	finalTextOffset.y = scrH * (p_textOffset.y);

	SpriteInfo* spriteInfo = NULL;
	if( p_bgTexPath != "" )
		spriteInfo = CreateSpriteInfo( p_bgTexPath,
		fVector3(finalPos.x, finalPos.y, p_position.z),
		fVector2(p_size.x*scrW, p_size.y*scrH), NULL );


	GlyphMap* font = NULL;
	TextArea* text = NULL;
	if( p_text != "" )
	{
		text = createMenuItemTextArea(p_position, p_text, p_textOffset, p_fontSize );
		text->setText( p_text );
	}

	return new MenuItem( spriteInfo, text, finalPos, finalTextOffset );
}

void HomeLayout::onTweetPosted(AbstractObjectBase* tweet) {
	Q_UNUSED(tweet);
	RequestEnvelope *env = qobject_cast<RequestEnvelope *>(sender());
	disconnect(env, SIGNAL(requestComplete(AbstractObjectBase*)), this, SLOT(onTweetPosted(AbstractObjectBase*)));
	qDebug() << "Successfully posted the tweet";
	TextArea *tweetText = root()->findChild<TextArea*>("tweetText");
	tweetText->setText("Tweet Posted!");
}

FormElement *TextareaFactory::CreateElement(string name, string value)
{
	TextArea *retVal = new TextArea();
	retVal->SetName(name);
	retVal->SetValue(value);

	return retVal;
}

ActivityIndicatorRecipe::ActivityIndicatorRecipe(Container *parent) :
        CustomControl(parent)
{
    // The recipe Container
    Container *recipeContainer = new Container();
    recipeContainer->setLeftPadding(20.0);
    recipeContainer->setRightPadding(20.0);

    // The introduction text
    TextArea *introText = new TextArea();
    introText->setText((const QString) "This is a milk boiling simulator recipe");
    introText->setEditable(false);
    introText->textStyle()->setBase(SystemDefaults::TextStyles::bodyText());
    introText->setBottomMargin(100);

    Container* smashContainer = new Container();
    smashContainer->setLayout(new DockLayout());

    // Create the unbroken egg ImageView
    mUnbroken = ImageView::create("asset:///images/stockcurve/egg.png");

    // Center the unbroken egg image
    mUnbroken->setHorizontalAlignment(HorizontalAlignment::Center);
    mUnbroken->setVerticalAlignment(VerticalAlignment::Center);

    // Since this broken egg image is on top of the unbroken egg image, we can hide
    // this image by changing the opacity value of this image.
    mBroken = ImageView::create("asset:///images/stockcurve/broken_egg.png").opacity(0.0);

    // Center the brown egg image (same as unbroken one)
    mBroken->setHorizontalAlignment(HorizontalAlignment::Center);
    mBroken->setVerticalAlignment(VerticalAlignment::Center);

    mActivityIndicator = new ActivityIndicator();
    mActivityIndicator->setPreferredSize(130, 130);

    smashContainer->add(mUnbroken);
    smashContainer->add(mActivityIndicator);
    smashContainer->add(mBroken);

    mButton = new Button();
    mButton->setTopMargin(100);
    mButton->setText((const QString) "start cooking");
    connect(mButton, SIGNAL(clicked()), this, SLOT(onClicked()));

    // Add the controls to the recipe Container and set it as root.
    recipeContainer->add(introText);
    recipeContainer->add(smashContainer);

    recipeContainer->add(mButton);

    setRoot(recipeContainer);

}

TupCrashWidget::TupCrashWidget(int sig) : QDialog(0), m_sig(sig)
{
    setModal(true);

    setWindowTitle(CHANDLER->title());
    setWindowIcon(QPixmap(THEME_DIR + "icons/skull.png"));

    m_layout = new QVBoxLayout(this);
    m_tabber = new QTabWidget(this);
    m_layout->addWidget(m_tabber);

    QWidget *page1 = new QWidget;
    QVBoxLayout *page1layout = new QVBoxLayout(page1);
    QLabel *message = new QLabel("<font color="+CHANDLER->messageColor().name()+">"+ CHANDLER->message()+"</color>");

    page1layout->addWidget(message);

    QHBoxLayout *hbox = new QHBoxLayout;

    QString text = CHANDLER->defaultText();
    QImage img(CHANDLER->defaultImage());

    if (CHANDLER->containsSignalEntry(sig)) {
        text = CHANDLER->signalText(sig);
        img = QImage(CHANDLER->signalImage(sig));
    }

    QLabel *sigImg = new QLabel;
    sigImg->setPixmap(QPixmap::fromImage(img));

    hbox->addWidget(sigImg);

    TextArea *sigText = new TextArea();
    sigText->setHtml(text);
    hbox->addWidget(sigText);

    page1layout->addLayout(hbox);

    m_tabber->addTab(page1, tr("What's happening?"));

    QPushButton *launch = new QPushButton(CHANDLER->launchButtonLabel(),this);
    connect(launch, SIGNAL(clicked()), SLOT(restart()));
    m_layout->addWidget(launch);

    QPushButton *end = new QPushButton(CHANDLER->closeButtonLabel(),this);
    connect(end, SIGNAL(clicked()), SLOT(exit()));
    m_layout->addWidget(end);

    setLayout(m_layout);
}

/** Sets a new position, relays the change to an associated textarea and calls
	any existing GUI OnChange callback */
void ScrollBar::SetPos(int NewPos)
{
	if (Pos && ( Pos == NewPos )) {
		return;
	}
	Changed = true;
	Pos = (ieWord) NewPos;
	if (ta) {
		TextArea* t = ( TextArea* ) ta;
		t->SetRow( Pos );
	}
	if (VarName[0] != 0) {
		core->GetDictionary()->SetAt( VarName, Pos );
	}
	RunEventHandler( ScrollBarOnChange );
}

Container *Intro::setUpExampleUI()
{
    // A small example UI, illustrating some of the core controls.
    // The UI is arranged using a Container with a stack layout.
    Container *exampleUI = new Container();
    StackLayout *exampleUILayout = new StackLayout();

    exampleUI->setLayout(exampleUILayout);

    // A TextArea with text input functionality
    TextArea *exampleTextArea = new TextArea();
    exampleTextArea->textStyle()->setBase(SystemDefaults::TextStyles::bodyText());
    exampleTextArea->setHorizontalAlignment(HorizontalAlignment::Fill);

    // An example of a Slider
    Slider *exampleSlider = new Slider();
    exampleSlider->setValue(0.5f);
    exampleSlider->setHorizontalAlignment(HorizontalAlignment::Left);
    exampleSlider->setVerticalAlignment(VerticalAlignment::Bottom);

    // A ToggleButton
    ToggleButton *exampleToggle = new ToggleButton();
    exampleToggle->setHorizontalAlignment(HorizontalAlignment::Right);

    // A regular Button
    Button *exampleButton = new Button();
    exampleButton->setText("Button");

    // Container for the buttons
    Container *buttonContainer = new Container();
    DockLayout *buttonContainerLayout = new DockLayout();

    buttonContainer->setLayout(buttonContainerLayout);
    buttonContainer->setHorizontalAlignment(HorizontalAlignment::Fill);

    // Adding the buttons to the container.
    buttonContainer->add(exampleToggle);
    buttonContainer->add(exampleButton);

    // Add the Controls to the Container, the layouting is done using
    // layout properties and margins of each control (see code above).
    exampleUI->add(exampleTextArea);
    exampleUI->add(exampleSlider);
    exampleUI->add(buttonContainer);

    return exampleUI;
}

void DisplayMessage::DisplayString(const char* Text, Scriptable *target) const
{
	Label *l = core->GetMessageLabel();
	if (l) {
		l->SetText(Text);
	}
	TextArea *ta = core->GetMessageTextArea();
	if (ta) {
		ta->AppendText( Text, -1 );
	} else {
		if(target) {
			char *tmp = strdup(Text);

			target->DisplayHeadText(tmp);
		}
	}
}

bool Paddle::mouseOver(TextArea& textarea, vec2& mouse) {

    if(pos.x <= mouse.x && pos.x + width >= mouse.x && abs(pos.y - mouse.y) < height/2) {

        std::vector<std::string> content;

        content.push_back( token );

        textarea.setText(content);
        textarea.setPos(mouse);
        textarea.setColour(vec3(colour));

        return true;
    }

    return false;
}

void Window::RedrawControls(const char* VarName, unsigned int Sum)
{
	for (unsigned int i = 0; i < Controls.size(); i++) {
		switch (Controls[i]->ControlType) {
			case IE_GUI_MAP:
			{
				MapControl *mc = ( MapControl* ) (Controls[i]);
				mc->RedrawMapControl( VarName, Sum );
				break;
			}
			case IE_GUI_BUTTON:
			{
				Button* bt = ( Button* ) ( Controls[i] );
				bt->RedrawButton( VarName, Sum );
				break;
			}
			case IE_GUI_TEXTAREA:
			{
				TextArea* pb = ( TextArea* ) ( Controls[i] );
				pb->RedrawTextArea( VarName, Sum );
				break;
			}
			case IE_GUI_PROGRESSBAR:
			{
				Progressbar* pb = ( Progressbar* ) ( Controls[i] );
				pb->RedrawProgressbar( VarName, Sum );
				break;
			}
			case IE_GUI_SLIDER:
			{
				Slider* sl = ( Slider* ) ( Controls[i] );
				sl->RedrawSlider( VarName, Sum );
				break;
			}
			case IE_GUI_SCROLLBAR:
			{
				ScrollBar* sb = ( ScrollBar* ) ( Controls[i] );
				sb->RedrawScrollBar( VarName, Sum );
				break;
			}
		}
	}
}

string DialogFrame::showInputDialog(Component parentComponent, string option, string title, string message)
{
	//parentComponent.drawWin();
	string input;

	ConsoleWordWrapper::formatString(&message, 80);

	int dLength = getLengthFromString(message);
	int dWidth = getWidthFromString(message);
	int centerX = (parentComponent.getLength() / 2) - (dLength / 2);
	int centerY = (parentComponent.getWidth() / 2) - (dWidth / 2)-2;

	int startLine;

	Frame dFrame(centerX, centerY, dLength, dWidth+4, title);
	dFrame.setBackground(COLOR_WHITE);

	TextArea dTextArea = dFrame.addTextArea();

	if (message.length() <= 80)
	{
		startLine = (dTextArea.getLength() / 2) - (message.length() / 2);
	}

	dTextArea.addText(startLine, 0, message);

	InputField dInputField(centerX + 5, dFrame.getBegY() + dFrame.getWidth()-6, dLength - 10, 3);
	
	//std::vector<std::string> bNames{ "Continue" };

	dFrame.setSize(dFrame.getLength(), dFrame.getWidth() + 3);
	ButtonMenu dButtonMenu(dFrame.getBegX(), dFrame.getBegY() + dFrame.getWidth() - 4, dFrame.getLength(), 3, option);
	input = dInputField.getInput();

	werase(dFrame.component);
	

	return input;
}

ProgressIndicatorRecipe::ProgressIndicatorRecipe(Container *parent) :
    CustomControl(parent)
{
  // The recipe Container
  Container *recipeContainer = Container::create().left(20.0).right(20.0);

  // The introduction text
  TextArea *introText = new TextArea();
  introText->setText((const QString) "Drag the slider to change the ProgressIndicator");
  introText->setEditable(false);
  introText->textStyle()->setBase(SystemDefaults::TextStyles::bodyText());
  introText->setBottomMargin(100);

  mProgressIndicator = new ProgressIndicator();
  mProgressIndicator->setFromValue(0);
  mProgressIndicator->setToValue(100);
  connect(mProgressIndicator, SIGNAL(valueChanged(float)), this, SLOT(onValueChanged(float)));

  // Create a Slider and connect a slot function to the signal for Slider value changing.
  Slider *slider = new Slider();
  slider->setTopMargin(100);
  slider->setFromValue(0);
  slider->setToValue(100);
  // Connect the Slider value directly to the value property of the ProgressIndicator.
  connect(slider, SIGNAL(immediateValueChanged(float)), mProgressIndicator, SLOT(setValue(float)));

  // Create a Slider and connect a slot function to the signal for Slider value changing.
  mButton = new Button();
  mButton->setText((const QString) "Pause");
  connect(mButton, SIGNAL(clicked()), this, SLOT(onClicked()));

  // Add the controls to the recipe Container and set it as root.
  recipeContainer->add(introText);
  recipeContainer->add(mProgressIndicator);
  recipeContainer->add(slider);
  recipeContainer->add(mButton);

  setRoot(recipeContainer);
}

void TupCrashWidget::addBacktracePage(const QString &execInfo, const QString &backtrace)
{
    #ifdef K_DEBUG
        T_FUNCINFO << execInfo << " " << backtrace;
    #endif

    QWidget *btPage = new QWidget;
    QVBoxLayout *layout = new QVBoxLayout(btPage);
    layout->addWidget(new QLabel(tr("Executable information")));

    TextArea *fileInfo = new TextArea;
    fileInfo->setHtml(execInfo);

    layout->addWidget(fileInfo);
    layout->addWidget(new QLabel(tr("Backtrace")));

    TextArea *btInfo = new TextArea;
    btInfo->setHtml(backtrace);

    layout->addWidget(btInfo);

    m_tabber->addTab(btPage, tr("Backtrace"));
}

int main(int argc, char * argv[])
{
  Font *font(FontFactory::create(
        (unsigned char*)_binary_sans_set_bin_start,
        (unsigned char*)_binary_sans_map_bin_start));
  TextAreaFactory::setFont(font);
  //TextAreaFactory::usePaletteData((const char*)_binary_vera_pal_bin_start, 32);
  Keyboard * keyBoard = new Keyboard();
  ScrollPane scrollPane;
  keyBoard->setTopLevel(&scrollPane);
#if 1
  TextField * tf = new TextField("Enter the value here. This line is too big to fit in");
  TextField * passwd = new TextField(std::string());
  RichTextArea * rich = (RichTextArea*)TextAreaFactory::create(TextAreaFactory::TXT_RICH);
  Button * goBtn = new Button("Go");
  rich->appendText("This is some long text ");
  passwd->setSize(60,18);
  
  scrollPane.setTopLevel();
  scrollPane.add(rich);
  scrollPane.add(passwd);
  scrollPane.add(goBtn);
  scrollPane.setSize(Canvas::instance().width(),Canvas::instance().height());
  scrollPane.add(tf);
  scrollPane.setScrollIncrement(13);

#else
  RichTextArea * rich = (RichTextArea*)TextAreaFactory::create(TextAreaFactory::TXT_RICH);
  TextArea * t = TextAreaFactory::create();
  EditableTextArea * t2 = (EditableTextArea*)TextAreaFactory::create(TextAreaFactory::TXT_EDIT);
  // t2->setBackgroundColor(Color(31,31,0));

  
  ScrollPane * subPane = new ScrollPane;
  subPane->add(t2);
  subPane->setTopLevel(false);
  subPane->setSize(Canvas::instance().width(),Canvas::instance().height());
  subPane->setScrollIncrement(t2->font().height());
  subPane->setStretchChildren(true);
  
  
  ComboBox * emptyCombo = new ComboBox();
  ComboBox * oneValCombo = new ComboBox();
  ComboBox * combo = new ComboBox();
  combo->setSize(60, 18);
  ComboBox * combo2 = new ComboBox();
  combo2->setSize(90, 18);
  
  std::string str("Hello World");
  Button * b1 = new Button(str);

  str = "Combo box!";
  oneValCombo->addItem(str);
  combo->addItem(str);
  combo2->addItem(str);
  combo2->addItem(str);
  str = "Another One - with very wide text";
  Button * b2 = new Button(str);
  combo->addItem(str);
  combo2->addItem(str);
  combo2->addItem(str);
  str = "Three- wide, but fixed width";
  Button * b3 = new Button(str);
  b3->setSize(60, 18);
  combo2->addItem(str);
  combo2->addItem(str);
  str = "Go";
  Button * b4 = new Button(str);
  //b4->setSize(6*13, 10);
  str = "Last one!";
  Button * b5 = new Button(str);
  combo->addItem(str);
  combo2->addItem(str);
  combo2->addItem(str);

  t2->setListener(keyBoard);
  
  str = "A text field that has a very, very long and pointless string";
  TextField * tf1 = new TextField(str);
  tf1->setSize(160, 18);
  tf1->setListener(keyBoard);
  combo2->addItem(str);

  TextArea * rbLabel = TextAreaFactory::create();
  str = "Radio button label.";
  rbLabel->appendText(str);

  TextArea * cbLabel = TextAreaFactory::create();
  str = "CheckBox label.";
  cbLabel->appendText(str);

  RadioButton * rb = new RadioButton();
  RadioButton * rb2 = new RadioButton();
  RadioButton * rb3 = new RadioButton();
  CheckBox * cb = new CheckBox();
  ButtonGroup bg;
  bg.add(rb);
  bg.add(rb2);
  bg.add(rb3);
  keyBoard->setTopLevel(&scrollPane);
//.........这里部分代码省略.........

InputRecipe::InputRecipe(Container *parent) :
        CustomControl(parent)
{

    Container *recipeContainer = new Container();
    StackLayout *recipeLayout = new StackLayout();
    recipeContainer->setLayout(recipeLayout);
    recipeLayout->setLeftPadding(80);
    recipeLayout->setRightPadding(80);

    // Label used to display the entered text.
    mInputLabel = new Label();
    mInputLabel->setText((const QString) " ");
    mInputLabel->setLayoutProperties(
            StackLayoutProperties::create().horizontal(HorizontalAlignment::Fill));
    mInputLabel->setBottomMargin(50.0);
    mInputLabel->textStyle()->setBase(SystemDefaults::TextStyles::bodyText());
    
    // A multi line text input.
    TextArea *textArea = new TextArea();
    textArea->setHintText("Enter text into multi-line TextArea");
    textArea->setMinHeight(120.0f);
    textArea->setMaxHeight(200.0f);
    textArea->setPreferredHeight(0);
    textArea->setBottomMargin(50.0);
    textArea->textStyle()->setBase(SystemDefaults::TextStyles::bodyText());
    textArea->setLayoutProperties(
            StackLayoutProperties::create().horizontal(HorizontalAlignment::Fill));


    // Connect to the textChanged (to update text).
    connect(textArea, SIGNAL(textChanging(const QString &)), this,
            SLOT(onTextChanging(const QString &)));

    // A single line input field with a clear functionality.
    TextField *textField = new TextField();
    textField->setHintText("Enter text into a single line TextField");
    textField->setLayoutProperties(
            StackLayoutProperties::create().horizontal(HorizontalAlignment::Fill));
    textField->setBottomMargin(50.0);

    // Connect to the textChanged (to update text).
    connect(textField, SIGNAL(textChanging(const QString &)), this,
            SLOT(onTextChanging(const QString &)));

    // A disabled text field.
    TextField *disabledTextField = new TextField();
    disabledTextField->setHintText("This is a disabled text field");
    disabledTextField->setEnabled(false);
    disabledTextField->setLayoutProperties(
            StackLayoutProperties::create().horizontal(HorizontalAlignment::Fill));
    disabledTextField->setBottomMargin(50.0);

    // Add the controls to the recipe Container and set it as the CustomControl root.
    recipeContainer->add(mInputLabel);
    recipeContainer->add(textField);
    recipeContainer->add(disabledTextField);
    recipeContainer->add(textArea);

    //recipeContainer->add(inputContainer);
    setRoot(recipeContainer);
}

//.........这里部分代码省略.........
				}

				ResourceHolder<ImageMgr> mos(BGMos);
				Sprite2D *img = NULL;
				if(mos) {
					img = mos->GetSprite2D();
				}

				TextEdit* te = new TextEdit( ctrlFrame, maxInput, PosX, PosY );
				te->ControlID = ControlID;
				te->SetFont( fnt );
				te->SetCursor( cursor );
				te->SetBackGround( img );
				//The original engine always seems to ignore this textfield
				//te->SetText (Initial );
				win->AddControl( te );
			}
			break;

			case IE_GUI_TEXTAREA:
			{
				//Text Area
				ieResRef FontResRef, InitResRef;
				Color fore, init, back;
				ieWord SBID;
				str->ReadResRef( FontResRef );
				str->ReadResRef( InitResRef );
				Font* fnt = core->GetFont( FontResRef );
				Font* ini = core->GetFont( InitResRef );
				str->Read( &fore, 4 );
				str->Read( &init, 4 );
				str->Read( &back, 4 );
				str->ReadWord( &SBID );
				TextArea* ta = new TextArea( ctrlFrame, fore, init, back );
				ta->ControlID = ControlID;
				ta->SetFonts( ini, fnt );
				win->AddControl( ta );
				if (SBID != 0xffff)
					win->Link( SBID, ( unsigned short ) ControlID );
			}
			break;

			case IE_GUI_LABEL:
			{
				//Label
				ieResRef FontResRef;
				ieStrRef StrRef;
				RevColor fore, back;
				ieWord alignment;
				str->ReadDword( &StrRef );
				str->ReadResRef( FontResRef );
				Font* fnt = core->GetFont( FontResRef );
				str->Read( &fore, 4 );
				str->Read( &back, 4 );
				str->ReadWord( &alignment );
				char* str = core->GetString( StrRef );
				Label* lab = new Label( ctrlFrame, fnt, str );
				core->FreeString( str );
				lab->ControlID = ControlID;

				if (alignment & 1) {
					lab->useRGB = true;
					Color f, b;
					f.r = fore.b;
					f.g = fore.g;
					f.b = fore.r;