trunk/src/qsamplerChannelStrip.ui.h

// qsamplerChannelStrip.ui.h
//
// ui.h extension file, included from the uic-generated form implementation.
/****************************************************************************
   Copyright (C) 2004-2005, rncbc aka Rui Nuno Capela. All rights reserved.

   This program is free software; you can redistribute it and/or
   modify it under the terms of the GNU General Public License
   as published by the Free Software Foundation; either version 2
   of the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

*****************************************************************************/

#include <qvalidator.h>
#include <qmessagebox.h>
#include <qdragobject.h>
#include <qfileinfo.h>
#include <qtooltip.h>
#include <qpopupmenu.h>
#include <qobjectlist.h>
#include <qurl.h>

#include <math.h>

#include "qsamplerMainForm.h"
#include "qsamplerChannelForm.h"

#include "config.h"

// Channel status/usage usage limit control.
#define QSAMPLER_ERROR_LIMIT    3


// Kind of constructor.
void qsamplerChannelStrip::init (void)
{
    // Initialize locals.
    m_pChannel     = NULL;
    m_iDirtyChange = 0;
        m_iErrorCount  = 0;

    // Try to restore normal window positioning.
    adjustSize();
}


// Kind of destructor.
void qsamplerChannelStrip::destroy (void)
{
    // Destroy existing channel descriptor.
    if (m_pChannel)
        delete m_pChannel;
    m_pChannel = NULL;
}


// Drag'n'drop file handler.
bool qsamplerChannelStrip::decodeDragFile ( const QMimeSource *pEvent, QString& sInstrumentFile )
{
        if (m_pChannel == NULL)
                return false;
        if (QTextDrag::canDecode(pEvent)) {
                QString sText;
                if (QTextDrag::decode(pEvent, sText)) {
                        QStringList files = QStringList::split('\n', sText);
                        for (QStringList::Iterator iter = files.begin(); iter != files.end(); iter++) {
                                *iter = QUrl((*iter).stripWhiteSpace().replace(QRegExp("^file:"), QString::null)).path();
                                if (qsamplerChannel::isInstrumentFile(*iter)) {
                                        sInstrumentFile = *iter;
                                        return true;
                                }
                        }
                }
        }
        // Fail.
        return false;
}


// Window drag-n-drop event handlers.
void qsamplerChannelStrip::dragEnterEvent ( QDragEnterEvent* pDragEnterEvent )
{
        QString sInstrumentFile;
        pDragEnterEvent->accept(decodeDragFile(pDragEnterEvent, sInstrumentFile));
}


void qsamplerChannelStrip::dropEvent ( QDropEvent* pDropEvent )
{
        QString sInstrumentFile;

        if (decodeDragFile(pDropEvent, sInstrumentFile)) {
                // Go and set the dropped instrument filename...
                m_pChannel->setInstrument(sInstrumentFile, 0);
                // Open up the channel dialog.
                channelSetup();
        }
}


// Channel strip setup formal initializer.
void qsamplerChannelStrip::setup ( qsamplerChannel *pChannel )
{
    // Destroy any previous channel descriptor;
    // (remember that once setup we own it!)
    if (m_pChannel)
        delete m_pChannel;

    // Set the new one...
    m_pChannel = pChannel;
    
    // Stabilize this around.
    updateChannelInfo();

        // We'll accept drops from now on...
        if (m_pChannel)
                setAcceptDrops(true);
}

// Channel secriptor accessor.
qsamplerChannel *qsamplerChannelStrip::channel (void)
{
    return m_pChannel;
}


// Messages view font accessors.
QFont qsamplerChannelStrip::displayFont (void)
{
    return EngineNameTextLabel->font();
}

void qsamplerChannelStrip::setDisplayFont ( const QFont & font )
{
    EngineNameTextLabel->setFont(font);
    MidiPortChannelTextLabel->setFont(font);
    InstrumentNameTextLabel->setFont(font);
    InstrumentStatusTextLabel->setFont(font);
}


// Channel display background effect.
void qsamplerChannelStrip::setDisplayEffect ( bool bDisplayEffect )
{
    QPixmap pm;
    if (bDisplayEffect)
        pm = QPixmap::fromMimeSource("displaybg1.png");
    setDisplayBackground(pm);
}


