/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- * * The contents of this file are subject to the Netscape Public License * Version 1.0 (the "NPL"); you may not use this file except in * compliance with the NPL. You may obtain a copy of the NPL at * http://www.mozilla.org/NPL/ * * Software distributed under the NPL is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL * for the specific language governing rights and limitations under the * NPL. * * The Initial Developer of this code under the NPL is Netscape * Communications Corporation. Portions created by Netscape are * Copyright (C) 1998 Netscape Communications Corporation. All Rights * Reserved. */ #include "MPreference.h" #include "PascalString.h" #include #include #include "xp_mcom.h" #include "prefapi.h" #include "macutil.h" // for StringParamText #include "prefwutil.h" // for CColorButton #include "StSetBroadcasting.h" #include "CTooltipAttachment.h" Boolean MPreferenceBase::sWriteOnDestroy = false; // must be one for all instantiations of the template. const char* MPreferenceBase::sReplacementString = nil; #pragma mark ---CDebugPrefToolTipAttachment--- //======================================================================================== class CDebugPrefToolTipAttachment : public CToolTipAttachment //======================================================================================== { public: enum { class_ID = 'X%W@' }; CDebugPrefToolTipAttachment(MPreferenceBase* b); protected: virtual void CalcTipText( LWindow* inOwningWindow, LPane* inOwningPane, const EventRecord& inMacEvent, StringPtr outTipText); MPreferenceBase* mPreferenceBase; }; // class CDebugPrefToolTipAttachment //---------------------------------------------------------------------------------------- CDebugPrefToolTipAttachment::CDebugPrefToolTipAttachment(MPreferenceBase* b) //---------------------------------------------------------------------------------------- : CToolTipAttachment(60, 11507) , mPreferenceBase(b) { } //---------------------------------------------------------------------------------------- void CDebugPrefToolTipAttachment::CalcTipText( //---------------------------------------------------------------------------------------- LWindow* /* inOwningWindow */, LPane* /* inOwningPane */, const EventRecord& /* inMacEvent */, StringPtr outTipText) { *(CStr255*)outTipText = mPreferenceBase->mName; } #pragma mark ---MPreferenceBase--- //---------------------------------------------------------------------------------------- MPreferenceBase::MPreferenceBase( LPane* inPane , LStream* inStream) //---------------------------------------------------------------------------------------- : mName(nil) , mLocked(false) , mPaneSelf(inPane) { CStr255 text; inStream->ReadPString(text); SetPrefName((const char*)text, false); *inStream >> mOrdinal; } // MPreferenceBase::MPreferenceBase //---------------------------------------------------------------------------------------- MPreferenceBase::~MPreferenceBase() //---------------------------------------------------------------------------------------- { XP_FREEIF(const_cast(mName)); } // MPreferenceBase::~MPreferenceBase //---------------------------------------------------------------------------------------- void MPreferenceBase::SetPrefName(const char* inNewName, Boolean inReread) //---------------------------------------------------------------------------------------- { const char* oldName = mName; // so that inNewName == mName works CStr255 text(inNewName); if (sReplacementString && *sReplacementString) ::StringParamText(text, sReplacementString); mName = XP_STRDUP((const char*)text); XP_FREEIF(const_cast(oldName)); if (inReread) { ReadLockState(); ReadSelf(); } } // MPreferenceBase::ReadLockState //---------------------------------------------------------------------------------------- void MPreferenceBase::ChangePrefName(LView* inSuperView, PaneIDT inPaneID, const char* inNewName) //---------------------------------------------------------------------------------------- { LPane* p = inSuperView->FindPaneByID(inPaneID); MPreferenceBase* pb = dynamic_cast(p); SignalIf_(!pb); if (pb) pb->SetPrefName(inNewName); } //---------------------------------------------------------------------------------------- const char* MPreferenceBase::GetPrefName(LView* inSuperView, PaneIDT inPaneID) //---------------------------------------------------------------------------------------- { LPane* p = inSuperView->FindPaneByID(inPaneID); MPreferenceBase* pb = dynamic_cast(p); SignalIf_(!pb); if (pb) return pb->GetPrefName(); return nil; } //---------------------------------------------------------------------------------------- const char* MPreferenceBase::GetPrefName() const //---------------------------------------------------------------------------------------- { return XP_STRDUP(mName); } //---------------------------------------------------------------------------------------- void MPreferenceBase::ReadLockState() //---------------------------------------------------------------------------------------- { mLocked = PREF_PrefIsLocked(mName); if (mLocked) mPaneSelf->Disable(); } // MPreferenceBase::ReadLockState //---------------------------------------------------------------------------------------- void MPreferenceBase::FinishCreate() //---------------------------------------------------------------------------------------- { ReadLockState(); ReadSelf(); #ifdef DEBUG LAttachable::SetDefaultAttachable(mPaneSelf); CDebugPrefToolTipAttachment* a = new CDebugPrefToolTipAttachment(this); mPaneSelf->AddAttachment(a); #endif } // MPreferenceBase::FinishCreate //---------------------------------------------------------------------------------------- Boolean MPreferenceBase::ShouldWrite() const //---------------------------------------------------------------------------------------- { if (!sWriteOnDestroy || mLocked) return false; if (strstr(mName, "^0") != nil) // yow! unreplaced strings { // Check if a replacement has become possible Assert_(sReplacementString && *sReplacementString); if (!sReplacementString || !*sReplacementString) return false; const_cast(this)->SetPrefName(mName, false); // don't read } return true; // Note: don't worry about testing Changed(), since preflib does that. } // MPreferenceBase::ShouldWrite #pragma mark ---MPreference--- //---------------------------------------------------------------------------------------- template MPreference::MPreference( LPane* inPane, LStream* inStream) //---------------------------------------------------------------------------------------- : MPreferenceBase(inPane, inStream) { } // MPreference::MPreference //---------------------------------------------------------------------------------------- template MPreference::~MPreference() //---------------------------------------------------------------------------------------- { } // MPreference::~MPreference #pragma mark - enum // what the ordinal means in this case: { kOrdinalXORBit = 1<<0 , kOrdinalIntBit = 1<<1 }; //---------------------------------------------------------------------------------------- XP_Bool MPreference::GetPaneValue() const //---------------------------------------------------------------------------------------- { return ((LControl*)mPaneSelf)->GetValue(); } // MPreference::GetPaneValue //---------------------------------------------------------------------------------------- void MPreference::SetPaneValue(XP_Bool inData) //---------------------------------------------------------------------------------------- { ((LControl*)mPaneSelf)->SetValue(inData); } // MPreference::SetPaneValue //---------------------------------------------------------------------------------------- Boolean MPreference::Changed() const //---------------------------------------------------------------------------------------- { return GetPaneValue() != mInitialControlValue; } // MPreference::Changed //---------------------------------------------------------------------------------------- void MPreference::InitializeUsing(PrefReadFunc inFunc) //---------------------------------------------------------------------------------------- { XP_Bool value; int prefResult; if (mOrdinal & 2) { int32 intValue; typedef int (*IntPrefReadFunc)(const char*, int32*); prefResult = ((IntPrefReadFunc)inFunc)(mName, &intValue); value = intValue; } else prefResult = inFunc(mName, &value); if (prefResult == PREF_NOERROR) SetPaneValue(value ^ (mOrdinal & kOrdinalXORBit)); } // MPreference::InitializeUsing //---------------------------------------------------------------------------------------- void MPreference::ReadSelf() //---------------------------------------------------------------------------------------- { if (mOrdinal & kOrdinalIntBit) // this bit indicates it's an int conversion InitializeUsing((PrefReadFunc)PREF_GetIntPref); else InitializeUsing(PREF_GetBoolPref); mInitialControlValue = GetPaneValue(); } // MPreference::ReadSelf //---------------------------------------------------------------------------------------- void MPreference::ReadDefaultSelf() //---------------------------------------------------------------------------------------- { if (!IsLocked()) if (mOrdinal & kOrdinalIntBit) // this bit indicates it's an int conversion InitializeUsing((PrefReadFunc)PREF_GetDefaultIntPref); else InitializeUsing(PREF_GetDefaultBoolPref); } // MPreference::ReadDefaultSelf //---------------------------------------------------------------------------------------- void MPreference::WriteSelf() //---------------------------------------------------------------------------------------- { if (ShouldWrite()) { if (mOrdinal & kOrdinalIntBit) // this bit indicates it's an int conversion PREF_SetIntPref(mName, GetPrefValue()); else PREF_SetBoolPref(mName, GetPrefValue()); } } // MPreference::WriteSelf //---------------------------------------------------------------------------------------- XP_Bool MPreference::GetPrefValue() const //---------------------------------------------------------------------------------------- { // xor the boolean value with the low-order bit of the ordinal return (XP_Bool)(mPaneSelf->GetValue() ^ (mOrdinal & kOrdinalXORBit)); } // MPreference::GetPrefValue template class MPreference; #pragma mark - //---------------------------------------------------------------------------------------- int32 MPreference::GetPaneValue() const //---------------------------------------------------------------------------------------- { return ((LControl*)mPaneSelf)->GetValue(); } // MPreference::GetPaneValue //---------------------------------------------------------------------------------------- void MPreference::SetPaneValue(int32 inData) //---------------------------------------------------------------------------------------- { ((LControl*)mPaneSelf)->SetValue(inData); } // MPreference::SetPaneValue //---------------------------------------------------------------------------------------- Boolean MPreference::Changed() const //---------------------------------------------------------------------------------------- { return GetPaneValue() != mInitialControlValue; } // MPreference::Changed //---------------------------------------------------------------------------------------- void MPreference::InitializeUsing(PrefReadFunc inFunc) //---------------------------------------------------------------------------------------- { int32 value; int prefResult = inFunc(mName, &value); if (prefResult == PREF_NOERROR) { if (value == mOrdinal) SetPaneValue(1); // tab group will turn others off. } } // MPreference::InitializeUsing //---------------------------------------------------------------------------------------- void MPreference::ReadSelf() //---------------------------------------------------------------------------------------- { InitializeUsing(PREF_GetIntPref); mInitialControlValue = GetPaneValue(); } // MPreference::ReadSelf //---------------------------------------------------------------------------------------- void MPreference::ReadDefaultSelf() //---------------------------------------------------------------------------------------- { if (!IsLocked()) InitializeUsing(PREF_GetDefaultIntPref); } // MPreference::ReadDefaultSelf //---------------------------------------------------------------------------------------- void MPreference::WriteSelf() //---------------------------------------------------------------------------------------- { if (ShouldWrite()) PREF_SetIntPref(mName, mOrdinal); } // MPreference::WriteSelf //---------------------------------------------------------------------------------------- int32 MPreference::GetPrefValue() const //---------------------------------------------------------------------------------------- { return mOrdinal; } // MPreference::GetPrefValue template class MPreference; #pragma mark - //---------------------------------------------------------------------------------------- MPreference::~MPreference() //---------------------------------------------------------------------------------------- { XP_FREEIF(mInitialControlValue); } // MPreference::CleanUpData //---------------------------------------------------------------------------------------- char* MPreference::GetPaneValue() const //---------------------------------------------------------------------------------------- { CStr255 value; mPaneSelf->GetDescriptor(value); return (char*)value; } // MPreference::GetPaneValue //---------------------------------------------------------------------------------------- void MPreference::SetPaneValue(char* inData) //---------------------------------------------------------------------------------------- { ((LTextEdit*)mPaneSelf)->SetDescriptor(CStr255(inData)); } // MPreference:SetPaneValue //---------------------------------------------------------------------------------------- Boolean MPreference::Changed() const //---------------------------------------------------------------------------------------- { char* value = GetPaneValue(); if (value && *value) return (strcmp(value, mInitialControlValue) != 0); return true; } // MPreference::Changed //---------------------------------------------------------------------------------------- void MPreference::InitializeUsing(PrefReadFunc inFunc) //---------------------------------------------------------------------------------------- { char* value; int prefResult = inFunc(mName, &value); if (prefResult == PREF_NOERROR) { SetPaneValue(value); XP_FREEIF(value); } } // MPreference::InitializeUsing //---------------------------------------------------------------------------------------- void MPreference::ReadSelf() //---------------------------------------------------------------------------------------- { InitializeUsing(PREF_CopyCharPref); mInitialControlValue = XP_STRDUP(GetPaneValue()); } // MPreference::ReadSelf //---------------------------------------------------------------------------------------- void MPreference::ReadDefaultSelf() //---------------------------------------------------------------------------------------- { if (!IsLocked()) InitializeUsing(PREF_CopyDefaultCharPref); } // MPreference::ReadDefaultSelf //---------------------------------------------------------------------------------------- void MPreference::WriteSelf() //---------------------------------------------------------------------------------------- { if (ShouldWrite()) PREF_SetCharPref(mName, GetPaneValue()); } // MPreference::WriteSelf //---------------------------------------------------------------------------------------- char* MPreference::GetPrefValue() const //---------------------------------------------------------------------------------------- { return GetPaneValue(); } // MPreference::GetPrefValue template class MPreference; #pragma mark - // This is used for captions, and for mixing in with another pref control (eg, to // control the descriptor of a checkbox). //---------------------------------------------------------------------------------------- MPreference::~MPreference() //---------------------------------------------------------------------------------------- { XP_FREEIF(mInitialControlValue); } // MPreference::CleanUpData //---------------------------------------------------------------------------------------- char* MPreference::GetPaneValue() const //---------------------------------------------------------------------------------------- { CStr255 value; mPaneSelf->GetDescriptor(value); return (char*)value; } // MPreference::GetPaneValue //---------------------------------------------------------------------------------------- void MPreference::SetPaneValue(char* inData) //---------------------------------------------------------------------------------------- { ((LPane*)mPaneSelf)->SetDescriptor(CStr255(inData)); } // MPreference:SetPaneValue //---------------------------------------------------------------------------------------- Boolean MPreference::Changed() const //---------------------------------------------------------------------------------------- { char* value = GetPaneValue(); if (value && *value) return (strcmp(value, mInitialControlValue) != 0); return true; } // MPreference::Changed //---------------------------------------------------------------------------------------- void MPreference::InitializeUsing(PrefReadFunc inFunc) //---------------------------------------------------------------------------------------- { char* value; int prefResult = inFunc(mName, &value); if (prefResult == PREF_NOERROR) { SetPaneValue(value); XP_FREEIF(value); } } // MPreference::InitializeUsing //---------------------------------------------------------------------------------------- void MPreference::ReadSelf() //---------------------------------------------------------------------------------------- { InitializeUsing(PREF_CopyCharPref); mInitialControlValue = XP_STRDUP(GetPaneValue()); } // MPreference::ReadSelf //---------------------------------------------------------------------------------------- void MPreference::ReadDefaultSelf() //---------------------------------------------------------------------------------------- { if (!IsLocked()) InitializeUsing(PREF_CopyDefaultCharPref); } // MPreference::ReadDefaultSelf //---------------------------------------------------------------------------------------- void MPreference::WriteSelf() //---------------------------------------------------------------------------------------- { } // MPreference::WriteSelf //---------------------------------------------------------------------------------------- char* MPreference::GetPrefValue() const //---------------------------------------------------------------------------------------- { return GetPaneValue(); } // MPreference::GetPrefValue template class MPreference; #pragma mark - //---------------------------------------------------------------------------------------- MPreference::~MPreference() //---------------------------------------------------------------------------------------- { XP_FREEIF(mInitialControlValue); } // MPreference::CleanUpData //---------------------------------------------------------------------------------------- char* MPreference::GetPaneValue() const //---------------------------------------------------------------------------------------- { Int32 itemNumber = ((LGAPopup*)mPaneSelf)->GetValue(); CStr255 itemString; if (itemNumber > 0) { MenuHandle menuH = ((LGAPopup*)mPaneSelf)->GetMacMenuH(); ::GetMenuItemText(menuH, itemNumber, itemString); } return (char*)itemString; } // MPreference::GetPaneValue //---------------------------------------------------------------------------------------- void MPreference::SetPaneValue(char* inData) //---------------------------------------------------------------------------------------- { if (!inData || !*inData) return; MenuHandle menuH = ((LGAPopup*)mPaneSelf)->GetMacMenuH(); short menuSize = ::CountMItems(menuH); CStr255 itemString; for (short menuItem = 1; menuItem <= menuSize; ++menuItem) { ::GetMenuItemText(menuH, menuItem, itemString); if (itemString == inData) { StSetBroadcasting dontBroadcast((LGAPopup*)mPaneSelf, false); ((LGAPopup*)mPaneSelf)->SetValue(menuItem); return; } } } // MPreference:SetPaneValue //---------------------------------------------------------------------------------------- Boolean MPreference::Changed() const //---------------------------------------------------------------------------------------- { char* value = GetPaneValue(); if (value && *value) return (strcmp(value, mInitialControlValue) != 0); return true; } // MPreference::Changed //---------------------------------------------------------------------------------------- void MPreference::InitializeUsing(PrefReadFunc inFunc) //---------------------------------------------------------------------------------------- { char* value; int prefResult = inFunc(mName, &value); if (prefResult == PREF_NOERROR) { SetPaneValue(value); XP_FREEIF(value); } } // MPreference::InitializeUsing //---------------------------------------------------------------------------------------- void MPreference::ReadSelf() //---------------------------------------------------------------------------------------- { InitializeUsing(PREF_CopyCharPref); mInitialControlValue = XP_STRDUP(GetPaneValue()); } // MPreference::ReadSelf //---------------------------------------------------------------------------------------- void MPreference::ReadDefaultSelf() //---------------------------------------------------------------------------------------- { if (!IsLocked()) InitializeUsing(PREF_CopyDefaultCharPref); } // MPreference::ReadDefaultSelf //---------------------------------------------------------------------------------------- void MPreference::WriteSelf() //---------------------------------------------------------------------------------------- { if (ShouldWrite()) PREF_SetCharPref(mName, GetPaneValue()); } // MPreference::WriteSelf //---------------------------------------------------------------------------------------- char* MPreference::GetPrefValue() const //---------------------------------------------------------------------------------------- { return GetPaneValue(); } // MPreference::GetPrefValue template class MPreference; #pragma mark - //---------------------------------------------------------------------------------------- MPreference::~MPreference() //---------------------------------------------------------------------------------------- { } // MPreference::CleanUpData //---------------------------------------------------------------------------------------- int32 MPreference::GetPaneValue() const //---------------------------------------------------------------------------------------- { return ((LTextEdit*)mPaneSelf)->GetValue(); } // MPreference::GetPaneValue //---------------------------------------------------------------------------------------- void MPreference::SetPaneValue(int32 inData) //---------------------------------------------------------------------------------------- { ((LTextEdit*)mPaneSelf)->SetValue(inData); } // MPreference:SetPaneValue //---------------------------------------------------------------------------------------- Boolean MPreference::Changed() const //---------------------------------------------------------------------------------------- { return GetPaneValue() != mInitialControlValue; } // MPreference::Changed //---------------------------------------------------------------------------------------- void MPreference::InitializeUsing(PrefReadFunc inFunc) //---------------------------------------------------------------------------------------- { int32 value; int prefResult = inFunc(mName, &value); if (prefResult == PREF_NOERROR) SetPaneValue(value); } // MPreference::InitializeUsing //---------------------------------------------------------------------------------------- void MPreference::ReadSelf() //---------------------------------------------------------------------------------------- { InitializeUsing(PREF_GetIntPref); mInitialControlValue = GetPaneValue(); } // MPreference::ReadSelf //---------------------------------------------------------------------------------------- void MPreference::ReadDefaultSelf() //---------------------------------------------------------------------------------------- { if (!IsLocked()) InitializeUsing(PREF_GetDefaultIntPref); } // MPreference::ReadDefaultSelf //---------------------------------------------------------------------------------------- void MPreference::WriteSelf() //---------------------------------------------------------------------------------------- { if (ShouldWrite()) PREF_SetIntPref(mName, GetPaneValue()); } // MPreference::WriteSelf //---------------------------------------------------------------------------------------- int32 MPreference::GetPrefValue() const //---------------------------------------------------------------------------------------- { return GetPaneValue(); } // MPreference::GetPrefValue template class MPreference; #pragma mark - // The function signature for reading colors is not like the other types. Here is // its prototype, which we use to cast back and forth. typedef int (*ColorReadFunc)(const char*, uint8*, uint8*, uint8*); //---------------------------------------------------------------------------------------- MPreference::~MPreference() //---------------------------------------------------------------------------------------- { } // MPreference::CleanUpData //---------------------------------------------------------------------------------------- RGBColor MPreference::GetPaneValue() const //---------------------------------------------------------------------------------------- { return ((CColorButton*)mPaneSelf)->GetColor(); } // MPreference::GetPaneValue //---------------------------------------------------------------------------------------- void MPreference::SetPaneValue(RGBColor inData) //---------------------------------------------------------------------------------------- { ((CColorButton*)mPaneSelf)->SetColor(inData); mPaneSelf->Refresh(); } // MPreference:SetPaneValue //---------------------------------------------------------------------------------------- Boolean MPreference::Changed() const //---------------------------------------------------------------------------------------- { return memcmp(&GetPaneValue(), &mInitialControlValue, sizeof(RGBColor)) == 0; } // MPreference::Changed //---------------------------------------------------------------------------------------- void MPreference::InitializeUsing(PrefReadFunc inFunc) //---------------------------------------------------------------------------------------- { RGBColor value; uint8 red = 0, green = 0, blue = 0; int prefResult = ((ColorReadFunc)inFunc)(mName, &red, &green, &blue); if (prefResult == PREF_NOERROR) { value.red = red << 8; value.green = green << 8; value.blue = blue << 8; SetPaneValue(value); } } // MPreference::InitializeUsing //---------------------------------------------------------------------------------------- void MPreference::ReadSelf() //---------------------------------------------------------------------------------------- { InitializeUsing((PrefReadFunc)PREF_GetColorPref); mInitialControlValue = GetPaneValue(); } // MPreference::ReadSelf //---------------------------------------------------------------------------------------- void MPreference::ReadDefaultSelf() //---------------------------------------------------------------------------------------- { if (!IsLocked()) InitializeUsing((PrefReadFunc)PREF_GetDefaultColorPref); } // MPreference::ReadDefaultSelf //---------------------------------------------------------------------------------------- void MPreference::WriteSelf() //---------------------------------------------------------------------------------------- { if (ShouldWrite()) { RGBColor value = GetPaneValue(); PREF_SetColorPref(mName, value.red >> 8, value.green >> 8, value.blue >> 8); } } // MPreference::WriteSelf //---------------------------------------------------------------------------------------- RGBColor MPreference::GetPrefValue() const //---------------------------------------------------------------------------------------- { return GetPaneValue(); } // MPreference::GetPrefValue template class MPreference;