/* -*- 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 #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. Boolean MPreferenceBase::sUseTempPrefPrefix = false; // must be one for all instantiations of the template. char* MPreferenceBase::sReplacementString = nil; const char * kTempPrefPrefix = "temp_pref_mac"; // prepended to the prefs string //======================================================================================== 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( LPane* inPane , LStream* inStream) //---------------------------------------------------------------------------------------- : mName(nil) , mSubstitutedName(nil) , mLocked(false) , mWritePref(true) , mPaneSelf(inPane) { CStr255 text; inStream->ReadPString(text); SetPrefName((const char*)text, false); *inStream >> mOrdinal; } // MPreferenceBase::MPreferenceBase //---------------------------------------------------------------------------------------- MPreferenceBase::~MPreferenceBase() //---------------------------------------------------------------------------------------- { XP_FREEIF(const_cast(mSubstitutedName)); mSubstitutedName = nil; XP_FREEIF(const_cast(mName)); mName = nil; } // 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); if (sUseTempPrefPrefix) { mName = XP_STRDUP(kTempPrefPrefix); StrAllocCat(mName, text); } else mName = XP_STRDUP((const char*)text); */ XP_FREEIF(const_cast(mName)); mName = XP_STRDUP(inNewName); if (inReread) { ReadLockState(); ReadSelf(); } } // MPreferenceBase::ReadLockState //---------------------------------------------------------------------------------------- /*static*/ void MPreferenceBase::SetReplacementString(const char* s) //---------------------------------------------------------------------------------------- { XP_FREEIF(sReplacementString); sReplacementString = (s != nil) ? XP_STRDUP(s) : nil; } //---------------------------------------------------------------------------------------- /*static*/ 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); } //---------------------------------------------------------------------------------------- /*static*/ void MPreferenceBase::SetPaneWritePref(LView* inSuperView, PaneIDT inPaneID, Boolean inWritePref) //---------------------------------------------------------------------------------------- { LPane* p = inSuperView->FindPaneByID(inPaneID); MPreferenceBase* pb = dynamic_cast(p); SignalIf_(!pb); if (pb) pb->SetWritePref(inWritePref); } //---------------------------------------------------------------------------------------- /*static*/ const char* MPreferenceBase::GetPanePrefName(LView* inSuperView, PaneIDT inPaneID) //---------------------------------------------------------------------------------------- { LPane* p = inSuperView->FindPaneByID(inPaneID); MPreferenceBase* pb = dynamic_cast(p); SignalIf_(!pb); if (pb) return XP_STRDUP(pb->GetPrefName()); return nil; } //---------------------------------------------------------------------------------------- /*static*/ const char* MPreferenceBase::GetPaneUnsubstitutedPrefName(LView* inSuperView, PaneIDT inPaneID) //---------------------------------------------------------------------------------------- { LPane* p = inSuperView->FindPaneByID(inPaneID); MPreferenceBase* pb = dynamic_cast(p); SignalIf_(!pb); if (pb) return XP_STRDUP(pb->mName); return nil; } //---------------------------------------------------------------------------------------- const char* MPreferenceBase::GetPrefName() //---------------------------------------------------------------------------------------- { CStr255 subName(mName); if (sReplacementString && *sReplacementString) ::StringParamText(subName, sReplacementString); XP_FREEIF(const_cast(mSubstitutedName)); if (sUseTempPrefPrefix) { CStr255 newName(kTempPrefPrefix); newName += "."; newName += subName; mSubstitutedName = XP_STRDUP(newName); } else mSubstitutedName = XP_STRDUP(subName); return mSubstitutedName; } //---------------------------------------------------------------------------------------- const char* MPreferenceBase::GetValidPrefName() // Get the pref name, with or without the prefix depending on whether the prefixed // preference exists or not. //---------------------------------------------------------------------------------------- { CStr255 subName(mName); if (sReplacementString && *sReplacementString) ::StringParamText(subName, sReplacementString); XP_FREEIF(const_cast(mSubstitutedName)); if (sUseTempPrefPrefix) { CStr255 newName(kTempPrefPrefix); newName += "."; newName += subName; if (PREF_GetPrefType(newName) == PREF_ERROR) mSubstitutedName = XP_STRDUP(subName); // the prefixed pref does not exist. else mSubstitutedName = XP_STRDUP(newName); } else mSubstitutedName = XP_STRDUP(subName); return mSubstitutedName; } //---------------------------------------------------------------------------------------- const char* MPreferenceBase::GetUnsubstitutedPrefName() //---------------------------------------------------------------------------------------- { return XP_STRDUP(mName); } //---------------------------------------------------------------------------------------- void MPreferenceBase::ReadLockState() //---------------------------------------------------------------------------------------- { mLocked = PREF_PrefIsLocked(GetPrefName()); 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 || !mWritePref) 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 //---------------------------------------------------------------------------------------- /*static*/ void MPreferenceBase::InitTempPrefCache() //---------------------------------------------------------------------------------------- { // delete the temp pref tree PREF_DeleteBranch(kTempPrefPrefix); } //---------------------------------------------------------------------------------------- /*static*/ void MPreferenceBase::CopyCachedPrefsToMainPrefs() //---------------------------------------------------------------------------------------- { int result; result = PREF_CopyPrefsTree(kTempPrefPrefix, ""); Assert_(result == PREF_NOERROR); result = PREF_DeleteBranch(kTempPrefPrefix); Assert_(result == PREF_NOERROR); } #pragma mark - //---------------------------------------------------------------------------------------- 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 & kOrdinalIntBit) { int32 intValue; typedef int (*IntPrefReadFunc)(const char*, int32*); prefResult = ((IntPrefReadFunc)inFunc)(GetValidPrefName(), &intValue); value = intValue; } else prefResult = inFunc(GetValidPrefName(), &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(GetPrefName(), GetPrefValue()); else PREF_SetBoolPref(GetPrefName(), 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 - // Why the heck would we want a prefcontrol that is just a caption? Only for the use of the // resource template to supply an extra string which initially holds the pref name. // CSpecialFolderCaption is derived from this. //---------------------------------------------------------------------------------------- XP_Bool MPreference::GetPaneValue() const //---------------------------------------------------------------------------------------- { return false; } // MPreference::GetPaneValue //---------------------------------------------------------------------------------------- void MPreference::SetPaneValue(XP_Bool) //---------------------------------------------------------------------------------------- { } // MPreference::SetPaneValue //---------------------------------------------------------------------------------------- Boolean MPreference::Changed() const //---------------------------------------------------------------------------------------- { return false; } // MPreference::Changed //---------------------------------------------------------------------------------------- void MPreference::InitializeUsing(PrefReadFunc) //---------------------------------------------------------------------------------------- { } // MPreference::InitializeUsing //---------------------------------------------------------------------------------------- void MPreference::ReadSelf() //---------------------------------------------------------------------------------------- { InitializeUsing(PREF_GetBoolPref); mInitialControlValue = false; } // MPreference::ReadSelf //---------------------------------------------------------------------------------------- void MPreference::ReadDefaultSelf() //---------------------------------------------------------------------------------------- { if (!IsLocked()) InitializeUsing(PREF_GetDefaultBoolPref); } // MPreference::ReadDefaultSelf //---------------------------------------------------------------------------------------- void MPreference::WriteSelf() //---------------------------------------------------------------------------------------- { } // MPreference::WriteSelf //---------------------------------------------------------------------------------------- XP_Bool MPreference::GetPrefValue() const //---------------------------------------------------------------------------------------- { return false; } // 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(GetValidPrefName(), &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(GetPrefName(), mOrdinal); } // MPreference::WriteSelf //---------------------------------------------------------------------------------------- int32 MPreference::GetPrefValue() const //---------------------------------------------------------------------------------------- { return mOrdinal; } // MPreference::GetPrefValue template class MPreference; #pragma mark - //---------------------------------------------------------------------------------------- #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) //---------------------------------------------------------------------------------------- { ((LTextEditView*)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(GetValidPrefName(), &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(GetPrefName(), GetPaneValue()); } // MPreference::WriteSelf //---------------------------------------------------------------------------------------- char* MPreference::GetPrefValue() const //---------------------------------------------------------------------------------------- { return GetPaneValue(); } // MPreference::GetPrefValue template class MPreference; // This is used for captions, and for mixing in with another pref control (eg, to // control the descriptor of a checkbox). #pragma mark - //---------------------------------------------------------------------------------------- #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) //---------------------------------------------------------------------------------------- { ((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(GetValidPrefName(), &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 - //---------------------------------------------------------------------------------------- #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(GetValidPrefName(), &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(GetPrefName(), 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 ((LTextEditView*)mPaneSelf)->GetValue(); } // MPreference::GetPaneValue //---------------------------------------------------------------------------------------- void MPreference::SetPaneValue(int32 inData) //---------------------------------------------------------------------------------------- { ((LTextEditView*)mPaneSelf)->SetValue(inData); } // MPreference:SetPaneValue //---------------------------------------------------------------------------------------- Boolean MPreference::Changed() const //---------------------------------------------------------------------------------------- { return GetPaneValue() != mInitialControlValue; } // MPreference::Changed //---------------------------------------------------------------------------------------- void MPreference::InitializeUsing(PrefReadFunc inFunc) //---------------------------------------------------------------------------------------- { int32 value; int prefResult = inFunc(GetValidPrefName(), &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(GetPrefName(), 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)(GetValidPrefName(), &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(GetPrefName(), value.red >> 8, value.green >> 8, value.blue >> 8); } } // MPreference::WriteSelf //---------------------------------------------------------------------------------------- RGBColor MPreference::GetPrefValue() const //---------------------------------------------------------------------------------------- { return GetPaneValue(); } // MPreference::GetPrefValue template class MPreference;