// Update main display background pixmap.
void qsamplerChannelStrip::setDisplayBackground ( const QPixmap& pm )
{
    // Set the main origin...
    ChannelInfoFrame->setPaletteBackgroundPixmap(pm);

    // Iterate for every child text label...
    QObjectList *pList = ChannelInfoFrame->queryList("QLabel");
    if (pList) {
        for (QLabel *pLabel = (QLabel *) pList->first(); pLabel; pLabel = (QLabel *) pList->next())
            pLabel->setPaletteBackgroundPixmap(pm);
        delete pList;
    }
    
    // And this standalone too.
    StreamVoiceCountTextLabel->setPaletteBackgroundPixmap(pm);
}


// Maximum volume slider accessors.
void qsamplerChannelStrip::setMaxVolume ( int iMaxVolume )
{
    m_iDirtyChange++;
    VolumeSlider->setRange(0, iMaxVolume);
    VolumeSpinBox->setRange(0, iMaxVolume);
    m_iDirtyChange--;
}


// Channel setup dialog slot.
bool qsamplerChannelStrip::channelSetup (void)
{
        if (m_pChannel == NULL)
                return false;
                
        // Invoke the channel setup dialog.
        bool bResult = m_pChannel->channelSetup(this);
        // Notify that thie channel has changed.
        if (bResult)
                emit channelChanged(this);

        return bResult;
}


// Channel reset slot.
bool qsamplerChannelStrip::channelReset (void)
{
        if (m_pChannel == NULL)
                return false;

        // Invoke the channel reset method.
        bool bResult = m_pChannel->channelReset();
        // Notify that thie channel has changed.
        if (bResult)
                emit channelChanged(this);

        return bResult;
}


// Update the channel instrument name.
bool qsamplerChannelStrip::updateInstrumentName ( bool bForce )
{
        if (m_pChannel == NULL)
                return false;

        // Do we refersh the actual name?
        if (bForce)
                m_pChannel->updateInstrumentName();

        // Instrument name...
        if (m_pChannel->instrumentName().isEmpty()) {
                if (m_pChannel->instrumentStatus() >= 0)
                        InstrumentNameTextLabel->setText(' ' + qsamplerChannel::loadingInstrument());
                else
                        InstrumentNameTextLabel->setText(' ' + qsamplerChannel::noInstrumentName());
        } else
                InstrumentNameTextLabel->setText(' ' + m_pChannel->instrumentName());

        return true;    
}


// Do the dirty volume change.
bool qsamplerChannelStrip::updateChannelVolume (void)
{
    if (m_pChannel == NULL)
        return false;

    // Convert...
#ifdef CONFIG_ROUND
    int iVolume = (int) ::round(100.0 * m_pChannel->volume());
#else
    double fIPart = 0.0;
    double fFPart = ::modf(100.0 * m_pChannel->volume(), &fIPart);
    int iVolume = (int) fIPart;
    if (fFPart >= +0.5)
        iVolume++;
    else
    if (fFPart <= -0.5)
        iVolume--;
#endif

    // And clip...
    if (iVolume < 0)
        iVolume = 0;

    // Flag it here, to avoid infinite recursion.
    m_iDirtyChange++;
    VolumeSlider->setValue(iVolume);
    VolumeSpinBox->setValue(iVolume);
    m_iDirtyChange--;

    return true;
}


