Пример #1
0
DockModeClock::DockModeClock (DockModeWindowManager* dm, int zValue)
	: m_launchPoint(0)
	, m_appDesc (0)
	, m_dockWindow (0)
{
	m_appDesc = ApplicationDescription::fromNativeDockApp (std::string ("com.palm.app.dockmodetime"),
			std::string (LOCALIZED("Time")),
			std::string ("1.0"),
			Settings::LunaSettings()->lunaSystemResourcesPath + std::string("/dockmode/time-icon-48x48.png"), // splashIcon
			std::string("Time"), // splashBackgroundName
			Settings::LunaSettings()->lunaSystemResourcesPath + std::string("/dockmode/time-icon-48x48.png"), // miniicon
			std::string("Palm"), 
			std::string("http://www.palm.com"), 
			std::string(LOCALIZED("Time")));

	if (!m_appDesc) {
		g_warning ("appDesc could not be created");
		return;
	}

	m_launchPoint = new LaunchPoint (m_appDesc,
			std::string ("com.palm.dockmodetime"),
			std::string ("com.palm.dockmodetime"),
			std::string (LOCALIZED("Time")),
			std::string (LOCALIZED("Time")),
			Settings::LunaSettings()->lunaSystemResourcesPath + std::string("/dockmode/time-icon-48x48.png"), // iconPath
			std::string(), // params
			false);

	const HostInfo& hostInfo = HostBase::instance()->getInfo();

	QPixmap dockPixmap (hostInfo.displayWidth, hostInfo.displayHeight); // this will be replaced with the background pixmap

	m_dockWindow = new DockModeClockWindow (dockPixmap, dm, zValue);
}
Пример #2
0
void ClockWindow::tick()
{
	time_t rawTime;
	struct tm* timeinfo = 0;
	time(&rawTime);
	timeinfo = localtime(&rawTime);

	// get current local time
	if (m_twelveHour) {

		strftime(m_time, MaxTimeChars, LOCALIZED("%I:%M").c_str(), timeinfo);

		if (m_time[0] == '0') {
			memmove(m_time, m_time+1, MaxTimeChars-1);
		}
	}
	else {
		strftime(m_time, MaxTimeChars, LOCALIZED("%H:%M").c_str(), timeinfo);
	}

	// recalculate the width of the new time
	m_width = 0;
	int len = strlen(m_time);
	for (int i=0; i<len; i++) {
		QPixmap surf = m_digits[m_time[i]];
		if (!surf.isNull())
			m_width += surf.width();
	}

	update();
}
Пример #3
0
void CWakeOnAccess::OnJobComplete(unsigned int jobID, bool success, CJob *job)
{
  CMACDiscoveryJob* discoverJob = (CMACDiscoveryJob*)job;

  const std::string& host = discoverJob->GetHost();
  const std::string& mac = discoverJob->GetMAC();

  if (success)
  {
    CSingleLock lock (m_entrylist_protect);

    SaveMACDiscoveryResult(host, mac);
  }
  else
  {
    CLog::Log(LOGERROR, "%s - Mac discovery failed for host '%s'", __FUNCTION__, host.c_str());

    if (IsEnabled())
    {
      std::string heading = LOCALIZED(13033);
      std::string message = StringUtils::Format(LOCALIZED(13036).c_str(), host.c_str());
      CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error, heading, message, 4000, true, 3000);
    }
  }
}
void FullEraseConfirmationWindow::updateCountDownText()
{
	if (m_secondsLeft == 1) {
		m_countDown = qFromUtf8Stl(LOCALIZED(kFullEraseCountDownSingular));
	} else {
		m_countDown = qFromUtf8Stl(LOCALIZED(kFullEraseCountDownPlural)).arg(m_secondsLeft);
	}

	m_font.setPixelSize(kCountDownFontHeight);
	QFontMetrics metrics(m_font);
	m_countDownBounds = metrics.boundingRect(m_boundingRect.toRect(), Qt::AlignCenter|Qt::TextWordWrap, m_countDown);
	m_countDownBounds.moveTop(m_boundingRect.y() + (m_boundingRect.height() * countRatio));
}
Пример #5
0
void StatusBarClock::tick()
{
	if(Settings::LunaSettings()->demoMode)
		return;

	time_t rawTime;
	struct tm* timeinfo = 0;

	::time(&rawTime);
	timeinfo = ::localtime(&rawTime);

	// get current local time (or date)
	if(!m_displayDate) {
		// If local time matches we don't need to update anything
		if (timeinfo->tm_hour == m_lastUpdateTime.hour && timeinfo->tm_min == m_lastUpdateTime.min)
		{
			return;
		}

		m_lastUpdateTime.hour = timeinfo->tm_hour;
		m_lastUpdateTime.min = timeinfo->tm_min;

		if (m_twelveHour) {
			::strftime(m_timeBuf, kMaxTimeChars, LOCALIZED("%I:%M").c_str(), timeinfo);

			if (m_timeBuf[0] == '0') {
				m_curTimeStr = m_timeBuf + 1;
			} else {
				m_curTimeStr = m_timeBuf;
			}
		} else {
			::strftime(m_timeBuf, kMaxTimeChars, LOCALIZED("%H:%M").c_str(), timeinfo);
			m_curTimeStr = m_timeBuf;
		}
		setTimeText(m_curTimeStr);
	} else{
		// If local time matches we don't need to update anything
		if (timeinfo->tm_year == m_lastUpdateTime.year && timeinfo->tm_mon == m_lastUpdateTime.month && timeinfo->tm_mday == m_lastUpdateTime.day)
		{
			return;
		}

		m_lastUpdateTime.year  = timeinfo->tm_year;
		m_lastUpdateTime.month = timeinfo->tm_mon;
		m_lastUpdateTime.day   = timeinfo->tm_mday;

		setTimeText(QDate::currentDate().toString(Qt::DefaultLocaleShortDate));
	}

	update();
}
Пример #6
0
DockModeClockWindow::DockModeClockWindow(const QPixmap& pixmap, DockModeWindowManager* dm, int zValue)
	: DockModeWindow (WindowType::Type_DockModeWindow, pixmap)
{
	setFlag (QGraphicsItem::ItemHasNoContents);
	setBoundingRect (pixmap.width(), pixmap.height());

	setName (LOCALIZED("Time"));
	setAppId ("com.palm.dockmodetime");

	QDeclarativeEngine* qmlEngine = WindowServer::instance()->declarativeEngine();
	if(qmlEngine) {
		QDeclarativeContext* context =	qmlEngine->rootContext();
		Settings* settings = Settings::LunaSettings();
		std::string systemMenuQmlPath = settings->lunaQmlUiComponentsPath + "DockModeTime/Clocks.qml";
		QUrl url = QUrl::fromLocalFile(systemMenuQmlPath.c_str());
		m_qmlNotifMenu = new QDeclarativeComponent(qmlEngine, url, this);
		if(m_qmlNotifMenu) {
			m_clockObject = qobject_cast<QGraphicsObject *>(m_qmlNotifMenu->create());
			if(m_clockObject) {
				m_clockObject->setPos (boundingRect().x(), boundingRect().y());
				m_clockObject->setParentItem(this);
			}
		}
	}
}
Пример #7
0
static void ShowDiscoveryMessage(const char* function, const char* server_name, bool new_entry)
{
  std::string message;

  if (new_entry)
  {
    CLog::Log(LOGINFO, "%s - Create new entry for host '%s'", function, server_name);
    message = StringUtils::Format(LOCALIZED(13035).c_str(), server_name);
  }
  else
  {
    CLog::Log(LOGINFO, "%s - Update existing entry for host '%s'", function, server_name);
    message = StringUtils::Format(LOCALIZED(13034).c_str(), server_name);
  }
  CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, LOCALIZED(13033), message, 4000, true, 3000);
}
Пример #8
0
void BootupAnimation::generateUtf16AndGlyphOffsets()
{
	m_textLine1 = convertToUtf16(LOCALIZED(s_line1));
	m_textLine2 = convertToUtf16(LOCALIZED(s_line2));

	m_glyphOffsetsLine1 = getGlyphOffsets(m_textLine1, s_fontHeight1);
	m_glyphOffsetsLine2 = getGlyphOffsets(m_textLine2, s_fontHeight2);

	m_widthLine1 = 0;
	for (unsigned int i = 0; i < m_glyphOffsetsLine1.size(); i++)
		m_widthLine1 += m_glyphOffsetsLine1[i];

	m_widthLine2 = 0;
	for (unsigned int i = 0; i < m_glyphOffsetsLine2.size(); i++)
		m_widthLine2 += m_glyphOffsetsLine2[i];

}
void FullEraseConfirmationWindow::setupLabels()
{
	QRect bounds = m_boundingRect.toRect();

	m_title = qFromUtf8Stl(LOCALIZED(kFullEraseConfirmationTitle));
	m_font.setPixelSize(kTitleFontHeight);
	QFontMetrics metrics(m_font);
	m_titleBounds = metrics.boundingRect(bounds, Qt::AlignCenter|Qt::TextWordWrap, m_title);
	m_titleBounds.moveTop(m_boundingRect.y() + (m_boundingRect.height() * titleRatio));
	
	m_description = qFromUtf8Stl(LOCALIZED(kFullEraseConfirmationDescription));
	m_font.setPixelSize(kDescriptionFontHeight);
	metrics = QFontMetrics(m_font);
	m_descBounds = metrics.boundingRect(bounds, Qt::AlignCenter|Qt::TextWordWrap, m_description);
	m_descBounds.moveTop(m_boundingRect.y() + (m_boundingRect.height() * descRatio));

	updateCountDownText();
}
Пример #10
0
void CWakeOnAccess::SaveMACDiscoveryResult(const std::string& host, const std::string& mac)
{
  CLog::Log(LOGNOTICE, "%s - Mac discovered for host '%s' -> '%s'", __FUNCTION__, host.c_str(), mac.c_str());

  std::string heading = LOCALIZED(13033);

  for (EntriesVector::iterator i = m_entries.begin(); i != m_entries.end(); ++i)
  {
    if (StringUtils::EqualsNoCase(host, i->host))
    {
      CLog::Log(LOGDEBUG, "%s - Update existing entry for host '%s'", __FUNCTION__, host.c_str());
      if (!StringUtils::EqualsNoCase(mac, i->mac))
      {
        if (IsEnabled()) // show notification only if we have general feature enabled
        {
          std::string message = StringUtils::Format(LOCALIZED(13034).c_str(), host.c_str());
          CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, heading, message, 4000, true, 3000);
        }

        i->mac = mac;
        SaveToXML();
      }

      return;
    }
  }

  // not found entry to update - create using default values
  WakeUpEntry entry (true);
  entry.host = host;
  entry.mac  = mac;
  m_entries.push_back(entry);

  CLog::Log(LOGDEBUG, "%s - Create new entry for host '%s'", __FUNCTION__, host.c_str());
  if (IsEnabled()) // show notification only if we have general feature enabled
  {
    std::string message = StringUtils::Format(LOCALIZED(13035).c_str(), host.c_str());
    CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Info, heading, message, 4000, true, 3000);
  }

  SaveToXML();
}
Пример #11
0
static bool getLunaPrefSystemValue(const char* key, std::string& value)
{
#if defined(HAS_LUNA_PREF)

	char* str = 0;
	if (LP_ERR_NONE == LPSystemCopyStringValue(key, &str) && str) {
		value = str;
		g_free((gchar*) str);
		return true;
	}	
#endif

	value = LOCALIZED("Unknown");
	return false;
}
Пример #12
0
//virtual
void	PageTab::redoLabelTextLayout()
{
	//TODO: somewhat wasteful. If there is no label, should just exit early and leave a layout that will be left unrendered by paint()
	m_textLayoutObject.clearLayout();;
	//TODO: Need a real fix later instead of localizing the labels at runtime
	QString m_tabLabelLocalized = fromStdUtf8(LOCALIZED(m_tabLabel.toStdString()));
	m_textLayoutObject.setText(m_tabLabelLocalized);

//	int fontSize = qBound(4,(int)((qreal)(m_labelMaxGeom.height())*0.5),24) -2;
//	fontSize = fontSize - (fontSize % 2);
//	m_textFont.setPixelSize(fontSize);
	m_textLayoutObject.setFont(m_textFont);
	QTextOption textOpts;
	textOpts.setAlignment(Qt::AlignHCenter | Qt::AlignVCenter);
	textOpts.setWrapMode(QTextOption::WrapAtWordBoundaryOrAnywhere);
	m_textLayoutObject.setTextOption(textOpts);

	QFontMetrics textFontMetrics(m_textFont);
	int leading = textFontMetrics.leading();
	int rise = textFontMetrics.ascent();
	qreal height = 0;

	m_textLayoutObject.beginLayout();
	while (height < m_labelMaxGeom.height()) {
		QTextLine line = m_textLayoutObject.createLine();
		if (!line.isValid())
			break;
		line.setLineWidth(m_labelMaxGeom.width());
		if (m_textLayoutObject.lineCount() > 1)
		{
			height += leading;
		}
		line.setPosition(QPointF(0, height));
		height += line.height();
	}
	height = qMin((quint32)DimensionsGlobal::roundUp(height),(quint32)m_labelMaxGeom.height());
	height = DimensionsGlobal::roundDown(height) - (DimensionsGlobal::roundDown(height) % 2);	//force to an even #
	m_textLayoutObject.endLayout();
	//TODO: PIXEL-ALIGN
	m_labelGeom = DimensionsGlobal::realRectAroundRealPoint(QSizeF(m_textLayoutObject.boundingRect().width(),height)).toAlignedRect();
}
Пример #13
0
bool CWakeOnAccess::WakeUpHost(const WakeUpEntry& server)
{
  std::string heading = StringUtils::Format(LOCALIZED(13027).c_str(), server.host.c_str());

  ProgressDialogHelper dlg (heading);

  {
    NetworkStartWaiter waitObj (m_netsettle_ms, server.host); // wait until network connected before sending wake-on-lan

    if (dlg.ShowAndWait (waitObj, m_netinit_sec, LOCALIZED(13028)) != ProgressDialogHelper::Success)
    {
      if (g_application.getNetwork().IsConnected() && HostToIP(server.host) == INADDR_NONE)
      {
        // network connected (at least one interface) but dns-lookup failed (host by name, not ip-address), so dont abort yet
        CLog::Log(LOGWARNING, "WakeOnAccess timeout/cancel while waiting for network (proceeding anyway)");
      }
      else
      {
        CLog::Log(LOGNOTICE, "WakeOnAccess timeout/cancel while waiting for network");
        return false; // timedout or canceled ; give up 
      }
    }
  }

  {
    ULONG dst_ip = HostToIP(server.host);

    if (g_application.getNetwork().PingHost(dst_ip, server.ping_port, 500)) // quick ping with short timeout to not block too long
    {
      CLog::Log(LOGNOTICE,"WakeOnAccess success exit, server already running");
      return true;
    }
  }

  if (!g_application.getNetwork().WakeOnLan(server.mac.c_str()))
  {
    CLog::Log(LOGERROR,"WakeOnAccess failed to send. (Is it blocked by firewall?)");

    if (g_application.IsCurrentThread() || !g_application.m_pPlayer->IsPlaying())
      CGUIDialogKaiToast::QueueNotification(CGUIDialogKaiToast::Error, heading, LOCALIZED(13029));
    return false;
  }

  {
    PingResponseWaiter waitObj (dlg.HasDialog(), server); // wait for ping response ..

    ProgressDialogHelper::wait_result 
      result = dlg.ShowAndWait (waitObj, server.wait_online1_sec, LOCALIZED(13030));

    if (result == ProgressDialogHelper::TimedOut)
      result = dlg.ShowAndWait (waitObj, server.wait_online2_sec, LOCALIZED(13031));

    if (result != ProgressDialogHelper::Success)
    {
      CLog::Log(LOGNOTICE,"WakeOnAccess timeout/cancel while waiting for response");
      return false; // timedout or canceled
    }
  }

  // we have ping response ; just add extra wait-for-services before returning if requested

  {
    WaitCondition waitObj ; // wait uninteruptable fixed time for services ..

    dlg.ShowAndWait (waitObj, server.wait_services_sec, LOCALIZED(13032));

    CLog::Log(LOGNOTICE,"WakeOnAccess sequence completed, server started");
  }
  return true;
}
Пример #14
0
void DeviceInfo::gatherInfo()
{
	Settings* settings = Settings::LunaSettings();

	// Display information --------------------------------------------------------
	m_screenDensity = 1.0f;
	m_hardwareScreenWidth = settings->displayWidth;
	m_hardwareScreenHeight = settings->displayHeight;

	m_screenWidth = (int) (m_hardwareScreenWidth / m_screenDensity);
	m_screenHeight = (int) (m_hardwareScreenHeight / m_screenDensity);

	int maxNegativeSpaceHeight = (int) (settings->maximumNegativeSpaceHeightRatio *
										m_screenHeight);
		
	m_maximumCardWidth = m_screenWidth;
	m_maximumCardHeight = m_screenHeight - settings->positiveSpaceTopPadding;

	m_minimumCardWidth = m_screenWidth;
	m_minimumCardHeight = m_screenHeight - settings->positiveSpaceTopPadding -
						  maxNegativeSpaceHeight;

	m_touchableRows = (m_screenHeight
					   - settings->positiveSpaceTopPadding
					   - settings->positiveSpaceBottomPadding) / kTouchableHeight;

	// Platform Info --------------------------------------------------------------

	getLunaPrefSystemValue("com.palm.properties.ProdSN", m_serialNumber);
	getLunaPrefSystemValue("com.palm.properties.DMCARRIER", m_carrierName);

	// If getLunaPrefSystemValue fails, such as luna-prefs not yet built for the platform, return
        // a sane version number for applications
        if(!getLunaPrefSystemValue("com.palm.properties.version", m_platformVersion))
        {
            // This should only be returned if the luna-prefs package is not working, or
            // the luna-prefs system version has not been set.
            m_platformVersion = "3.5.0";
        }
        else if (m_platformVersion.find("Palm webOS ", 0) != std::string::npos)
        {
            m_platformVersion = m_platformVersion.substr(11);
        }
        else if (m_platformVersion.find("HP webOS ", 0) != std::string::npos)
        {
            m_platformVersion = m_platformVersion.substr(9);
        } 
        else if (m_platformVersion.find("Open webOS ", 0) != std::string::npos)
        {
            m_platformVersion = m_platformVersion.substr(11);
        }

        std::string platformVersion = m_platformVersion;

        size_t npos1 = 0, npos2 = 0;
        npos1 = platformVersion.find_first_of ('.');
        if (npos1 != std::string::npos && npos1 <= platformVersion.size() - 1)
            npos2 = platformVersion.find_first_of ('.', npos1 + 1);
        if (npos1 == std::string::npos || npos2 == std::string::npos)  {
            m_platformVersionMajor = m_platformVersionMinor = m_platformVersionDot = -1;
        }
        else {
            m_platformVersionMajor = atoi ((platformVersion.substr (0, npos1)).c_str());
            m_platformVersionMinor = atoi ((platformVersion.substr (npos1+1, npos2)).c_str());
            m_platformVersionDot = atoi ((platformVersion.substr (npos2+1)).c_str());
        }

	// WIFI and bluetooth ---------------------------------------------------------

	std::string dummy;

	if (getLunaPrefSystemValue("com.palm.properties.WIFIoADDR", dummy))
		m_wifiAvailable = true;
	else
		m_wifiAvailable = false;

	if (getLunaPrefSystemValue("com.palm.properties.BToADDR", dummy))
		m_bluetoothAvailable = true;
	else
		m_bluetoothAvailable = false;


	// RadioType and carrier availability -----------------------------------------
    gchar* buffer;
    gsize sz;
    int token = 0;

    if( !g_file_get_contents( "/dev/tokens/RadioType", &buffer, &sz, 0 ) ) {
    	g_warning("RadioType token not found!");
    	m_radioType = 0;
    } else {
        token = atoi(buffer);

        g_free(buffer);
        m_radioType = token;
    }

/*	
	// Storage --------------------------------------------------------------------

	getLunaPrefSystemValue("com.palm.properties.storageCapacity", dummy);
	if (!dummy.empty())
		m_storageTotal = strtod(dummy.c_str(), NULL);
	else
		m_storageTotal = 0.0;
*/

	// Keyboard configration -----------------------------------------------------

	std::string hwName = HostBase::instance()->hardwareName();
        if (hwName == "Desktop") {
            m_modelName = "Desktop";
            m_modelNameAscii = "Desktop";
            m_keyboardAvailable = true;
            m_keyboardSlider = false;
            m_coreNaviButton = true;
            m_keyboardType = "QWERTY";
            m_swappableBattery = false;
        } else {
            if (!getLunaPrefSystemValue("com.palm.properties.deviceNameShortBranded", m_modelName))
                m_modelName = "webOS smartphone";

		if (!getLunaPrefSystemValue("com.palm.properties.deviceNameShort", m_modelNameAscii))
			m_modelNameAscii = "webOS smartphone";
		
		m_keyboardSlider = false;
		m_coreNaviButton = false;
        m_keyboardAvailable = false;
		m_swappableBattery = false;

		// Castle
#if defined(MACHINE_CASTLE)		
		if (hwName.find("Castle Plus", 0) != std::string::npos
				|| hwName.find ("Roadrunner", 0) != std::string::npos) {

			m_keyboardSlider = true;
			m_coreNaviButton = false;
			m_swappableBattery = true;
		}
		else if (hwName.find("Castle", 0) != std::string::npos) {

			m_keyboardSlider = true;
			m_coreNaviButton = true;
			m_swappableBattery = true;
		}
#endif

#if defined(MACHINE_WINDSOR)
		if (hwName.find("Windsor", 0) != std::string::npos) {
			
			m_keyboardSlider = true;
			m_coreNaviButton = false;
			m_swappableBattery = true;
		}
#endif

#if defined(MACHINE_BROADWAY)
		if (hwName.find("Broadway", 0) != std::string::npos) {
			
			m_keyboardSlider = true;
			m_coreNaviButton = false;
			m_swappableBattery = false;
		}
#endif
		
#if defined(MACHINE_PIXIE)
		if (hwName.find("Pixie", 0) != std::string::npos) {

			m_keyboardSlider = false;
			m_coreNaviButton = false;
			m_swappableBattery = true;
		}
#endif		

		if (getLunaPrefSystemValue("com.palm.properties.KEYoBRD", dummy)) {

			m_keyboardAvailable = true;
			
			if (dummy == "z")
				m_keyboardType = "QWERTY";
			else if (dummy == "w")
				m_keyboardType = "AZERTY";
			else if (dummy == "y")
				m_keyboardType = "QWERTZ";
			else if (dummy == "w1")
				m_keyboardType = "AZERTY_FR";
			else if (dummy == "y1")
				m_keyboardType = "QWERTZ_DE";
			else
				m_keyboardType = LOCALIZED("Unknown");
		}
        else {
            m_keyboardAvailable = false;
            m_keyboardType = LOCALIZED("Unknown");
        }
	}

	// Compose json string from the parameters  -------------------------------

	json_object* json = json_object_new_object();

	json_object_object_add(json, (char*) "modelName", json_object_new_string(m_modelName.c_str()));
	json_object_object_add(json, (char*) "modelNameAscii", json_object_new_string(m_modelNameAscii.c_str()));
	json_object_object_add(json, (char*) "platformVersion", json_object_new_string(m_platformVersion.c_str()));
	json_object_object_add(json, (char*) "platformVersionMajor", json_object_new_int (m_platformVersionMajor));
	json_object_object_add(json, (char*) "platformVersionMinor", json_object_new_int (m_platformVersionMinor));
	json_object_object_add(json, (char*) "platformVersionDot", json_object_new_int (m_platformVersionDot));
	json_object_object_add(json, (char*) "carrierName", json_object_new_string(m_carrierName.c_str()));
	json_object_object_add(json, (char*) "serialNumber", json_object_new_string(m_serialNumber.c_str()));

	json_object_object_add(json, (char*) "screenWidth", json_object_new_int(m_screenWidth));
	json_object_object_add(json, (char*) "screenHeight", json_object_new_int(m_screenHeight));

	json_object_object_add(json, (char*) "minimumCardWidth", json_object_new_int(m_minimumCardWidth));
	json_object_object_add(json, (char*) "minimumCardHeight", json_object_new_int(m_minimumCardHeight));
	json_object_object_add(json, (char*) "maximumCardWidth", json_object_new_int(m_maximumCardWidth));
	json_object_object_add(json, (char*) "maximumCardHeight", json_object_new_int(m_maximumCardHeight));

	json_object_object_add(json, (char*) "touchableRows", json_object_new_int(m_touchableRows));
	
	json_object_object_add(json, (char*) "keyboardAvailable", json_object_new_boolean(m_keyboardAvailable));
	json_object_object_add(json, (char*) "keyboardSlider", json_object_new_boolean(m_keyboardSlider));
	json_object_object_add(json, (char*) "keyboardType", json_object_new_string(m_keyboardType.c_str()));

	json_object_object_add(json, (char*) "wifiAvailable", json_object_new_boolean(m_wifiAvailable));
	json_object_object_add(json, (char*) "bluetoothAvailable", json_object_new_boolean(m_bluetoothAvailable));

	json_object_object_add(json, (char*) "carrierAvailable", json_object_new_boolean(carrierAvailable()));

	json_object_object_add(json, (char*) "coreNaviButton", json_object_new_boolean(m_coreNaviButton));
	
	json_object_object_add(json, (char*) "swappableBattery", json_object_new_boolean(m_swappableBattery));
	json_object_object_add(json, (char*) "dockModeEnabled", json_object_new_boolean(true));

	m_jsonString = json_object_to_json_string(json);

	json_object_put(json);
}
QString SysmgrIMEModel::getLocalizedString(const std::string &str)
{
    return fromStdUtf8(LOCALIZED(str));
}