// Update whole channel info state.
bool qsamplerChannelStrip::updateChannelInfo (void)
{
    if (m_pChannel == NULL)
        return false;
        
        // Check for error limit/recycle...
        if (m_iErrorCount > QSAMPLER_ERROR_LIMIT)
                return true;

    // Update strip caption.
    QString sText = m_pChannel->channelName();
    setCaption(sText);
    ChannelSetupPushButton->setText(sText);

    // Check if we're up and connected.
    if (m_pChannel->client() == NULL)
        return false;

    // Read actual channel information.
    m_pChannel->updateChannelInfo();

    // Engine name...
    if (m_pChannel->engineName().isEmpty())
        EngineNameTextLabel->setText(' ' + qsamplerChannel::noEngineName());
    else
        EngineNameTextLabel->setText(' ' + m_pChannel->engineName());

        // Instrument name...
        updateInstrumentName(false);

    // MIDI Port/Channel...
    if (m_pChannel->midiChannel() == LSCP_MIDI_CHANNEL_ALL)
        MidiPortChannelTextLabel->setText(QString("%1 / *").arg(m_pChannel->midiPort()));
    else
        MidiPortChannelTextLabel->setText(QString("%1 / %2").arg(m_pChannel->midiPort()).arg(m_pChannel->midiChannel() + 1));

    // Instrument status...
    int iInstrumentStatus = m_pChannel->instrumentStatus();
    if (iInstrumentStatus < 0) {
        InstrumentStatusTextLabel->setPaletteForegroundColor(Qt::red);
        InstrumentStatusTextLabel->setText(tr("ERR%1").arg(iInstrumentStatus));
        m_iErrorCount++;
        return false;
    }
    // All seems normal...
    InstrumentStatusTextLabel->setPaletteForegroundColor(iInstrumentStatus < 100 ? Qt::yellow : Qt::green);
    InstrumentStatusTextLabel->setText(QString::number(iInstrumentStatus) + '%');
    m_iErrorCount = 0;

    // And update the both GUI volume elements;
    // return success if, and only if, intrument is fully loaded...
    return updateChannelVolume() && (iInstrumentStatus == 100);
}


// Update whole channel usage state.
bool qsamplerChannelStrip::updateChannelUsage (void)
{
    if (m_pChannel == NULL)
        return false;
    if (m_pChannel->client() == NULL)
        return false;

        // This only makes sense on fully loaded channels...
        if (m_pChannel->instrumentStatus() < 100)
            return false;
            
    // Get current channel voice count.
    int iVoiceCount  = ::lscp_get_channel_voice_count(m_pChannel->client(), m_pChannel->channelID());
    // Get current stream count.
    int iStreamCount = ::lscp_get_channel_stream_count(m_pChannel->client(), m_pChannel->channelID());
    // Get current channel buffer fill usage.
    // As benno has suggested this is the percentage usage
    // of the least filled buffer stream...
    int iStreamUsage = ::lscp_get_channel_stream_usage(m_pChannel->client(), m_pChannel->channelID());;

    // Update the GUI elements...
    StreamUsageProgressBar->setProgress(iStreamUsage);
    StreamVoiceCountTextLabel->setText(QString("%1 / %2").arg(iStreamCount).arg(iVoiceCount));
    
    // We're clean.
    return true;
}


// Volume change slot.
void qsamplerChannelStrip::volumeChanged ( int iVolume )
{
    if (m_pChannel == NULL)
        return;

    // Avoid recursion.
    if (m_iDirtyChange > 0)
        return;

    // Convert and clip.
    float fVolume = (float) iVolume / 100.0;
    if (fVolume < 0.001)
        fVolume = 0.0;

    // Update the GUI elements.
    if (m_pChannel->setVolume(fVolume)) {
        updateChannelVolume();
        emit channelChanged(this);
    }
}


// Context menu event handler.
void qsamplerChannelStrip::contextMenuEvent( QContextMenuEvent *pEvent )
{
    if (m_pChannel == NULL)
        return;
        
    // We'll just show up the main form's edit menu (thru qsamplerChannel).
    m_pChannel->contextMenuEvent(pEvent);
}


// end of qsamplerChannelStrip.ui.h
1	// qsamplerChannelStrip.ui.h
2	//
3	// ui.h extension file, included from the uic-generated form implementation.
4	/****************************************************************************
5	Copyright (C) 2004-2005, rncbc aka Rui Nuno Capela. All rights reserved.
6
7	This program is free software; you can redistribute it and/or
8	modify it under the terms of the GNU General Public License
9	as published by the Free Software Foundation; either version 2
10	of the License, or (at your option) any later version.
11
12	This program is distributed in the hope that it will be useful,
13	but WITHOUT ANY WARRANTY; without even the implied warranty of
14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	GNU General Public License for more details.
16
17	You should have received a copy of the GNU General Public License
18	along with this program; if not, write to the Free Software
19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20
21	*****************************************************************************/
22
23	#include <qvalidator.h>
24	#include <qmessagebox.h>
25	#include <qdragobject.h>
26	#include <qfileinfo.h>
27	#include <qtooltip.h>
28	#include <qpopupmenu.h>
29	#include <qobjectlist.h>
30	#include <qurl.h>
31
32	#include <math.h>
33
34	#include "qsamplerMainForm.h"
35	#include "qsamplerChannelForm.h"
36
37	#include "config.h"
38
39	// Channel status/usage usage limit control.
40	#define QSAMPLER_ERROR_LIMIT 3
41
42
43	// Kind of constructor.
44	void qsamplerChannelStrip::init (void)
45	{
46	// Initialize locals.
47	m_pChannel = NULL;
48	m_iDirtyChange = 0;
49	m_iErrorCount = 0;
50
51	// Try to restore normal window positioning.
52	adjustSize();
53	}
54
55
56	// Kind of destructor.
57	void qsamplerChannelStrip::destroy (void)
58	{
59	// Destroy existing channel descriptor.
60	if (m_pChannel)
61	delete m_pChannel;
62	m_pChannel = NULL;
63	}
64
65
66	// Drag'n'drop file handler.
67	bool qsamplerChannelStrip::decodeDragFile ( const QMimeSource *pEvent, QString& sInstrumentFile )
68	{
69	if (m_pChannel == NULL)
70	return false;
71	if (QTextDrag::canDecode(pEvent)) {
72	QString sText;
73	if (QTextDrag::decode(pEvent, sText)) {
74	QStringList files = QStringList::split('\n', sText);
75	for (QStringList::Iterator iter = files.begin(); iter != files.end(); iter++) {
76	iter = QUrl((iter).stripWhiteSpace().replace(QRegExp("^file:"), QString::null)).path();
77	if (qsamplerChannel::isInstrumentFile(*iter)) {
78	sInstrumentFile = *iter;
79	return true;
80	}
81	}
82	}
83	}
84	// Fail.
85	return false;
86	}
87
88
89	// Window drag-n-drop event handlers.
90	void qsamplerChannelStrip::dragEnterEvent ( QDragEnterEvent* pDragEnterEvent )
91	{
92	QString sInstrumentFile;
93	pDragEnterEvent->accept(decodeDragFile(pDragEnterEvent, sInstrumentFile));
94	}
95
96
97	void qsamplerChannelStrip::dropEvent ( QDropEvent* pDropEvent )
98	{
99	QString sInstrumentFile;
100
101	if (decodeDragFile(pDropEvent, sInstrumentFile)) {
102	// Go and set the dropped instrument filename...
103	m_pChannel->setInstrument(sInstrumentFile, 0);
104	// Open up the channel dialog.
105	channelSetup();
106	}
107	}
108
109
110	// Channel strip setup formal initializer.
111	void qsamplerChannelStrip::setup ( qsamplerChannel *pChannel )
112	{
113	// Destroy any previous channel descriptor;
114	// (remember that once setup we own it!)
115	if (m_pChannel)
116	delete m_pChannel;
117
118	// Set the new one...
119	m_pChannel = pChannel;
120
121	// Stabilize this around.
122	updateChannelInfo();
123
124	// We'll accept drops from now on...
125	if (m_pChannel)
126	setAcceptDrops(true);
127	}
128
129	// Channel secriptor accessor.
130	qsamplerChannel *qsamplerChannelStrip::channel (void)
131	{
132	return m_pChannel;
133	}
134
135
136	// Messages view font accessors.
137	QFont qsamplerChannelStrip::displayFont (void)
138	{
139	return EngineNameTextLabel->font();
140	}
141
142	void qsamplerChannelStrip::setDisplayFont ( const QFont & font )
143	{
144	EngineNameTextLabel->setFont(font);
145	MidiPortChannelTextLabel->setFont(font);
146	InstrumentNameTextLabel->setFont(font);
147	InstrumentStatusTextLabel->setFont(font);
148	}
149
150
151	// Channel display background effect.
152	void qsamplerChannelStrip::setDisplayEffect ( bool bDisplayEffect )
153	{
154	QPixmap pm;
155	if (bDisplayEffect)
156	pm = QPixmap::fromMimeSource("displaybg1.png");
157	setDisplayBackground(pm);
158	}
159
160
161	// Update main display background pixmap.
162	void qsamplerChannelStrip::setDisplayBackground ( const QPixmap& pm )
163	{
164	// Set the main origin...
165	ChannelInfoFrame->setPaletteBackgroundPixmap(pm);
166
167	// Iterate for every child text label...
168	QObjectList *pList = ChannelInfoFrame->queryList("QLabel");
169	if (pList) {
170	for (QLabel pLabel = (QLabel ) pList->first(); pLabel; pLabel = (QLabel *) pList->next())
171	pLabel->setPaletteBackgroundPixmap(pm);
172	delete pList;
173	}
174
175	// And this standalone too.
176	StreamVoiceCountTextLabel->setPaletteBackgroundPixmap(pm);
177	}
178
179
180	// Maximum volume slider accessors.
181	void qsamplerChannelStrip::setMaxVolume ( int iMaxVolume )
182	{
183	m_iDirtyChange++;
184	VolumeSlider->setRange(0, iMaxVolume);
185	VolumeSpinBox->setRange(0, iMaxVolume);
186	m_iDirtyChange--;
187	}
188
189
190	// Channel setup dialog slot.
191	bool qsamplerChannelStrip::channelSetup (void)
192	{
193	if (m_pChannel == NULL)
194	return false;
195
196	// Invoke the channel setup dialog.
197	bool bResult = m_pChannel->channelSetup(this);
198	// Notify that thie channel has changed.
199	if (bResult)
200	emit channelChanged(this);
201
202	return bResult;
203	}
204
205
206	// Channel reset slot.
207	bool qsamplerChannelStrip::channelReset (void)
208	{
209	if (m_pChannel == NULL)
210	return false;
211
212	// Invoke the channel reset method.
213	bool bResult = m_pChannel->channelReset();
214	// Notify that thie channel has changed.
215	if (bResult)
216	emit channelChanged(this);
217
218	return bResult;
219	}
220
221
222	// Update the channel instrument name.
223	bool qsamplerChannelStrip::updateInstrumentName ( bool bForce )
224	{
225	if (m_pChannel == NULL)
226	return false;
227
228	// Do we refersh the actual name?
229	if (bForce)
230	m_pChannel->updateInstrumentName();
231
232	// Instrument name...
233	if (m_pChannel->instrumentName().isEmpty()) {
234	if (m_pChannel->instrumentStatus() >= 0)
235	InstrumentNameTextLabel->setText(' ' + qsamplerChannel::loadingInstrument());
236	else
237	InstrumentNameTextLabel->setText(' ' + qsamplerChannel::noInstrumentName());
238	} else
239	InstrumentNameTextLabel->setText(' ' + m_pChannel->instrumentName());
240
241	return true;
242	}
243
244
245	// Do the dirty volume change.
246	bool qsamplerChannelStrip::updateChannelVolume (void)
247	{
248	if (m_pChannel == NULL)
249	return false;
250
251	// Convert...
252	#ifdef CONFIG_ROUND
253	int iVolume = (int) ::round(100.0 * m_pChannel->volume());
254	#else
255	double fIPart = 0.0;
256	double fFPart = ::modf(100.0 * m_pChannel->volume(), &fIPart);
257	int iVolume = (int) fIPart;
258	if (fFPart >= +0.5)
259	iVolume++;
260	else
261	if (fFPart <= -0.5)
262	iVolume--;
263	#endif
264
265	// And clip...
266	if (iVolume < 0)
267	iVolume = 0;
268
269	// Flag it here, to avoid infinite recursion.
270	m_iDirtyChange++;
271	VolumeSlider->setValue(iVolume);
272	VolumeSpinBox->setValue(iVolume);
273	m_iDirtyChange--;
274
275	return true;
276	}
277
278
279	// Update whole channel info state.
280	bool qsamplerChannelStrip::updateChannelInfo (void)
281	{
282	if (m_pChannel == NULL)
283	return false;
284
285	// Check for error limit/recycle...
286	if (m_iErrorCount > QSAMPLER_ERROR_LIMIT)
287	return true;
288
289	// Update strip caption.
290	QString sText = m_pChannel->channelName();
291	setCaption(sText);
292	ChannelSetupPushButton->setText(sText);
293
294	// Check if we're up and connected.
295	if (m_pChannel->client() == NULL)
296	return false;
297
298	// Read actual channel information.
299	m_pChannel->updateChannelInfo();
300
301	// Engine name...
302	if (m_pChannel->engineName().isEmpty())
303	EngineNameTextLabel->setText(' ' + qsamplerChannel::noEngineName());
304	else
305	EngineNameTextLabel->setText(' ' + m_pChannel->engineName());
306
307	// Instrument name...
308	updateInstrumentName(false);
309
310	// MIDI Port/Channel...
311	if (m_pChannel->midiChannel() == LSCP_MIDI_CHANNEL_ALL)
312	MidiPortChannelTextLabel->setText(QString("%1 / *").arg(m_pChannel->midiPort()));
313	else
314	MidiPortChannelTextLabel->setText(QString("%1 / %2").arg(m_pChannel->midiPort()).arg(m_pChannel->midiChannel() + 1));
315
316	// Instrument status...
317	int iInstrumentStatus = m_pChannel->instrumentStatus();
318	if (iInstrumentStatus < 0) {
319	InstrumentStatusTextLabel->setPaletteForegroundColor(Qt::red);
320	InstrumentStatusTextLabel->setText(tr("ERR%1").arg(iInstrumentStatus));
321	m_iErrorCount++;
322	return false;
323	}
324	// All seems normal...
325	InstrumentStatusTextLabel->setPaletteForegroundColor(iInstrumentStatus < 100 ? Qt::yellow : Qt::green);
326	InstrumentStatusTextLabel->setText(QString::number(iInstrumentStatus) + '%');
327	m_iErrorCount = 0;
328
329	// And update the both GUI volume elements;
330	// return success if, and only if, intrument is fully loaded...
331	return updateChannelVolume() && (iInstrumentStatus == 100);
332	}
333
334
335	// Update whole channel usage state.
336	bool qsamplerChannelStrip::updateChannelUsage (void)
337	{
338	if (m_pChannel == NULL)
339	return false;
340	if (m_pChannel->client() == NULL)
341	return false;
342
343	// This only makes sense on fully loaded channels...
344	if (m_pChannel->instrumentStatus() < 100)
345	return false;
346
347	// Get current channel voice count.
348	int iVoiceCount = ::lscp_get_channel_voice_count(m_pChannel->client(), m_pChannel->channelID());
349	// Get current stream count.
350	int iStreamCount = ::lscp_get_channel_stream_count(m_pChannel->client(), m_pChannel->channelID());
351	// Get current channel buffer fill usage.
352	// As benno has suggested this is the percentage usage
353	// of the least filled buffer stream...
354	int iStreamUsage = ::lscp_get_channel_stream_usage(m_pChannel->client(), m_pChannel->channelID());;
355
356	// Update the GUI elements...
357	StreamUsageProgressBar->setProgress(iStreamUsage);
358	StreamVoiceCountTextLabel->setText(QString("%1 / %2").arg(iStreamCount).arg(iVoiceCount));
359
360	// We're clean.
361	return true;
362	}
363
364
365	// Volume change slot.
366	void qsamplerChannelStrip::volumeChanged ( int iVolume )
367	{
368	if (m_pChannel == NULL)
369	return;
370
371	// Avoid recursion.
372	if (m_iDirtyChange > 0)
373	return;
374
375	// Convert and clip.
376	float fVolume = (float) iVolume / 100.0;
377	if (fVolume < 0.001)
378	fVolume = 0.0;
379
380	// Update the GUI elements.
381	if (m_pChannel->setVolume(fVolume)) {
382	updateChannelVolume();
383	emit channelChanged(this);
384	}
385	}
386
387
388	// Context menu event handler.
389	void qsamplerChannelStrip::contextMenuEvent( QContextMenuEvent *pEvent )
390	{
391	if (m_pChannel == NULL)
392	return;
393
394	// We'll just show up the main form's edit menu (thru qsamplerChannel).
395	m_pChannel->contextMenuEvent(pEvent);
396	}
397
398
399	// end of qsamplerChannelStrip.ui.h